<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Structural Optimization of the Towers of Hanoi Algorithm</title>
  <style>
    body {
      font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif;
      background-color: #f8f8f8;
      color: #111;
      line-height: 1.6;
      padding: 5vh 10vw;
      max-width: 800px;
      margin: auto;
    }
    h1 {
      font-size: 1.8em;
      margin-bottom: 1em;
    }
    h2 {
      font-size: 1.2em;
      margin-top: 2em;
    }
    blockquote {
      margin: 2em 0;
      padding-left: 1em;
      border-left: 4px solid #ccc;
      font-style: italic;
      color: #555;
    }
    hr {
      margin: 2em 0;
      border: none;
      border-top: 1px solid #ddd;
    }
    .small {
      font-size: 0.9em;
      color: #888;
    }
    code, pre {
      background-color: #eee;
      padding: 2px 4px;
      font-family: monospace;
      white-space: pre-wrap;
    }
    table {
      border-collapse: collapse;
      width: 100%;
    }
    th, td {
      border: 1px solid #ccc;
      padding: 6px 10px;
    }
  </style>
</head>
<body>

<h1>Structural Optimization of the Towers of Hanoi Algorithm</h1>
<p><strong>Student Submission</strong><br>10 June 2025</p>

<h2>1. Problem Overview</h2>
<p>The classic Towers of Hanoi puzzle requires \(2^n - 1\) steps to solve for \(n\) disks. This analysis explores whether transforming the algorithm can provide a structurally faster or more efficient solution.</p>

<h2>2. Starting Point</h2>
<ul>
  <li>Step count remains: \( \Theta(2^n) \)</li>
  <li>Two implementation modes:</li>
  <ul>
    <li><strong>Precomputed:</strong> Generates and stores all steps in advance.</li>
    <li><strong>Lazy Recursive:</strong> Generates steps during execution via recursion.</li>
  </ul>
</ul>

<h2>3. Comparative Table</h2>
<table>
  <tr><th>Aspect</th><th>Precomputed</th><th>Lazy Recursive</th></tr>
  <tr><td>Initialization Time</td><td>\( \Theta(2^n) \)</td><td>\( \Theta(n) \)</td></tr>
  <tr><td>Memory Usage</td><td>\( \Theta(2^n) \)</td><td>\( \Theta(n) \)</td></tr>
  <tr><td>Step Count</td><td>\( 2^n - 1 \)</td><td>\( 2^n - 1 \)</td></tr>
  <tr><td>Advantage</td><td>Immediate access</td><td>Efficiency in resource-constrained contexts</td></tr>
</table>

<h2>4. Core Finding</h2>
<p>The transformation does not reduce the number of required moves. It optimizes how the move sequence is represented and executed. The lazy method is favorable in memory-limited or runtime-generated scenarios.</p>

<h2>5. Applied Informatics Perspective</h2>
<blockquote>
Optimization occurs in representation, not in theoretical execution time.
</blockquote>
<p>The algorithmic choice affects how resources are allocated during solution generation, not the intrinsic complexity of the problem.</p>

<h2>6. Appendix A – Python Code Comparison</h2>
<pre><code># Precomputed

def build_hanoi(n, src, aux, dst, moves):
    if n == 0: return
    build_hanoi(n - 1, src, dst, aux, moves)
    moves.append((src, dst))
    build_hanoi(n - 1, aux, src, dst, moves)

# Lazy Generator

def lazy_hanoi(n, src, aux, dst):
    if n == 0: return
    yield from lazy_hanoi(n - 1, src, dst, aux)
    yield (src, dst)
    yield from lazy_hanoi(n - 1, aux, src, dst)</code></pre>

<h2>7. Appendix B – Sample Output (n = 3)</h2>
<pre><code>Move disk from A to C
Move disk from A to B
Move disk from C to B
Move disk from A to C
Move disk from B to A
Move disk from B to C
Move disk from A to C</code></pre>

<h2>8. Appendix C – Runtime Measurements (n = 20)</h2>
<pre><code>Precomputed: 1048575 moves in 0.282143 seconds
Lazy:        1048575 moves in 0.250726 seconds
✔ Both methods produced identical move sequences.</code></pre>

<h2>Contextual Note</h2>
<blockquote>
This analysis of the Towers of Hanoi algorithm may seem modest — but it serves a deeper purpose within the SnapOS framework.

It illustrates a central principle of semantic auditability:
the difference between a result and the structure that generates it.

By comparing precomputed and lazy recursion, the article highlights how semantic drift, representational load, and structural inertia emerge — even in a system with fixed rules and predictable outcomes.

In SnapOS, this becomes a model case: where invariance meets method, and where meaning begins to move beneath stable form.

The algorithm remains the same. The representation changes. And with it — the entire audit landscape of structure, load, and drift.
</blockquote>

<hr>
<p class="small">Algorithmic Evaluation · Marko Chalupa · 10.06.2025 · CC BY 4.0</p>

</body>
</html>