notice that,
T(n) + T(n+1) = – T(n) ———-[R1]

from above,
T(n) + T(n) = – T(n+1)
2 * T(n) = – T(n+1) using [R1] above
2 * T(n) = T(n+1) + T(n+2) ————-[R2]

at any bit,
0 + 0 = 0
1 + 0 = 1
0 + 1 = 1
1 + 1 = T(n) + T(n) = 2 * T(n) using [R2]
= T(n+1) + T(n+2)
= 0, CARRY_n+1 = 1, CARRY_n+2 = 1

for simplification let treat ‘L’ as a symbol, that represent value of ‘-1′
then
0000000L = (-1) * ( 1) = -1
000000L0 = (-1) * ( -2) = 2
00000L00 = (-1) * ( 4) = -4
0000L000 = (-1) * ( -8) = 8
000L0000 = (-1) * ( 16) = -16
00L00000 = (-1) * ( -32) = 32
0L000000 = (-1) * ( 64) = -64
L0000000 = (-1) * (-128) = 128

Then by using convert ‘L’ to value ‘1′, the order or magnitude is just multiply with negative,
so, the order of magnitude is:
(128) (-64) (32) (-16) (8) (-4) (2) ( -1)

then, we can used value ‘1′ and ‘0′ to represent a base 2 number

i.e.
00000110 = -4 + 2 = -2 (base 10)
00001010 = 8 + 2 = 10 (base 10)
00001100 = 8 + -4 = 4 (base 10)

So,
base n number should used all integer start from 0 to the integer before N

then base -2 should use {0,-1}
base -8 should use {0,-1,-2,-3,-4,-5,-6,-7}

Extending the carries does not have an efficient implementation (a second row of full-adders does not suffice! Actually, one needs n rows of full-adders (FAs) –though one less FA every subsequent row– till the extension of carries is fully processed).

A more efficient implementation can be obtained by making use of the concept of “generalized FA/HAs(half-adders)”. As before, the first row is a conventional ripple adder. The output being S = -s_0 + s_1 x 2^1 – … must be consequently inverted. A second row made of a simple incrementor (half-adders!) will do the job since -s = s_bar – 1.

I think you understood it the other way around.
we are not interested in what the sequential binary count will result in, rather we are interested in how to represent the numbers sequentially in base -2.
But I think you got the general idea…

Let A = {a_0 a_1 … a_n-1} and B = {b_0 b_1 … b_n-1} represent the algebraic value of two numbers in base -2.

That is, A = sum_i (a_i x (-2)^i) and B = sum_i (b_i x (-2)^i) with i = 0…n-1 and, a_i and b_i in {0,1}.

Note that (a_i + b_i)x(-1)^i takes values in {0,+1,+2} if i even and {0,-1,-2} if i odd.

Also, it is obvious that, +2 = +4 + (-2) and -2 = (-4) + (+2). Note that +2 and -2 do not have a representation in the next bit position i+1, but they do in i+1 and i+2.

By extending the carry output of a conventional full-adder to bit positions i+1 and i+2 we are done.

For example, one can use two ripple adders: the first connected as usual, and the second one takes the sum and the carries of the first one.

here is my thinking…
binary
representation in decimal
0 = 0x(-2)^0 = 0
1 = 1x(-2)^0 = 1
10 = 1x(-2)^1+0x(-2)^0= -2
11 = 1x(-2)^1+1x(-2)^0= -1
100 = 1x(-2)^2+0+0 = 4
101 = 1x(-2)^2+0+1x(-2)^0= 5
and so on…

and as for counting

the addition circuit will be same as the base 2 adder circuit.
since 101(5)+100(4)= 1001 which is 9 in base -2
and 100(4)+11(-1)=11 which is 3 in base -2
and say 101(5)+10(-2)= 11 which is 3 in base -2

Please let me know if im on the right track…

Thanks.