Controllers and polarized networks

Why controllers exist

A neural substrate can learn representations while a controller learns how the substrate should operate. Cognia controllers observe selected activity and emit a bounded control signal. This separates content processing from policy without replacing either side with imperative application code.

Current control families are:

gate — scale or enable a pathway;
select — choose or weight alternatives;
polarization — steer the low-dimensional state of a polarized module.

Controllers remain neural components: their output can be trained and inspected, and their effect is declared in the network.

The polarization concept

A polarized module gives every participating neuron a fixed unit direction d_i = (x_i, y_i) in a two-dimensional plane. The module maintains a unit polarization vector p.

Alignment influences a neuron's effective drive:

alignment_i = dot(d_i, p)
polarized_drive_i = ordinary_drive_i * (1 + alpha * alignment_i)

Activity produces a normalized directional centroid c. Without momentum, the module updates it as:

c = sum_i abs(activation_i) * d_i / (epsilon + sum_i abs(activation_i))
p_intrinsic = normalize((1 - eta) * p_previous + eta * c)

With momentum enabled, the runtime first updates directional velocity v = mu * v_previous + eta * c, then adds it to p and normalizes. Here alpha controls how strongly direction biases computation, eta admits new evidence and mu retains directional velocity. Exact field names and constraints are defined by the canonical grammar.

This forms a bidirectional loop: activity rotates the vector, and the vector biases later activity. The vector is therefore a continuous context or operating regime, not a class label and not a replacement for neuron activation.

The axon inspiration

The original concept came from observing that ordinary computer neural networks do not use the axon's physical direction. Cognia repurposes the idea mathematically: each neuron receives a fixed directional coordinate, analogous to an axon direction, and their collective activity produces a module vector.

The analogy motivates the representation; it does not claim that the runtime simulates biological axon geometry. The polarization vector matters because it creates a compact, persistent directional state and a structured way to bias distributed computation.

Polarization without a controller

Without a controller, the direction emerges from the module's own activity. This is appropriate when the desired context should be inferred and retained from the same population that processes the signal.

Useful candidate tasks include:

retaining one of several interpretations after evidence disappears;
trajectory or intent inference from noisy temporal input;
continuous context that should decay or rotate rather than flip as a bit;
reducing collapse of a recurrent population toward a single default response.

The strongest current demonstration is Example 06. Two radar histories lead to an identical current sensor vector. Polarization improves accuracy on the identical-input tail from 84.5% to 92.9% in the checked experiment. This is evidence for improved retention in that controlled setup, not a general benchmark result.

Controller-driven polarization

A controller can set the operating direction from a separate observation:

controller PolarizationSteering {
    interface {
        observe observation[2];
        control polarization direction[2];
    }
    // neural controller implementation
}

network ControlledContext {
    use ContextModule as context;
    use PolarizationSteering as steering;

    // Bind observations to steering.observation here.
    control polarization of context.cells
        with steering.direction by 1.0;
}

At each propagation step, the module first computes its intrinsic update. The normalized controller output is then blended with it:

p_next = normalize((1 - strength) * p_intrinsic
                 + strength * normalize(controller_xy))

strength = 0 leaves the module autonomous; strength = 1 gives the controller full directional authority. Intermediate values combine policy with local evidence.

Semantic constraints prevent ambiguous writes: the controller output must be a polarization port of width two, the target must be a polarized module, strength must constant-fold into [0,1], and one polarization unit may have only one controller.

When a controller adds value

Use controller-driven polarization when the operating regime comes from information or an objective distinct from the module's ordinary inputs—for example:

a short instruction configures how a long ambiguous stream is interpreted;
task identity selects a reusable recurrent substrate regime;
an external risk estimate rotates processing between conservative and exploratory modes;
a learned meta-policy preserves context while the controlled population handles fast observations.

Do not add a controller when a direct input feature or output neuron solves the task more clearly. Polarization is valuable only when distributed state affects subsequent processing.

Current evidence

Example 07 compares controller-driven and autonomous polarization on unseen sequence lengths. Both variants reach 87.5% aggregate accuracy, but the autonomous baseline collapses to chance at late depths 9–11 while the controlled network stays at 100%. The controlled version also makes early settling errors, so the experiment demonstrates long-horizon regime retention—not higher overall accuracy.

How to research it responsibly

A publishable study should add repeated seeds, confidence intervals, parameter sweeps, longer unseen horizons and comparisons with GRU/LSTM/state-space and ordinary reservoir baselines. Measure vector separation, retention curves and downstream performance. Keep controller capacity equal or account for added parameters.

Polarized networks and controller-driven polarization are experimental Cognia concepts. They have promising controlled examples, but no peer-reviewed evidence yet establishes broad scientific benefit.