SilverSight/octave/hachimoji_encode.m

#!/usr/bin/env octave -qf
% Hachimoji Encoder + AngrySphinx Gate — Octave Implementation
% Run: octave hachimoji_encode.m

1;

global LETTER_NAMES = {"Phi", "Rho", "Lambda", "Kappa", "Sigma", "Omega", "Pi", "Zeta"};

% Precomputed sigma3 → hachimoji index keys and values (column vectors)
global LM_KEYS   = int64([1; 9; 28; 73; 126; 252; 344; 585; 757; 1134]);
global LM_VALUES = int64([0; 0; 3;  0;  1;   3;   5;   0;   1;   5]);

function total = sigma3(n)
  n = int64(n);
  if n <= int64(0)
    total = int64(0);
    return;
  endif
  total = int64(0);
  for d = int64(1):n
    if mod(n, d) == int64(0)
      total = total + (d * d * d);
    endif
  endfor
endfunction

function idx = hachimoji_letter(sigma3_value)
  global LM_KEYS LM_VALUES;
  sv = int64(sigma3_value);
  pos = find(LM_KEYS == sv);
  if ~isempty(pos)
    idx = LM_VALUES(pos(1));
  else
    idx = mod(sv, int64(8));
  endif
  idx = int64(idx);
endfunction

function w = cartan_weight(a, b)
  a = int64(a);
  b = int64(b);
  if a == b
    w = int64(273);
  elseif idivide(a, int64(2)) == idivide(b, int64(2))
    w = int64(256);
  else
    w = int64(0);
  endif
endfunction

function result = angrysphinx_gate(elements)
  els = int64(elements(:));
  n = length(els);
  collisions = int64(0);
  sum_keys = [];
  sum_counts = [];

  for i = 1:n
    for j = i:n
      s = els(i) + els(j);
      pos = find(sum_keys == s);
      if isempty(pos)
        sum_keys = [sum_keys; s];
        sum_counts = [sum_counts; int64(1)];
      else
        cnt = sum_counts(pos(1));
        if cnt == int64(1)
          collisions = collisions + int64(1);
        endif
        sum_counts(pos(1)) = cnt + int64(1);
      endif
    endfor
  endfor

  energy_raw = int64(273) + int64(17) * collisions - int64(256) * collisions;
  energy = max(int64(0), energy_raw);
  passed = collisions <= int64(1);

  result.passed = passed;
  result.collisions = collisions;
  result.energy_remaining = energy;
endfunction

function result = hachimoji_encode(n)
  global LETTER_NAMES;
  s3 = sigma3(n);
  idx = hachimoji_letter(s3);
  result.n = n;
  result.sigma3 = s3;
  result.index = idx;
  result.letter = LETTER_NAMES{int32(idx) + 1};
endfunction

% ── Main ──────────────────────────────────────────────────────────────
printf("=== Hachimoji Encoder + AngrySphinx Gate ===\n");
printf("Language: Octave    Run: octave hachimoji_encode.m\n\n");

% sigma3 unit tests
assert(sigma3(0) == int64(0));
assert(sigma3(1) == int64(1));
assert(sigma3(2) == int64(9));
printf("[PASS] sigma3 unit tests\n");

% Test vector
exp_sigma3  = int64([1; 9; 28; 73; 126; 252; 344; 585; 757; 1134]);
exp_idx     = int64([0; 0; 3;  0;  1;   3;   5;   0;   1;   5]);
exp_letters = {"Phi", "Phi", "Kappa", "Phi", "Rho", "Kappa", "Omega", "Phi", "Rho", "Omega"};

printf("Inputs: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n\n");

for i = 1:10
  n = i;
  res = hachimoji_encode(n);
  printf("n=%-2d: sigma3=%-5d, letter=%s (%d)\n",
         n, res.sigma3, res.letter, res.index);
  assert(res.sigma3 == exp_sigma3(i), "sigma3 mismatch");
  assert(strcmp(res.letter, exp_letters{i}), "letter mismatch");
  assert(res.index == exp_idx(i), "index mismatch");
endfor

% Gate tests
printf("\nGate tests:\n");

g = angrysphinx_gate(int64([1; 2]));
printf("  [1,2]   -> passed=%d, collisions=%d, energy=%d\n",
       g.passed, g.collisions, g.energy_remaining);
assert(g.passed && g.collisions == int64(0) && g.energy_remaining == int64(273));

g = angrysphinx_gate(int64([1; 2; 3]));
printf("  [1,2,3] -> passed=%d, collisions=%d, energy=%d\n",
       g.passed, g.collisions, g.energy_remaining);
assert(g.passed && g.collisions == int64(1) && g.energy_remaining == int64(34));

g = angrysphinx_gate(int64([1; 2; 3; 4]));
printf("  [1,2,3,4] -> passed=%d, collisions=%d, energy=%d\n",
       g.passed, g.collisions, g.energy_remaining);
assert(~g.passed && g.collisions == int64(3) && g.energy_remaining == int64(0));

printf("\nAll tests passed.\n");