My book shows a circuit for a half subtractor, that is exactly the same as that for a half adder, except the "minued" input (The input 'A', in 'A-B') to the AND gate (Borrow output) is inverted.

The main thing I don't understand is the idea of 'borrowing' a bit. I mean when you 'carry' a bit in addition, you will only ever directly affect the next higher significant bit, but the way I learnt to do subtraction when I was little means that if the next higher significant digit is a zero, then you have to affect the

*next higher significant digit to that*, and so on, until you come to a non-zero digit. When I've done some

*binary*subtractions on paper the same thing applies.

But how can a full subtractor, which is connected only to its next higher significant bit (and lower significant), take account of this standard subtraction algorithm*, when the next higher significant bit is a zero? It means having to change

*even higher*significant bits, that it's not directly connected to. So how can it do it?

Basically I'm having trouble connecting the hand calculations of binary subtraction, to the way the circuits work. I'm aware there are a few different subtraction algorithms that are used, using modular arithmetic and stuff, so I'm not really sure which is the best to learn. For instance I'm not sure that all of them will allow negative differences, which is probably needed for most applications.

*This is an example of what I mean by this subtraction algorithm (in binary):

Rich (BB code):

```
01101011
```__-0110010__
1001

Rich (BB code):

```
01001011
```__-0110010__
11001

Rich (BB code):

```
00001011
```__-0110010__
111001

So we have 1101011-110010 = 111001 which in decimal is 107 - 50 = 57

I'm ok with this so far, since we have only had to affect the bit immideately higher to the one we're computing, and in the circuit of a full subtractor, this is accounted for by the

*borrow-in*connection.

But what if we change the sum slightly to:

Rich (BB code):

```
01001011
```__-0110010__
1001

Rich (BB code):

```
00101011
```__-0110010__
11001

__only connected to consecutive bits__, so how can it be possible to perform a sum like this, where non-consecutive bits are being directly affected as well?

Thanks