# The Waterfall Model

**The Waterfall Model** is an esoteric programming language (or possibly a computational model) created by User:ais523 in 2018. It can be seen as a simplification of counter machines along different lines from The Amnesiac From Minsk; however, similarly to that language, it's intended as a source language for proving the Turing-completeness of other languages by compiling The Waterfall Model into them. Historically, though, it was originally created as a derivative of Kangaroo (and the first informal proof of its Turing-completeness was by analogy with the proof for Kangaroo, although there are simpler and more rigorous proofs available).

The main difference from a standard Minsky machine is that the language has no instruction pointer; like The Amnesiac From Minsk and StackFlow, code only runs as a consequence of counters reducing to zero. However, unlike most similar languages, there is no explicit way to reduce the value of a counter (the "zeroing triggers" can only increase counter values). Rather, the counters conceptually reduce at a standard rate over time; thus, the smallest counter will hit zero first and do some amount of increasing of the counters as a consequence. (Naturally, a counter has to increase its own value when it hits zero, or the program will never be able to make any progress.)

One interesting side consequence of this is that there is no particular reason why the counter values should be restricted to integers, and in fact many natural ways of implementing The Waterfall Model will naturally tend to be able to handle rational or even computable-real values with no additional effort. This can be seen as an extended version of the language, or as an interesting consequence of the model's definition.

## Semantics

A program in The Waterfall Model consists of a number of different *waterclocks*. Each of these has:

- A
*current value*, which is a number (that can change over the lifetime of the program, without changing the waterclock's identity); - and a
*zeroing trigger*, which is a map from waterclocks to nonnegative numbers (that's a fixed and hardcoded part of the program).

The "numbers" here are integers in the most basic form of the language, but using other forms of numbers may be an interesting extension. Note that implementations should be able (at least in theory) to handle unboundedly large numbers, in order to prevent the language collapsing into a bounded-storage machine.

The simplest way to visualise the semantics of the program is to imagine all the waterclocks counting down at the same, constant rate (e.g. their value reduces by 1 every second). When a waterclock's current value hits 0, its zeroing trigger *runs*, increasing the current value of each waterclock by the value that corresponds to it within the zeroing trigger.

Should two waterclocks' current values hit 0 simultaneously, the resulting behaviour is undefined by default. Some implementations may assign defined semantics to this (e.g. reading user input and using it to determine which zeroing trigger to run).

If a waterclock's zeroing trigger runs but fails to increase the value of that waterclock from 0, this conceptually causes an infinite loop (as the zeroing trigger in question runs infinitely many times in a row). Although this is technically a valid implementation of this situation, it's recommended that implementations that do not have a reason to be as simple as possible should detect this situation and halt when it occurs. In order to avoid trivial mistakes and (perhaps) simplify implementations, a program is invalid if a "halt waterclock" (one which fails to increase its own value when zeroed) has a zeroing trigger other than all-zeroes. Along similar lines, waterclocks must not start with 0 as their current value (their current value can hit 0 during execution, but only instantaneously, because the program will either halt or increase the waterclock's value as a consequence of the resulting trigger).

Note that there is no requirement to actually pause for a length of time proportional to the values of the waterclocks; implementations are entirely free to "accelerate time" where it's clear that nothing is happening (e.g. by finding the minimum current value among all waterclocks and subtracting it from each of them). In other words, the timing properties implied by the syntax are not necessarily part of the output of the program (although of course, an implementation could be written where they are).

## Syntax

The Waterfall Model represents programs as a square matrix, containing specifications of the waterclocks, and some additional information to make it easier to construct implementations in low-powered languages.

The first row of the matrix is used for metadata that enables languages that allocate memory explicitly to be able to allocate the memory in advance, rather than needing to reallocate it in the middle of reading the source. The top-left corner contains a number that's larger than any other number that appears in the matrix, to enable implementations to know how large the numbers can get; apart from this constraint, the number is entirely meaningless and can have any sufficiently large value. Each remaining element on the first row is filled with the number of waterclocks. (So for example, if there are three waterclocks, the first row would consist of a large number followed by three 3s.)

Each remaining row describes a waterclock. The first element of the row is the initial current value of the waterclock. The remaining elements are the zeroing trigger; the first remaining element (i.e. the second element) describes the amount that the first waterclock will be topped up by, the second remaining element describes how much water will be used to top up the second clock, and so on.

A matrix of numbers, although a concrete syntax, is a syntax that's not commonly communicated between systems. If a program in The Waterfall Model needs to be stored in a file, the recommendation is to use JSON (i.e. the matrix is a comma-separated list of rows enclosed in `[]`

, and each row is a comma-separated list of numbers enclosed in `[]`

, with whitespace being allowed anywhere outside a number).

## ZISC interpretation

One of the simplest ways to implement The Waterfall Model in a high-level language is to use a ZISC interpretation; in this case, the matrix (that's normally taken as describing the program) is instead seen as the content of memory that a single, repeated command operates on. The command here is "identify the lexicographically smallest matrix row (i.e. the row with the smallest first element), then add the transpose of that row to the first column of the matrix"; these operations tend to be already built in to practical programming languages, and thus it forms a particularly direct explanation of the language's behaviour. (Note that in this case, instead of waiting for waterclocks to hit zero, we're waiting for them to hit the minimum value, which is much faster, and never bothering with actually subtracting the waterclocks to zero; this clearly leads to the same result.)

It's possible when doing this that the first, metadata, row will end up as the lexicographically smallest. However, this effectively corresponds to a row that increments every waterclock by the same amount and the "zeroth waterclock" by more, which clearly has no effect on the behaviour of the program.

In some languages, it's simpler to add the transpose of the chosen row to every column of the matrix, rather than simply to the first. Adding a constant to every element of a zeroing trigger clearly does not change the behaviour of the language, after all.

The first implementation of The Waterfall Model was written here on Stack Exchange, and uses this ZISC construction. It consists of just four bytes of Jelly code:

+"Ṃẞ

## Computational class

One key observation here is that the requirement for all zeroing trigger elements to be nonnegative is not really relevant; you can simply increase every element by a constant so that they all become positive. As such, it's easy to imagine a structure for a program that acts more like a traditional Minsky Machine, with some waterclocks acting as counters and acting as states in the program, and changing state being achieved by incrementing the value of the current state and decrementing the value of the new state (i.e. all states have value 1, apart from the currently running state which has value 0). This handles increment, unconditional decrement, and goto operations just fine, via implementing them on the zeroing triggers of the state waterclocks. Note that the minimum value of a counter should be 1 (not 0), because having a waterclock at 0 is a special case in The Waterfall Model.

For conditional decrement operations, the trick is to double the value of every counter (so they normally get incremented and decremented by 2 at a time), and use the values 4 and 0 for states rather than 1 and 0. Now, you can implement a conditional decrement by setting a state to 3, rather than the usual 0, and "decrementing" the counter by 2 at the same time (i.e. by incrementing everything else by 2). If the counter waterclock was at 2 (emulating a counter value of 1), it'll get decremented to 0 and its own zeroing trigger will run (which can restore its own value to an emulated value of 1 / actual value of 2, and set the currently running state accordingly at the same time). If the counter waterclock was higher (i.e. 4 or more), the state that was set will be the first thing to hit zero, and it can likewise recover the situation. Note that one minor problem with this construction is that there can only be one conditional decrement operation per counter (it needs to know where it was called from), but The Amnesiac From Minsk demonstrates, this does not change the Turing-completeness of the language.