6.7 KiB
Calculator-Plain Math: The Entire Research Stack
Every equation in this project reducible to + - * / ^ log.
No calculus. No linear algebra. Just arithmetic.
1. Nibble Switch (GCCL Core)
What it is: A 4-bit transition atom.
Calculator steps:
Given control (0-3) and domain (0-3):
nibble = control * 4 + domain
Example: control=1 (ACCEPT), domain=2 (M_TENSION)
nibble = 1 * 4 + 2 = 6
Unpack:
control = floor(nibble / 4)
domain = nibble mod 4
Example: nibble = 6
control = floor(6 / 4) = 1
domain = 6 mod 4 = 2
That's it. No algebra. Just * / mod.
2. Manifold State Point
What it is: A point on the machine's map.
Calculator steps:
new_locus = old_locus + delta
delta depends on domain:
K_AXIS → delta = +1
C_WINDING → delta = +256
M_TENSION → delta = +65536
Y_BREAK → delta = -1
If polarity is negative, flip the sign.
Example: locus = 100, domain = K_AXIS, polarity = positive
new_locus = 100 + 1 = 101
Curvature update (exponential moving average):
new_curvature = 0.7 * old_curvature + 0.3 * target
target = 1.0 if control == ACCEPT
0.0 otherwise
Example: curvature = 0.5, control = ACCEPT
new_curvature = 0.7 * 0.5 + 0.3 * 1.0
= 0.35 + 0.30
= 0.65
Register:
new_register = nibble (the packed value, 0-15)
3. English Invariant Fingerprint
What it is: Reduce a sentence to its grammatical skeleton.
Calculator steps (per word):
- Check if word is in a lookup table (DET, PRON, PREP, etc.)
- If not, check suffix:
- ends with "ing" → VBG
- ends with "ed" → VBN
- ends with "ly" → ADV
- ends with "tion" → NOUN
- ends with "able" → ADJ
- If no match and length ≤ 3 → SHORT
- Otherwise → LEX
Example:
"The cat sat on the mat"
The → DET
cat → LEX (not in tables, no special suffix)
sat → SHORT (3 letters) or VBN (ends with 't', not 'ed')
on → PREP (in table)
the → DET
mat → SHORT (3 letters)
Fingerprint: DET LEX SHORT PREP DET SHORT
No math. Just string matching.
4. Shannon Entropy
What it is: How unpredictable the language is.
Calculator steps:
Given a list of counts (how many times each form appears):
Step 1: total = sum of all counts
Step 2: For each count:
p = count / total
contribution = -p * log2(p)
Step 3: entropy = sum of all contributions
Example:
Forms: A=100, B=50, C=50
total = 100 + 50 + 50 = 200
For A: p = 100/200 = 0.5
-0.5 * log2(0.5) = -0.5 * (-1) = 0.5
For B: p = 50/200 = 0.25
-0.25 * log2(0.25) = -0.25 * (-2) = 0.5
For C: p = 50/200 = 0.25
-0.25 * log2(0.25) = 0.5
entropy = 0.5 + 0.5 + 0.5 = 1.5 bits
You need: + / * log2. That's it.
5. Power-Law (Zipf) Fit
What it is: Word frequency follows count * rank ≈ constant.
Calculator steps:
Given ranks (1, 2, 3, ...) and counts sorted descending:
alpha = 1 + N / sum(log(rank/count) for each item)
Example:
rank 1: count = 200 → log(1/200) = log(0.005) = -7.64
rank 2: count = 100 → log(2/100) = log(0.02) = -5.52
rank 3: count = 50 → log(3/50) = log(0.06) = -4.12
sum = -7.64 + (-5.52) + (-4.12) = -17.28
N = 3
alpha = 1 + 3 / (-17.28) = 1 - 0.174 = 0.826
You need: log + /.
6. Hutter Prize Score
What it is: How good the compression is.
Calculator steps:
C = (0.4 * C_comp + 0.35 * C_phys + 0.25 * C_geom) * (S / (G + F))
Each component:
C_comp = original_size / compressed_size (compression ratio)
C_phys = log2(number_of_unique_words + 1)
C_geom = (top_form_count) / (total_forms)
S = spatial_locality (constant, e.g. 0.95)
G = decoder_size_in_MB
F = replay_overhead (constant, e.g. 0.4)
Example:
original = 1000 bytes
compressed = 100 bytes
decoder = 10 MB
C_comp = 1000 / 100 = 10.0
C_phys = log2(5000 + 1) = log2(5001) = 12.29
C_geom = 44679 / 152158 = 0.293
S = 0.95
G = 10
F = 0.4
C = (0.4 * 10.0 + 0.35 * 12.29 + 0.25 * 0.293) * (0.95 / (10 + 0.4))
= (4.0 + 4.30 + 0.073) * (0.95 / 10.4)
= 8.373 * 0.0913
= 0.764
You need: + * / log2.
7. Grand Compression Equation
What it is: The optimal compressor minimizes this.
Calculator steps:
Score = H + λ*|C| + μ*K + ν*dim
H = Shannon entropy (from §4)
|C| = size of the compressor in bytes
K = log2(|C| + 1) (simplified Kolmogorov)
dim = number of unique forms / total sentences
Example:
H = 17.05 bits/form
|C| = 10000 bytes
K = log2(10001) = 13.29
dim = 151232 / 180189 = 0.839
λ = 0.001, μ = 0.01, ν = 1.0
Score = 17.05 + 0.001*10000 + 0.01*13.29 + 1.0*0.839
= 17.05 + 10.0 + 0.133 + 0.839
= 28.022
You need: + * / log2.
8. Betti Numbers (Topological Invariants)
What it is: Count holes in the state trajectory.
Calculator steps:
β₀ = number of connected parts = 1 (always 1 for single trajectory)
β₁ = number of loops
A loop = trajectory revisits a previous point
χ (Euler) = V - E + F
V = number of unique points
E = number of edges (transitions) = len(trajectory) - 1
F = β₁ (simplified)
Example:
trajectory: A → B → C → B → D
V = 4 (A, B, C, D)
E = 4 (AB, BC, CB, BD)
β₁ = 1 (B visited twice, forming loop B→C→B)
χ = 4 - 4 + 1 = 1
You need: + - only.
9. Unified Hardware Surface
What it is: Add up all compute units.
Calculator steps:
total_compute = CPU_cores + (if has_GPU then 1024 else 0)
memory_tiers:
RAM_max = available_RAM * 0.5
VRAM_max = available_VRAM * 0.7
Example (this machine):
CPU = 12 cores
GPU = yes (RTX 4070 SUPER)
total = 12 + 1024 = 1036 compute units
RAM = 17.2 GB available → 8.6 GB managed
VRAM = 11.8 GB → 8.3 GB managed
You need: + *.
10. Cache Statistics
What it is: Hit rate and size.
Calculator steps:
hit_rate = hits / (hits + misses) * 100
Example:
hits = 161,154
misses = 3,523
hit_rate = 161154 / (161154 + 3523) * 100
= 161154 / 164677 * 100
= 97.9%
You need: + / *.
Summary Table
| Concept | Operations Needed | Difficulty |
|---|---|---|
| Nibble Switch | * + mod / |
Elementary |
| Manifold Point | + * |
Elementary |
| Fingerprint | String lookup | Elementary |
| Shannon Entropy | + / * log |
High school |
| Power-Law Fit | + / log |
High school |
| Hutter Score | + * / log |
High school |
| Grand Equation | + * / log |
High school |
| Betti Numbers | + - |
Elementary |
| Hardware Surface | + * |
Elementary |
| Cache Stats | + / * |
Elementary |
Every equation in this project uses only + - * / ^ log.
No calculus required. No matrices. Just arithmetic.
A high school student with a scientific calculator could verify every number.