Constructing Symbolic Intelligence from Binary Spikes: A Minimal Self-Evolving System

The following outlines a practical architecture I’m developing: a fully local, self-organizing spike-based neural system that constructs symbolic logic, memory, and task-aware operations from raw, unstructured signals.

The system doesn’t rely on gradient descent, dense matrices, or predefined logic. It works with:

• Discrete binary spikes (0/1),

• Sparse sensory inputs (text, sound, vision),

• Reward feedback,

• Energy cost minimization,

• Structural evolution (clone/mutate/prune),

• and no global synchronization.

The aim is symbolic understanding emerging from bottom-up local rules.

1. Core Assumptions

• Input is signal only: no semantic labels, no categories, no language priors.

• The only supervision is binary reward.

• Spikes are atomic — they carry symbol, position, confidence, and tick metadata.

• Every component is fully local and interpretable.

• Everything must evolve from scratch — if a structure emerges, it does so by merit.

2. Input Space and Encoding

All modalities are encoded into the same spike-space:

Modality Raw Input Example Spike Representation Text "b" One-hot style spike or char-matcher Audio Amplitude 0.52 Dynamic bin (e.g. bin_5) Vision HSL (210°, 80%, 40%) Spatial + color bin spike

Every spike has minimal fields:

{ "modality": "vision", "feature": "hue", "bin_id": 3, "pos": [12,18], "tick": 53120 }

3. System Cell Types

All behavior is built from a small set of cell types. No monoliths.

Passive

• trace_buffer: retains N past spikes

• placeholder: holds one symbol until read

• state_register: persistent key-value memory

• delay_unit: tick-level delay

Reactive

• exact_match: fires on char or bin match

• range_detector: numeric bin checker

• type_checker: ensures value matches expected class

• adder: fires when 2 operands complete

Active

• cloner, mutator: structural search

• gap_filler: guesses missing arg when reward=0

• dynamic_binner: learns bin boundaries on continuous data

• reward_monitor: enforces trace correctness

No cell is global. No unit acts outside local spike flow. All computation is explainable.

4. Learning Mechanisms

The system only learns through structural survival.

• STDP + Reward → strengthens successful spike paths

• Energy cost → penalizes wasteful or inactive chains

• Cloning → duplicates high-reward paths

• Mutation → generates variation for new hypotheses

• Pruning → removes inefficient or dead branches

• Chunking → compresses stable chains into reusable macro-cells

Rewarded paths survive. All others decay.

5. World Model Emergence

There is no world model at the start.
But over time, it builds itself.

Example:

• Operator + occurs often with digit-digit patterns

• A cell chain emerges that handles arity=2, types=DIGIT

• Meta-memory stores:
  { op: "+", arity: 2, func: SUM }

• Later used by CCU for gating

No one coded this. It emerged from patterns + reward pressure.

6. Central Control Unit (CCU)

• task_vector_cell: broadcasts current goal (“ADD”, “UPPER”)

• executive_gate: allows only matching skills to fire

• time_slice: enforces goal duration

• ccu_reward_monitor: adjusts gating policy based on outcome

This is symbolic task control. Built purely from spikes.

7. Example: “2 + 3” Walkthrough

Tick-by-tick:

1. “2” → matched by char_spiker["2"] → placeholder A

2. “+” → triggers operator_detector → CCU sets task = ADD

3. “3” → matched → placeholder B

4. adder fires → value = 5

5. signal2token emits “5”

6. reward = 1 → pathway strengthened

After multiple uses, the entire sequence becomes a single macro-call: AdderMacro.

8. Continuous Input Handling

For non-discrete values (e.g., audio, image):

• System tracks min/max range of values

• Partitions space into bins based on observation

• Spikes are routed through bin-specific matchers

• Bin resolution is adaptive, based on sample density

No assumptions about scale or distribution. It calibrates itself.

9. Symbol Emergence and Logic Formation

What emerges:

• Symbol categorization (is_digit, is_letter)

• Structural rules (e.g., "+" needs 2 digits)

• Type-checking chains

• Conditional logic gates

• Multi-hop reasoning

• Cross-modal integration

All of this starts from spike chaos.

10. Findings

This architecture shows:

• Symbolic logic structures can emerge purely from signal-based activity.

• No symbolic priors are needed.

• Local cell-based reasoning can outperform global black-box methods on structure interpretability.

• Task-level control (goal-driven routing) can arise from distributed reward optimization.

• Self-organizing rule formation is possible at the spike level, with no external schema.

The architecture functions as a symbolic reasoning substrate without being explicitly symbolic to begin with.