Every computer file, including data files and program files, is a *unique
sequence* of binary bits, unless the user modifies the file. As such, every such
file has a *unique signature*, which is its base-2 (or alternatively base-10)
numerical representation. Since a byte has 8 bits, we can immediately get some bounds
on the size of this file signature:

File Size: | 1 byte | 1 KB | 1 MB | 1 GB |

Signature Range: | 0 ≤ S ≤ 2^{23}-1 |
0 ≤ S ≤ 2^{213}-1 |
0 ≤ S ≤ 2^{223}-1 |
0 ≤ S ≤ 2^{233}-1 |

Expanded Signature Range: | 0 ≤ S ≤ 255 | 0 ≤ S ≤ 0.1090748136*10^{2467} |
0 ≤ S ≤ A (large!) | 0 ≤ S ≤ B (huge!) |

Here's an example: Suppose our file F has size 5 bytes and contains the following bit sequence:

F: | 10110110 | 11010100 | 10100001 | 00111111 | 10110001 |

F's signature is exactly S = $B6D4A13FB1 in hexadecimal, which is equal to S =
785251385265 in base 10. S for a 5 byte file may take 2^{40} = 1099511627776
different values, which means such a file can represent 1099511627776 different
sequences/values/signatures, depending on its contents.

For a 1KB file, S can vary between 0 and 0.1090748136*10^{2467}. This last
number is a number with 2466 digits, in case you are wondering. It's already greater
than the number of all electrons in the universe (~10^{58}) by many orders, and
the total number of chess board configurations
(~10^{71.3}) also by many orders.

Let's now attempt to estimate the magnitude of A. We immediately have:

log_{2}(log_{2}(A)) = 23. Using the logarithm base change:

log_{b}(X) = log_{k}(X)/log_{k}(b), call X =
log_{2}(A). Then:

log_{2}(X) = log_{10}(X)/log_{10}(2) = 23, =>

log_{10}(X) = 23*log_{10}(2) ~ 6.9236898 ~ 7, =>

X = 10^{7} , =>

log_{2}(A) ~ 10^{7}, and using the base change formula again,
=>

log_{10}(A)/log_{10}(2) ~ 10^{7}, =>

log_{10}(A) ~ 10^{7}*log_{10}(2) ~ 3000000, =>

A ~ 10^{3000000}.

That's a LARGE number. It has approximately 3000000 digits. That's approximately 3 million digits.

Repeating for B, we find:

B ~ 10^{3000000000}.

That's a *huge* number. It has approximately 3 *billion* digits. Now you
understand what it means for a system to have *storage capacity* equal to 1
Gigabyte.

To get an idea of the immense power of the tetration of 2, a useful exercise for the
reader is to try to calculate how many digits the number
2^^7=^{7}2=2^{2222222}
has. The estimation is presented below. See if you can follow the details.

^{1}2=2^^1 |
2 |

^{2}2=2^^2 |
4 |

^{3}2=2^^3 |
16 |

^{4}2=2^^4 |
~10^4.81=^{1}(10,4.81)^{[1]} |

^{5}2=2^^5 |
~10^10^4.29=^{2}(10,4.29)^{[2]} |

^{6}2=2^^6 |
~10^10^10^4.29=^{3}(10,4.29)^{[3]} |

^{7}2=2^^7 |
~10^10^10^10^4.29=^{4}(10,4.29)^{[4]} |

- Estimates are given in terms of the extended tetration function
^{n}(x,y) = {x^{y}, iff n=1, x^{{n-1(x,y)}}iff n >1}. -
2^65536=10^{log
_{10}(2^65536)}=10^{log_{2}(2^65536)/log_{2}(10)} ~10^(65536/3.32)=10^19728=10^10^4.29=^{2}(10,4.29). -
2^{10^19728}=10^{log
_{10}(2^{10^19728})}=10^{log_{2}(2^{10^19728})/log_{2}(10)}=10^{10^19728/log_{2}(10)}~10^{10^19728/3.32}=10^{10^19728/10^0.52}=10^10^{19728-0.52}=10^10^19727=10^10^10^4.29=^{3}(10,4.29). -
2^{10^10^19727}=10^{log
_{10}(2^{10^10^19727})}=10^{log_{2}(2^{10^10^19727})/log_{2}(10)}=10^{{10^10^19727}/log_{2}(10)}~10^{{10^10^19727}/3.32}=10^{{10^10^19727}/10^0.52}~10^{10^{10^19727-0.52}}=10^{10^{10^19726}}~10^{10^{10^10^4.29}}~^{4}(10,4.29).