Binary number system and bit - byte concepts: Foundations

This page is a toolbox. Before you touch the parent note, you should recognise every mark on sight. We build them in order: each tool uses only tools already unpacked above it.

1. The digit — a single mark that carries a value

The picture: think of a single dial that can click into a fixed number of notches. A decimal dial has ten notches; a binary dial has only two — think of a plain light switch.

Figure — Binary number system and bit - byte concepts

Why the topic needs it: the whole subject is about the two-notch dial. A computer can only build the two-notch kind cheaply and reliably (a switch is either open or closed), so binary is forced on us by the hardware, not chosen for beauty.

2. Base $b$ — how many notches the dial has

$b = 10$ → decimal → ten digits.
$b = 2$ → binary → two digits.

The picture: the subscript is like a language tag on a word. The letters "chat" mean conversation in English but cat in French — same marks, different meaning depending on the tag. $101 1_{10} \neq = 101 1_{2}$ for exactly this reason.

Why the topic needs it: every conversion in the parent note is "translate a number from base $b$ into base $b^{'}$ ". Without the subscript you cannot even state the problem unambiguously.

3. Position and the subscript index $i$

Read a number left to right and the marks look equal. They are not — where a digit sits changes its worth. We need a way to name a position.

Why start counting at $0$ , not $1$ ? Because the rightmost column represents "how many ones" — and one is $b^{0}$ . Starting the index at $0$ makes the position number equal the power we will raise the base to. That alignment is the whole reason the formula in section 6 is clean.

The notation $d_{i}$ : we write $d_{i}$ to mean "the digit sitting at position $i$ ". So in $101 1_{2}$ :

$d_{0} = 1, d_{1} = 1, d_{2} = 0, d_{3} = 1$

Notice $d_{0}$ is the digit on the far right — the little subscript is an address, not a left-to-right reading order.

Why the topic needs it: the parent's warning "line the weights under the bits first" is entirely about not mixing up which $i$ each digit has. Miscount the position and every later answer is wrong.

4. Exponent notation $b^{i}$ — repeated multiplication as a column weight

Why does $b^{0} = 1$ ? Multiplying zero copies of anything must leave you at the "start" of multiplication, and the start of multiplication is $1$ (multiplying by $1$ changes nothing). So $b^{0} = 1$ for every base. This is why the rightmost column is always worth $1$ , in any base.

The picture: picture columns as boxes of increasing size. The first box holds $1$ , the next holds $2$ , the next $4$ — each box is twice as tall as its neighbour. A digit $1$ means "this box is filled"; a digit $0$ means "empty".

Why the topic needs it: $b^{i}$ is the weight of column $i$ . Every binary→decimal conversion is "add up the weights of the filled boxes". You cannot do it without knowing what a power means.

5. Multiplication as scaling, and the " $\cdot$ " dot

The parent writes $d_{i} \cdot b^{i}$ . The centred dot $\cdot$ is just the multiplication sign (the same as $\times$ ; we use the dot so it is never confused with the letter x).

Why the topic needs it: it turns a pattern (which boxes are filled) into a number (the total).

6. The summation sign $\sum$ — "add up all the pieces"

Now every piece is ready, we can read the parent's headline formula.

Here $n$ is just the number of digits in the string, so the last position is $n - 1$ (because we started counting at $0$ ).

7. The words: bit, nibble, byte

Now the numbers have symbols, we name the hardware quantities.

The picture: a bit is one light switch. A nibble is a strip of $4$ switches; a byte is a strip of $8$ . "Nibble = half a byte" and the word is a pun on bite — a nibble is a small bite.

Why the topic needs it: these are the units the whole "how many values fit" discussion (section 4 of the parent) counts in. The multiplication principle $2 \times 2 \times \dots$ giving $2^{n}$ patterns depends on knowing $n$ = number of bits.

Prerequisite map

This whole toolbox now flows into the parent topic. From there it powers Hexadecimal number system (grouping bits into nibbles), Two's complement (bit patterns for negatives), Logic Gates and the wider Boolean algebra chapter, and Memory addressing (why the byte is the addressable unit).

Equipment checklist

Test yourself — each line should be instant before you open the parent note.

What does the subscript in

101 1_{2}

tell you?

The base to read the digits in (here base 2); it is a tag, not a power or a multiplication.

d_{i}

, what does the index

i

point to and where does counting start?

The column position, counted from the right starting at

0

(rightmost digit is

i = 0

Why is

b^{0} = 1

for every base?

Multiplying zero copies of

b

leaves you at the start of multiplication, which is

1

; so the rightmost column is always worth

1

What does

b^{i}

represent in a positional number?

The weight (worth) of the column at position

i

— for binary the weights are

1, 2, 4, 8, 16, \dots

What does

\sum_{i = 0}^{n - 1}

instruct you to do?

Start

i

0

, evaluate the term, step

i

up to

n - 1

, and add all the results together.

Why does

\sum

stop at

n - 1

and not

n

for an

n

-digit number?

Positions start at

0

, so

n

digits occupy positions

0

through

n - 1

d_{i} \cdot b^{i}

with binary, what are the only two possible results?

0

(empty box, skip it) or

b^{i}

(full box, add its full weight).

What is a bit, and how many make a byte?

A bit is one binary digit (

0

1

);

8

bits make a byte (and

4

bits make a nibble).