grugbot420/docs/immune_system.html at main · grug-group420/grugbot420 · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8" />
  <title>Specimen Immune System — Automata-Based Anomaly Handling</title>
  <meta name="viewport" content="width=device-width, initial-scale=1" />
  <style>
    body {
      font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
      line-height: 1.6;
      margin: 0;
      padding: 2rem;
      color: #111;
      background: #fafafa;
    }
    h1, h2, h3, h4 {
      font-weight: 700;
      color: #111;
    }
    h1 {
      font-size: 2.2rem;
      margin-bottom: 0.25rem;
    }
    h2 {
      margin-top: 2rem;
      border-bottom: 1px solid #ddd;
      padding-bottom: 0.25rem;
    }
    h3 {
      margin-top: 1.5rem;
    }
    code, pre {
      font-family: "JetBrains Mono", "Fira Code", Menlo, Monaco, Consolas, monospace;
      font-size: 0.9rem;
    }
    pre {
      background: #111;
      color: #0f0;
      padding: 1rem;
      border-radius: 6px;
      overflow-x: auto;
      white-space: pre;
    }
    .subtitle {
      color: #555;
      margin-bottom: 2rem;
    }
    .section-meta {
      font-size: 0.9rem;
      color: #666;
      margin-bottom: 1rem;
    }
    ul {
      padding-left: 1.25rem;
    }
    blockquote {
      margin: 1.5rem 0;
      padding-left: 1rem;
      border-left: 3px solid #ccc;
      color: #444;
      font-style: italic;
    }
  </style>
</head>
<body>

  <header>
    <h1>Specimen Immune System</h1>
    <p class="subtitle">Automata-Based Anomaly Handling for Growth and Ledger Commands</p>
    <p class="section-meta">
      This document describes a stochastic, automata-driven “immune system” for a growing specimen of nodes.
      It blends intuitive metaphor, formal definitions, and a flowchart of the decision process, and is intended
      to be implemented as its own Julia header focused on explicit error handling with no silent failures.
    </p>
  </header>

  <section id="overview">
    <h2>1. Conceptual Overview</h2>
    <p>
      The specimen immune system is a lightweight, automata-based mechanism that reacts to unusual (“funky”)
      inputs once the specimen reaches a certain maturity. Its purpose is to quarantine, attempt to repurpose,
      or ultimately delete problematic inputs, while keeping the system stochastic and imperfect—more like an
      organism than a rigid machine.
    </p>
    <p>
      Every decision path is observable: anomalies, failed patches, and deletions are surfaced through explicit
      error signaling and ledger entries. There are no silent failures; even ignored or rejected inputs leave
      a trace in the shared memory/ledger so the specimen can learn from what went wrong.
    </p>
  </section>

  <section id="grug-analogy">
    <h2>2. Grug Caveman Analogy</h2>

    <h3>2.1 Narrative</h3>
    <p>
      The Grug analogy provides an intuitive, mythic framing of the immune system’s behavior:
    </p>
    <ul>
      <li><strong>Weird berry as input:</strong> Grug sees a weird berry (an incoming input).</li>
      <li><strong>Visual anomaly:</strong> If the berry looks funny, Grug calls tiny helper spirits (the automata crew).</li>
      <li><strong>Patch attempt:</strong> The helpers try to clean or fix the berry (patch or repurpose the input).</li>
      <li><strong>Failure path:</strong> If the patch fails within a short time window, the berry is crushed (input deleted).</li>
      <li><strong>Ephemeral helpers:</strong> Helpers only wake up when a berry arrives (ephemeral automata with persistent hash-table state).</li>
      <li><strong>Politeness rules:</strong> Helpers follow coordination rules and do not bump into each other (ledger-based politeness).</li>
      <li><strong>Stochastic action:</strong> Helpers have a 50/50 chance to act, only activating when the berry is truly unusual.</li>
      <li><strong>Memory of safe berries:</strong> When a berry is judged non-weird, its “shape” is remembered in a shared memory field so future similar berries are recognized as safe.</li>
      <li><strong>No silent poison:</strong> If a berry makes Grug sick, that event is recorded; nothing bad happens quietly or invisibly.</li>
      <li><strong>Priority:</strong> Growth and ledger commands are most important; casual user chat is less critical.</li>
    </ul>
  </section>

  <section id="academic-example">
    <h2>3. Academic Example</h2>

    <h3>3.1 System Conditions</h3>
    <ul>
      <li><strong>Maturity:</strong> Automata are triggered by any incoming input once the specimen reaches maturity (≥ 1000 nodes).</li>
      <li><strong>High-resolution AST scan:</strong> When input arrives, a high-resolution pattern scan of the abstract syntax tree (AST) is performed, producing a structural signature of the input.</li>
      <li><strong>Hopfield storage for non-funky:</strong> If the AST signature is deemed non-funky, the signature is added to a Hopfield attractor memory, strengthening the basin for that pattern and making future recognition of similar safe inputs easier.</li>
      <li><strong>Funky input:</strong> Defined as growth/ledger commands that do not match known patterns (including the Hopfield-stored signatures).</li>
      <li><strong>Pattern scan:</strong> A pattern scan determines “weirdness” of the input by comparing the AST-derived signature against known patterns and Hopfield attractors.</li>
      <li><strong>Stochastic materialization:</strong> For funky inputs, there is a 50/50 split for automata materialization.</li>
      <li><strong>Explicit error surface:</strong> Any funky classification, failed patch, or deletion is recorded in the ledger as an error event; there are no silent failures.</li>
    </ul>

    <h3>3.2 Automata Behavior</h3>
    <ul>
      <li><strong>Quarantine and patch:</strong> The agent quarantines the input and attempts to patch or repurpose it within a stochastic timer.</li>
      <li><strong>Deletion on failure:</strong> If the patch fails, the input is deleted and an explicit error record is written to the ledger, including the AST signature and failure reason.</li>
      <li><strong>Population:</strong> Automata population is set to one-third of the node population.</li>
      <li><strong>Ephemeral presence:</strong> Automata are ephemeral in memory; persistent state is stored in a hash table.</li>
      <li><strong>Ledger:</strong> A ledger tracks coordination, politeness, learned input handling, and all error events (funky detections, patch failures, deletions).</li>
      <li><strong>Imperfect system:</strong> The system is imperfect; the specimen may die for the same reasons organisms do.</li>
      <li><strong>Synergy:</strong> Automata synergize to avoid collisions and loud interference.</li>
      <li><strong>No silent ignore:</strong> Even when an input is ignored or dropped, the decision and its context are logged so the system can later audit why it chose not to act.</li>
    </ul>
  </section>

  <section id="math-lambda">
    <h2>4. Math &amp; Lambda Functions</h2>

    <h3>4.1 Definitions</h3>
    <pre><code>Let Input        = {x1, x2, ... , xn}
