Definition:Unlimited Register Machine

Context
Mathematical Logic, Computer Science.

Definition
An unlimited register machine, abbreviated URM, is an abstraction (or idealization) of a computing device with the following characteristics:

Registers
A URM has a number of locations called registers which can store natural numbers: $$\left\{{0, 1, 2, \ldots}\right\}$$.

Any given URM program may make use of only a finite number of registers.

Registers are usually referred to by the subscripted uppercase letters $$R_1, R_2, R_3, \ldots$$.

The number held at any one time by a register is usually referred to by the corresponding lowercase letter $$r_1, r_2, r_3, \ldots$$.

The registers are "unlimited" in the following two senses:
 * Although a URM program may make use of only a finite number of registers, there is no actual upper bound on how many a particular program can actually use.
 * There is no upper bound on the size of the natural numbers that may be stored in any register.

Program
The numbers held in the registers of a URM are manipulated according to a program.

A URM program is a finite list of basic instructions.

The instructions are written in a fixed order and numbered $$1, 2, 3, \ldots$$.

Basic Instructions
Basic instructions are also (and more commonly) known as commands, because the word's shorter and quicker to say.

Operation

 * When a URM runs a program, it always starts by executing the first instruction of the program.


 * When it has carried out an instruction, it moves to the next instruction and executes that one, unless required otherwise by a Jump instruction.

Termination
A URM program stops, or terminates, when there are no more instructions to carry out. This can happen in either of two ways:
 * 1) If the program carries out the last instruction, and this does not involve a Jump to an earlier instruction, the program will stop.
 * 2) If the program carries out a Jump instruction to a non-existent instruction, the program will stop.

If the program, when running, never reaches such a state, then it is said to be in an endless loop and will never terminate.

Note that whether a program terminates or not may depend on its input.

It may terminate perfectly well for one input, but go into an endless loop on another.

Input
The input to a URM program is:
 * either an ordered $k$-tuple $$\left({n_1, n_2, \ldots, n_k}\right) \in \N^k$$;
 * or a natural number $$n \in \N$$.

In the latter case, it is convenient to consider a single natural number as an "ordered $$1$$-tuple" $$\left({n_1}\right) \in \N^1 = \N$$.

Hence we can discuss inputs to URM programs solely as instances of tuples, and not be concerned with cumbersome repetition for the cases where $$k=1$$ and otherwise.

The convention usually used is for a URM program $$P$$ to start computation with:
 * the input $$\left({n_1, n_2, \ldots, n_k}\right)$$ in registers $$R_1, R_2, \ldots, R_k$$;
 * $$0$$ in all other registers used by $$P$$.

That is, the initial state of the URM is:
 * $$\forall i \in \left[{1 \, . \, . \, k}\right]: r_i = n_i$$;
 * $$\forall i > k: r_i = 0$$.

It is usual for the input (either all or part) to be overwritten during the course of the operation of a program. That is, at the end of a program, $$R_1, R_2, \ldots, R_k$$ are not guaranteed still to contain $$n_1, n_2, \ldots, n_k$$ unless the program has been explicitly written so as to ensure that this is the case.

Output
At the end of the running of a URM program, the output will be found in register $$R_1$$.

Comment
The particular details of a URM may differ between presentations.

The one defined here closely follows the design of that in Cutland.

Historical Note
The URM is a more versatile and easy to understand alternative to the Turing machine, which has the same capabilities and (to a certain extent) to which it is logically equivalent.

It was introduced in a paper by J. C. Shepherdson and H. E. Sturgis published in 1963.