# Why the negative sign is represented by 1 and not 0 in Binary.

I’m not sure about you, but I’ve certainly asked rather absurd looking questions like these to myself. Some of you might think it’s just a representational matter and it’s because it’s standardized. Surprisingly, there’s an actual reason why the negative sign is represented by a `1`

in binary and not `0`

. If you can answer this question, kudos to you. If you can’t, then read on.

Being in Computer Science for almost half a decade, the Binary Number System has become second nature to me. That doesn’t mean that I can do Binary calculations in a second. I still need to write the numbers down and do the maths on paper. But one day while doing Binary calculations specifically with negative numbers, a weird thought came into my mind. “Why was the negative sign represented with a `1`

rather than a `0`

?”. I knew the rules of Binary mathematics but just couldn’t figure it out until one day I stumbled upon the answer. It goes as follows.

Let’s take an example of a Binary number. Suppose the 8-bit number `11001010`

. Supposing that this number represents a signed decimal integer, it can be represented in *Positional Notation* as follows.

Or in more simple terms…

Now let’s find the value of the above formula in the Decimal System. Converting the number `11001010`

to it’s twos complement gives us `00110110`

. Which means we can represent it like…

And then finding the value of the above formula gives us *54* as the answer. Which means the original number was *-54*.

This method of first converting a negative number to it’s positive twos compliment equivalent and then finding the value of that positive number in Decimal System and attaching a minus sign to it seems very tedious. But that’s what we’ve been taught since we encountered this Binary System. But it turns out that there’s an easier way of doing what we just did. And it all involves one slight change to the positional notation of the original negative number illustrated by **Formula 2**. And the change is…

If you didn’t notice, what I did is I made the weight of the *Most Significant Bit* of the original number into a negative number. It’s magnitude doesn’t change, only it’s sign. But watch how much of a significant change it does to our calculations. Finding the value of the above formula directly gives us *-54*.

You don’t need to do any kind of conversions to achieve the result. But the interesting thing is that it even works for positive numbers. For example let’s take the positive number `01001101`

. Representing the number in **Signed Weighted Positional Notation**, we get…

The value of the above formula is *77*, which would be equal to the value if you were to calculate it this way…

“But what does this have to do with your question?”, you ask. The answer is that, the *MSB* does not just represent a sign in a binary number but it actually represents a negative weight. And that’s why it makes sense, because if the *MSB* is `1`

, then the negative weight is included in the calculation to give you the correct negative value. And if the *MSB* is `0`

, then the negative weight is not included in the calculation to give you the correct positive number.

This is one of the times mathematics shows us how beautiful it can be.