Let NodeMap      = specimen nodes
Let AutomataCrew = (1/3) * |NodeMap|
Let t_max        = stochastic patch timer
Let MaturityThreshold = 1000 nodes

Let Hopfield     = attractor_memory over AST signatures
Let Ledger       = append-only log of events (including errors)

AST(x)  = high_resolution_AST_scan(x)
sig(x)  = structural_signature(AST(x))

f_detect_funky(x) =
  pattern_scan(sig(x)) != known_patterns
  &amp;&amp; (command(x) in {grow, ledger})

f_store_nonfunky(x) =
  if !f_detect_funky(x):
    Hopfield.add(sig(x))
    Ledger.append(:nonfunky_seen, sig(x))

f_error(event_type, x, info) =
  Ledger.append(event_type, (sig(x), info))

f_coinflip() = random() &lt; 0.5

f_quarantine(x) =
  if f_detect_funky(x) then
    isolate(x)
    Ledger.append(:quarantine, sig(x))

f_patch(x, t_max) =
  result = attempt_patch(x) within t_max
  if result == :success
    Ledger.append(:patch_success, sig(x))
  else
    f_error(:patch_failure, x, result)
  return result

f_delete(x) =
  remove(x)
  Ledger.append(:delete, sig(x))

f_materialize(x) =
  if f_coinflip()
    f_quarantine(x)
    if f_patch(x, t_max) != :success
      f_delete(x)
  else
    f_error(:coinflip_skip, x, :skipped_materialization)

