You can probably use this to simulate register machines and, if you can do that, the system is Turing complete.
The setup is as follows.
- The machine has a sequence of names registers, each of which holds a non-negative integer.
- Program instructions are labelled with non-negative integers and execution starts with, say, instruction $0$;
- The three possible instructions are:
- increment register $R$ and goto instruction $I$ (where $R$ and $I$ are integer constants);
- if register $R$ is zero, goto instruction $I$; else, decrement $R$ and goto instruction $J$ ($R$, $I$ and $J$ are constants).
For example, the following program adds the contents of registers $0$ and $1$ and halts with the sum in register $0$:
0. if R1=0, goto 2 else decrement R1 and goto 1
1. increment R0 and goto 0
My recollection from computation theory classes 20+ years ago is that you can simulate a Turing machine using a register machine with two registers (and certainly with some fixed number of registers). Proving this is long and tedious because you have to code up the tape and all manipulations of it as arithmetic operations and, heck, you even have to code up arithmetic operations such as addition, multiplication and exponentiation. Oh, and you'll probably have to be more careful than I was with my addition routine, because you'll probably want to do arithmetic on two values without destroying them both, which requires copying them to extra registers and then copying back.
You can simulate a two-register machine (i.e., a register machine with two registers) with $n$ instructions with your system as follows. Use two array cells to store the register values, and then probably one array value for each instruction, such that $A[i]=1$ if instruction $i-2$ is the next to be executed and $A[i]=0$, otherwise. Then executing the system with $A=[x,y,1,0,\dots,0]$ should simulate the register machine running with input $x$ in the first register and $y$ in the second. If there are $n$ instructions in the program, ASTs will look like this:
$$A[i]=(A*v_0) + (A*v_1) + ... + (A[n+2]*v_n)\,,$$
where $v_j$ is the value that should be stored in $A[i]$ if instruction $j$ is executed.
Note that all of this assumes that the array elements can hold unboundedly large numbers. If not, your system only has a finite number of states so cannot be Turing-complete. The simulation I have in mind only uses non-negative integer values in the arrays.