Escape from the tarpit (Cops)
Blindfolded Arithmetic

Possibly a fairly easy language to start off with, relatively
speaking.  (There are limits on how difficult a language I can make
because I have to prove it Turing-complete myself!)

For this language, the program set is the set of Blindfolded
Arithmetic programs as given in the section "program" below, the input
set is the set of positive integers, and the output set is the set of
integers (the entire set, not just the positive integers).

This language is fairly interesting – maybe even practically useful –
because it has a more or less total lack of control flow, being
entirely based on computations on numbers you can't see.  That makes
it potentially useful as a language for implementing programs inside
homomorphic encryption
systems.

Specification

Blindfolded Arithmetic is an esoteric programming language with the
following specifications:

Data storage

A state of a running Blindfolded Arithmetic program consists of six
variables, each of which can store an integer.  (There are no limits
on how large or small these integers can get; in particular, they can
go negative.)  The variables are called a, b, c, d, e, and
i.

At the start of the program, a to e inclusive are each initialised
to 0, and i is initialised to a positive integer taken from user
input.  (If no input is available, i is initialised to 1.)

If the program ceases execution (this can only occur due to division
by zero), the value of i immediately before the division was
attempted is used as the program's output.

Program

A Blindfolded Arithmetic program is a list of commands, each of which
has one of the following forms (where v can be replaced by any
variable name, potentially a different name each time it's used):


v = v + v
v = v - v
v = v * v
v = v / v


Note that each operand of the commands must be a variable; this
language does not allow the use of literal integers.

Execution of the program is performed by running each of the commands
in sequence, and then looping back to the start and continuing to run
the commands in sequence again, ad infinitum (or until there's an
attempt to divide by zero, which ends the program).

Each command has the same semantics as you'd expect from the notation,
which is no different from that used by most practical programming
languages: the values of the second and third variables metioned in
the command are taken, an arithmetic operation
(add/subtract/multiply/divide respectively for the four forms of
command) is applied to them, and the resulting value stored into the
first variable.  Division here is integer division, rounding
towards 0.

There is no control flow of any kind, other than program exit; the
commands always cycle in sequence, up until a division by zero (if
any) occurs and ends the program.  In particular, there's no way to
directly read variables, only to use them as a source of calculations
whose results impact the values assigned to other variables.