Implementing if statements - turing-complete

Question

I created my own programming language that compiles down to Turing Machine instructions and I was wondering how to implement if(a>b) do _ end. Here's the definition of the language(also available here)
Variables are dynamically allocated at any width so can have arbitrarily large integers
Each line can do one of three things, it can call a function(which modifies it's argument), start a while loop(which is really more of a for loop), or assign a variable.
The available functions are incr(Increment by one, can overflow), decr(Decrement by one, can overflow), pop(Remove the last digit from a variable), first(Changes the most significant 0 in a variable to 1), and frost(changes the most significant 1 to a zero).
A while loop has the following syntax,
while a <func> {
_
}
Basically every time it loops it does <func> to a till error condition. The error conditions are as follows, incr and first has all 1's, decr and frost has all 0's, pop removes the last digit. After a while loop with incr or frost all bits of the looping variable will be 0, opposite with first and decr. While loops have to end on a function call, and they delete all variables contained within after each run.
Assignment can do a few different things based on the syntax. a=b means copy variable b into the space owned by variable a if b is longer than a this causes undefined behavior unless a is the latest variable created. a=b,5 assigns b to a with five padding bits(set to zero) to the left, again overflows cause undefined behavior unless a is the latest variable created. a=a,0 zeroes out a. Finally a=5,3 will assign 5 % 2**3 to a in 3 bits.
Now I can implement if(a != 0) do _ end with
while a decr {
_
t=0,1
while a incr {
incr(t)
}
incr(t)
}
My question is how can I implement the other if statements, like if(a==b), if(a!=b), and if(a>b)
And as a secondary question is this language Turing Complete, I believe so based on this answer Are there minimum criteria for a programming language being Turing complete?. I know the language satisfies 1 through 5, but I'm not sure about 6.

Answer 1

(please let me know if i've assumed wrong about the loop or incr/decr behavior, that would alter my answer)
Your original code for if(a!=0) appears to loop forever. As it is, it's doing while(a) do _ end because it either loops indefinitely or not at all. Lastly t would not exist outside of the loop and does not appear to be utilized inside it, even though it looks like the value you're trying to capture (true/false on the comparison).
You don't have a comment syntax so i'll throw in // comment / c-style comments where needed.
Maybe something like this...
if (a > 0) do _ end
// if (a > 0) do _ end
_a = a
while _a decr {
// overflow iif _a= 0
_ // do something
_a = 0
frost( _a ) // only function calls at end of loops
}
if (a == 0) do _ end
// if (a == 0) do _ end
_a = a
result = 1,1
while _a decr {
// overflow iif _a= 0
_a = 0
frost( result ) // only function calls at end of loops
}
while result decr {
// overflow iif result = 0
_ // do something
frost( result ) // exit loop
}
The pattern is straightforward for a non-zero check as you've noticed - decrement it, and if you didnt overflow (underflow technically) then you're dealing with something that was 1 or greater. Trick is exiting the while, which you can do by using a decr test and setting the variable being tested to 0 upon exit. For this, your frost function is suitable because for a target variable of 0 it leaves the result unmodified, and a target of 1 becomes 0 such as in result's usage.
Your documentation says that a function must mark the end of a loop, not an assignment or another loop, but your own examples are inconsistent with this, just to note.
I'm making an example for the remaining test conditions: a > b and a == b; the others can be derived from just these two and logical inversion / not operator, which you've seen in the above using result.
if (a == b) do _ end
// if( a == b ) do _ end
a_cond = a
b_cond = b
// step 1: a_cond = a - b
while b_cond decr {
decr(a_cond)
}
// step 2: if (a_cond == 0)
result = 1,1
while a_cond decr {
// overflow iif a_cond = 0
a_cond = 0
frost( result ) // only function calls at end of loops
}
while result decr {
// overflow iif result = 0
_ // do something
frost( result ) // exit loop
}
if (a > b) do _ end
WIP. will be similar to (a==b) case