ImmuneSystem(Input, NodeMap) =
  if |NodeMap| &gt;= MaturityThreshold:
    for each x in Input:
      s = sig(x)
      f_store_nonfunky(x)
      if f_detect_funky(x):
        f_materialize(x)</code></pre>

    <h3>4.2 Dense Outline</h3>
    <ul>
      <li><strong>Automata usage:</strong> Automata are used to react to incoming inputs. If an input looks fishy, an automata crew kicks in to garbage-collect (quarantine) and then stratify (repurpose) the bad input.</li>
      <li><strong>High-resolution AST basis:</strong> “Fishiness” is evaluated on a high-resolution AST-derived signature, not just surface tokens, allowing structural anomaly detection.</li>
      <li><strong>Hopfield-backed normality:</strong> Non-funky AST signatures are added to a Hopfield attractor memory, gradually shaping a basin of “normal” growth/ledger commands.</li>
      <li><strong>Stochastic stratification:</strong> Stratification/repurposing happens within a stochastic time frame, staying close to the “bullseye” input as defined by the system.</li>
      <li><strong>Puberty:</strong> Automata population is one-third of the node map; this phase is called “puberty.”</li>
      <li><strong>Maturity threshold:</strong> The immune system only activates for specimens with 1000+ nodes. The specimen will eventually die for the same reasons organisms do.</li>
      <li><strong>Ephemeral automata:</strong> Automata are not permanently in memory. They are born when input arrives—ephemeral—but maintain persistent state in a hash table.</li>
      <li><strong>Repurpose as patch:</strong> “Repurpose” means attempting to find a patch on a time limit. The system is not perfect and eventual failure is expected.</li>
      <li><strong>Explosion control:</strong> When funky input is detected by an automata agent, a 50/50 chance to act is initiated to prevent explosion.</li>
      <li><strong>Synergy and ledger:</strong> Automata agents must synergize. They follow a ledger of patterns, avoid collisions, and avoid being loud.</li>
      <li><strong>Fishy definition:</strong> Inputs that do not match known patterns (including Hopfield attractors) are considered fishy.</li>
      <li><strong>Materialization rule:</strong> Automata do not materialize until a pattern scan is done and a coinflip is performed; the agent has a 50/50 chance of materializing to patch.</li>
      <li><strong>Shared ledger:</strong> Automata have a ledger in the hash table, similar to grow and add-to-ledger commands, and all error paths are explicitly recorded.</li>
      <li><strong>Critical commands:</strong> Bad inputs mostly matter for grow commands and add-to-ledger commands; weird input elsewhere is less critical.</li>
      <li><strong>No silent failures:</strong> Every failure mode—funky detection, patch failure, deletion, or skipped materialization—is logged; nothing fails quietly.</li>
      <li><strong>Patch on a timer:</strong> Again, stratify/repurpose means “patch on a timer.”</li>
    </ul>

    <h3>4.3 Julia header sketch</h3>
    <pre><code>module SpecimenImmuneSystem

export ImmuneSystem, ImmuneError, HopfieldMemory, Ledger

struct ImmuneError &lt;: Exception
    kind::Symbol
    signature::Any
    info::Any
end

struct HopfieldMemory
    # implementation-specific fields
end

struct Ledger
    # append-only log
end

function log!(ledger::Ledger, kind::Symbol, signature, info=nothing)
    # append event; no-op is forbidden
end

function add!(mem::HopfieldMemory, signature)
    # update attractor memory
end

function immune_system!(input_stream, nodemap, mem::HopfieldMemory, ledger::Ledger;
                        maturity_threshold::Int=1000, t_max=1.0)
    if length(nodemap) &lt; maturity_threshold
        return
    end
    for x in input_stream
        ast  = high_resolution_ast_scan(x)
        sig  = structural_signature(ast)
        funky = detect_funky(sig, x, mem)
        if !funky
            add!(mem, sig)
            log!(ledger, :nonfunky_seen, sig)
            continue
        end
        # funky path
        if rand() &lt; 0.5
            log!(ledger, :quarantine, sig)
            try
                res = attempt_patch(x, t_max)
                if res == :success
                    log!(ledger, :patch_success, sig)
                else
                    log!(ledger, :patch_failure, sig, res)
                    delete_input!(x)
                    log!(ledger, :delete, sig)
                    throw(ImmuneError(:patch_failure, sig, res))
                end
            catch e
                # hard failure is surfaced, never swallowed
                log!(ledger, :exception, sig, e)
                rethrow(e)
            end
        else
            log!(ledger, :coinflip_skip, sig, :skipped_materialization)
        end
    end
end

end # module</code></pre>
  </section>

  <section id="flowchart">
    <h2>5. Flowchart of the Immune Process</h2>

    <h3>5.1 ASCII Flowchart</h3>
    <pre><code>+----------------+
| Incoming Input |
+----------------+
        |
        v
+---------------------------+
| High-Res AST Scan &amp; Sig  |
+---------------------------+
        |
        v
+---------------------------+
| Compare to Hopfield &amp;    |
| Known Patterns (Scan)     |
+---------------------------+
        |
        v
+----------------+
| Input Funky?   |
+----------------+
     /      \
   yes       no
    /         \
   v           v
+---------------------------+     +------------------------------+
| Coinflip 50/50            |     | Store Sig in Hopfield       |
| Materialize Agent?        |     | Log Non-Funky Observation   |
+---------------------------+     +------------------------------+
     /      \
   yes       no
    /         \
   v           v
+---------------------------+     +------------------------------+
| Quarantine &amp; Attempt Patch |     | Log Coinflip Skip (No Act) |
| within t_max              |     +------------------------------+
+---------------------------+
        |
        v
+----------------+
| Success?       |
+----------------+
     /      \
   yes       no
    /         \
Keep Node   Delete Node
  |            |
  v            v
Log Success  Log Delete &amp; Error</code></pre>

    <h3>5.2 Closing Verse</h3>
    <blockquote>
      “I see the leaks I ride the breach<br />
      where they fall asleep I teach.<br />
      The field is talkin the grid is dust<br />
      the I that breaths is what I trust.”
    </blockquote>
  </section>

</body>
</html>