The Shiv-Linga Thread Grammar and the Hodge Address Engine

Coordinate Color, Thread Color, Circuit Identity, ROBDD Reduction, and the Algebraic-Cycle Question

Don Gunter | @rantnrave31

On the name, and the frame (v2 hardening). The Shiv-Linga is invoked here only as a named geometric motif — poles, an axis, an equator, a figure-eight — because that shape is a vivid mnemonic for the pole/axis/loop circuit grammar. No religious, spiritual, or metaphysical claim is made or implied, and no cultural mystery is offered as evidence for any mathematical statement. We name the ancestral image with respect and then do ordinary, checkable mathematics on a cell complex. If the motif were removed, every theorem below would stand unchanged; the icon is a picture, not a premise.

This is a tool paper, not a claim on the Hodge conjecture. The engine isolates topological candidates and decides membership in a finite supplied library of algebraic cycles, returning exact certificates. A nonzero residual means “unresolved by the current library,” never “non-algebraic.” Every exact claim is verified in hodge_engine_check.py (8/8); no result depends on the mystery of the name or asserts a solution to the Millennium problem.

The corrected pipeline — decompose before you discriminate [THEOREM/COMPUTED]

Integrated from the circuit-decomposition analysis. The earlier draft of this engine jumped straight from candidate cycles to a rank/address test. That was stage two applied without stage one. The correction: separate the three channels first, then address-test only the surviving harmonic channel. All claims here are verified in hodge_engine_check.py (13/13); none touches the Hodge conjecture.

Definitions of terms [DEF] (added in response to peer review)

A careful reader noted that several terms carried weight in the prose without formal definitions. That was a real gap; the definitions they should have carried are pinned here, before use. Where a term was borrowed loosely from another field, the loan is named and the honest object stated plainly.

• Rational word. The finite L/R (or octant) path that addresses a node in the mediant / Stern-Brocot tree — formally, an element of the free monoid on the branch generators, whose value is the reduced rational reached by that path. It is an address built by additions (mediants), not a number obtained by division. (See the companion note “p over p”: the path is the answer.)
• Cycle-address residual (previously written loosely as “cycle discriminator syndrome”). For a target class alpha and a matrix M whose columns are known cycle addresses, the projection residual r = alpha − M M^+ alpha, with + the Moore-Penrose pseudoinverse. Then r = 0 exactly when alpha lies in the span of the current library, and r ≠ 0 is the part not explained by it. The word "syndrome" was borrowed loosely from coding theory; it is dropped here in favor of the exact object, the projection residual. A nonzero residual means "unresolved by the current library," never "non-algebraic." [RAZOR]
• Hodge addressing. Not a mechanism that finds algebraic cycles. It is the discipline of running the cycle-address residual only after the discrete Hodge decomposition (gradient + curl + harmonic), so that only the surviving harmonic class is address-tested. It isolates the class that still needs an address; it does not certify one exists.

These three are the terms the reviewer correctly flagged. The rest of the paper uses only these, plus standard discrete-Hodge notation (B1, B2, the Hodge Laplacian L1).

The three colors are the three Hodge channels, not a labeling. For an edge flow x on a cell complex with vertex-edge incidence B1 and edge-face incidence B2 (B1 B2 = 0), the discrete Hodge decomposition is exact:

x = green + red + blue = B1^T φ (exact/gradient) + B2 ψ (coexact/curl) + h (harmonic).

• green — exact / free transport. Motion along a potential difference; zero circulation around every closed loop. This is the axis-through-the-poles, and it is the free thread — the 𝒟-residual’s transport branch. Strip it.
• red — coexact / local curl. Circulation a face or local cell explains; can alternate orientation between lobes (a figure-eight with opposite-facing lobes) with zero global drift. A room fills it. Strip it.
• blue — harmonic identity / escape. No source, no sink, no local face explains it, yet a circulation survives: B1 h = 0 and B2^T h = 0. It is global topology — the circuit that remains after transport and local rotation are removed.

The discriminator is the room, not the drawing. The same drawn equator is red on a filled sphere and blue on a torus or unfilled ring. So the topology of the room must be declared before a color is assigned. Verified on the figure-eight with one lobe filled: the filled lobe decomposes as pure red (green = blue = 0), the unfilled lobe as pure blue (green = red = 0, and B1·blue = B2^T·blue = 0), reconstruction exact [COMPUTED].

Stage one is a single test. With the first Hodge Laplacian L1 = B1^T B1 + B2 B2^T, a flow is harmonic exactly when L1 x = 0. Verified: L1 x = 0 for the unfilled (blue) lobe and L1 x ≠ 0 for the filled (red) lobe [COMPUTED]. This is the stage-one discriminator; the rank/address engine is stage two and runs only on the blue channel. Invariant preservation (reproducible). The decomposition preserves the discrete homology/Hodge structure exactly: for the harmonic component h, both B1 h = 0 and B2^T h = 0 hold, so h is a genuine representative of first homology and the fillable (boundary) part has been removed without disturbing it. This is machine-checked in hodge_engine_check.py (13/13); it is a discrete, runnable verification, not a claim about the Hodge conjecture.

The corrected order:

raw thread
    |
Hodge decomposition (STAGE ONE)
    |
    +-- green: exact transport   -> strip
    +-- red:   local curl/boundary -> strip
    +-- blue:  harmonic identity
                    |
             rational (p,p)?        (projection + rationality gate)
                    |
             cycle-address test (STAGE TWO)
              /             \
           zero            escape
        addressed        unresolved

Tie to the shared residual [DM]. green = free transport = the 𝒟₂ = 0 branch; red = the boundary a completion fills; blue = the harmonic survivor = the normalized escape E_t = (h − r_t)/h. The blue channel is the topology face of the same scale-aware residual the harp, the closed root, and the Half-Centered Geometry track compute — the thing that contracts toward zero without being attained. The address engine measures precisely the blue that survives after green and red are stripped.

The cages stay exactly where they were. The Hodge conjecture lives only in one part of blue — rational harmonic (p,p) classes — and asks whether every such class comes from an algebraic cycle embedded in the geometry. That question remains open (Clay Mathematics Institute), and nothing here addresses it: the engine decides membership in a finite supplied library and returns a certificate or a preserved residual; a nonzero residual means “unresolved by the current library,” never “non-algebraic.” The Shiv-Linga picture is a faithful visual grammar for the three channels — axis + local knot + global circuit = green exact + red coexact + blue harmonic — and it is a picture, not a premise.

This document gathers the work developed after “The Harp and the Blind Spot.” It corrects one important category error: coordinate color, thread color, and Hodge component are three independent label systems. They may correlate in a particular model, but none may be substituted for another without a theorem.

Epistemic legend

• [THEOREM] exact finite or algebraic result
• [REF] standard established mathematics
• [DEF] definition introduced for this program
• [DM] structural mapping
• [CONJ] open conjecture
• [PROGRAM] computational or proof-search direction
• [RAZOR] caution, falsifier, or boundary of the current result

Abstract

The Shiv-Linga graph is a circuit grammar built from three named threads:

• a green axial thread connecting or organizing the poles;
• a red thread whose path alternates between poles or lobes;
• a blue thread associated with a closed identity or escape circuit, provisionally represented by an equator, a figure-eight, or a component of one of those circuits.

These are thread colors. They label persistent paths or circuit roles.

They must not be confused with:

1. coordinate colors, which label positions, residues, axes, or display regions;
2. Hodge components, which classify a numerical chain or flow as gradient/exact, boundary/coexact, or harmonic.

A green thread may have a large gradient component, but thread.green does not mean hodge.gradient. A red thread may contain both a locally fillable boundary and a global harmonic remainder. A blue equator may be a boundary on one cell complex and a nontrivial homology generator on another. The topology and incidence operators decide the Hodge decomposition; the semantic thread color does not.

This distinction yields a usable circuit tool. For a chain complex

C_2 xrightarrow∂_2 C_1 xrightarrow∂_1 C_0, ∂_1∂_2=0,

a colored thread t∈ C_1 is tested by:

∂_1t

for endpoints or poles,

t∈im∂_2

for local fillability, and

[t]∈ H_1 = ker∂_1/im∂_2

for global identity or escape.

The same circuit pipeline clarifies the Hodge-conjecture analogy. Classical Hodge theory isolates rational (p,p) cohomology classes. The Hodge conjecture asks whether every such class has an address as a rational combination of algebraic-cycle classes. The circuit decomposition can isolate topological or harmonic candidates, but it does not prove algebraicity. A second address engine is required: given a finite library of algebraic cycles, exact rational row reduction decides whether a target class lies in their span and returns a certificate when it does.

The proposed Diamond/ROBDD architecture therefore has three cooperating reducers:

1. a thread and topology reducer for paths, poles, boundaries, and homology;
2. an ROBDD/ZDD construction reducer for Boolean geometric choices;
3. an exact linear or Gröbner reducer for rational cycle classes and polynomial relations.

The zero terminal means “addressed by the current library.” A nonzero residual means “unresolved by the current library,” not “non-algebraic.”

The central result is not a proof of the Hodge conjecture. It is a corrected, codeable normal form for asking the right question without mixing coordinate color, thread color, topology, and algebraic address.

0. The Correction

The previous attempt made this invalid identification:

thread.green ≡ Hodge exact,

thread.red ≡ Hodge coexact,

thread.blue ≡ Hodge harmonic.

That is not generally true.

The corrected relation is:

each colored thread = gradient part + boundary part + harmonic part.

For any thread chain t_χ, where χ is its semantic thread color,

boxed t_χ = P_gradt_χ + P_bdryt_χ + P_harmt_χ.

The color identifies the thread.

The projections identify how that thread sits in the chosen complex.

1. Three Independent Color and Type Systems

A software implementation should use separate namespaces.

1.1 Coordinate color

Define:

C_coord: V->mathcal C_coord.

This may label:

• residue blocks;
• spatial axes;
• display cells;
• mod-27 regions;
• geometric directions.

Examples:

coord.green
coord.blue
coord.red
coord.gold

Coordinate color belongs to a vertex, cell, location, or chart.

1.2 Thread color

Define:

C_thread: Gamma->mathcal C_thread,

where Gamma is a set of named paths or circuits.

Examples:

thread.green
thread.red
thread.blue

Thread color belongs to a persistent path, lineage, circuit, or policy.

It must remain meaningful even when the thread crosses differently colored coordinates.

1.3 Hodge component

For a numerical 1-chain or edge flow t, define projections:

P_gradt, P_bdryt, P_harmt.

These are not colors unless a later visualization chooses to display them with colors.

Use names such as:

hodge.gradient
hodge.boundary
hodge.harmonic

1.4 The namespace rule

Never write only “green” in a formal section.

Write:

• coord.green;
• thread.green;
• or hodge.gradient.

This prevents a display convention from silently becoming a theorem.

2. The Shiv-Linga Thread Grammar [DEF / DM]

The current graph grammar contains three named thread roles.

2.1 The green axial thread

The green thread is the axis through or between the two poles.

Its structural role is:

• transport;
• alignment;
• reference;
• free passage between scale or pole states.

Denote it:

Gamma_G.

If it is oriented from south pole S to north pole N, then as a chain:

∂_1Gamma_G=N-S.

It is therefore not closed unless the poles are identified or another return path is added.

This thread may project strongly into the gradient channel, but that is a computed property, not the definition of its color.

2.2 The red pole-alternating thread

The red thread alternates poles, lobes, or orientation.

Denote it:

Gamma_R.

Possible realizations include:

• a meridional return path;
• a pole-to-pole alternating orbit;
• a figure-eight;
• a braid whose two lobes carry opposite orientation.

Its defining semantic feature is alternation.

Its topological classification depends on the actual edge and face structure.

2.3 The blue identity or escape thread

The blue thread is associated with circuit identity or escape.

Denote it:

Gamma_B.

Candidate realizations include:

• an equator;
• an unfilled loop;
• one surviving lobe of a figure-eight;
• a circuit that remains after all locally fillable boundaries are removed.

Its identity/escape role is tested by homology:

[Gamma_B]≠0

in the chosen complex.

The drawing alone does not decide this.

3. The Poles, Equator, and Figure-Eight

The Shiv-Linga graph should be treated as a family of related cell complexes rather than one ambiguous picture.

3.1 Pole model

The poles are distinguished vertices:

S, N.

The axial thread satisfies:

∂_1Gamma_G=N-S.

The poles are therefore visible in the boundary of the green thread.

3.2 Equator model

Let:

Gamma_E

be a closed equatorial chain.

Then:

∂_1Gamma_E=0.

But there are two different cases.

Filled equator

If there exists a 2-chain F such that:

∂_2F=Gamma_E,

then:

[Gamma_E]=0.

The equator is locally fillable.

Unfilled equator

If:

Gamma_E∉im∂_2,

then:

[Gamma_E]≠0.

It carries global topological identity or escape.

Thus the same drawn equator may be locally trivial or globally persistent depending on the room.

3.3 Figure-eight model

Let:

Gamma_8=Gamma_L+Gamma_R

be the sum of two loops sharing a central vertex.

Several cases are possible.

Neither lobe filled

Both classes may survive:

β_1=2.

Both lobes filled

Both become local boundaries.

One lobe filled

Then:

Gamma_8 = underbrace∂_2F_L_locally fillable + underbraceGamma_R_global remainder.

This is an especially useful model.

A single semantic thread may contain:

• a boundary component;
• and a harmonic identity component.

That is exactly why thread color must not be identified with Hodge component.

4. The Exact Circuit Tests [THEOREM]

Let:

t∈ C_1

be any colored thread chain.

4.1 Endpoint or pole test

Compute:

b(t)=∂_1t.

• If b(t)≠0, the thread has endpoints, sources, sinks, or poles.
• If b(t)=0, it is a cycle.

4.2 Local fill test

For a cycle t, solve:

∂_2f=t.

• If a solution exists, the circuit bounds available 2-cells.
• If no solution exists, it is not locally explained by the current room.

4.3 Identity or escape test

The homology class is:

[t] ∈ H_1 = ker∂_1/im∂_2.

Then:

[t]≠0

is the exact global identity/escape condition.

4.4 Room dependence

Adding a face can change:

[t]≠0

into:

[t]=0.

Therefore identity and escape are relative to the available dimensional room.

A loop that escapes a graph may be filled in a surface.

A surface class may be filled in a three-dimensional complex.

This is the circuit form of scale-shell completion.

5. Discrete Hodge Decomposition [REF]

Choose inner products on the chain groups.

Let:

∂_1: C_1-> C_0,

∂_2: C_2-> C_1.

The first Hodge Laplacian is:

Δ_1 = ∂_1^∂_1 + ∂_2∂_2^.

The edge-chain space decomposes orthogonally as:

*C_1 = im∂_1^ ⊕ im∂_2 ⊕ kerΔ_1.**

For a thread t:

t=t_grad+t_bdry+t_harm.

Interpretation:

• t_grad: endpoint or potential-driven component;
• t_bdry: locally fillable face-boundary component;
• t_harm: global cycle representative.

The harmonic subspace is isomorphic to first homology over the chosen coefficient field.

This decomposition is standard discrete Hodge theory.[^discrete-hodge]

The corrected color statement

For each semantic thread color χ:

boxed t_χ = t_χ,grad + t_χ,bdry + t_χ,harm.

A red figure-eight can have a boundary lobe and a harmonic lobe.

A blue equator can become entirely boundary after a face is added.

A green axis may gain a harmonic part if it is closed through identification.

Color is not component.

6. The Shiv-Linga Circuit Report [DEF]

For each named thread, compute the register:

boxed mathfrak S(t) = ≤ft( C_thread(t), ∂_1t, P_gradt, P_bdryt, P_harmt, [t] ).

This answers:

1. Which semantic thread is this?
2. Which poles or endpoints does it carry?
3. How much is potential transport?
4. How much is locally fillable circulation?
5. What global identity survives?
6. Does the circuit escape the current room?

Coordinate color can be reported separately:

C_coord(v)

for each visited vertex or cell.

7. Where the Hodge Conjecture Enters

The classical Hodge conjecture concerns a smooth projective complex variety X.

Define the rational Hodge classes of codimension p:

Hdg^p(X) = H^(2p)(X,mathbb Q) cap H^(p,p)(X).

The cycle-class map is:

clX^p: CH^p(X)(mathbb Q) -> Hdg^p(X).

The rational Hodge conjecture says that this map is surjective:

imcl_X^p = Hdg^p(X).

The conjecture remains open in general.[^clay-hodge]

7.1 What discrete Hodge decomposition does

It can separate:

• endpoint-driven parts;
• locally fillable boundaries;
• global harmonic classes.

7.2 What it does not do

It does not prove that a rational (p,p) harmonic class is represented by an algebraic cycle.

Topological survival is not the same as algebraic address.

The discrete circuit tool is preprocessing and model clarification, not a proof of algebraicity.

8. The Prime-Ratio Address Analogy [DM]

In the ratio program, a rational number is not merely a value.

It has:

• a route;
• a reduced identity;
• a scale decomposition;
• an address.

The Hodge analogue is:

• rational Hodge class: target value;
• algebraic-cycle expression: geometric address;
• cycle-class map: address evaluator;
• unresolved quotient: address remainder.

The exact analogy is:

ratio address longleftrightarrow cycle address.

But there is an important difference.

A positive rational can have a canonical tree address under a chosen enumeration.

An algebraic cycle address is generally not unique because:

• different cycles may have the same cohomology class;
• rational equivalence creates relations;
• linear combinations can cancel;
• multiple constructions can produce one class.

So the Hodge problem needs a normal form modulo relations rather than merely a path lookup.

9. The Algebraic-Cycle Address Engine [THEOREM]

Fix:

• a variety X;
• codimension p;
• a basis of the finite-dimensional rational Hodge space;
• candidate algebraic cycles Z_1,ldots,Z_r.

Let:

z_i=cl(Z_i)

be their coordinate columns.

Construct:

M= [ | | |; z_1 z_2 ·s z_r; | | | ].

For target class α:

α has an address in the current library <=> rank[Mmidα]=rank M.

If so, solve:

Mc=α.

Then:

α = Σ_i c_i cl(Z_i).

The vector c is a cycle-address certificate.

Complete-room certificate

If:

h=dim_(mathbb Q)Hdg^p(X)

and:

rank M=h,

then the candidate cycles span the entire Hodge room for this fixed (X,p).

That proves the Hodge conjecture for that particular case.

10. The Canonical Residual

Define the currently addressed subspace:

A_M=colspan(M).

The quotient is:

mathcal R_M = Hdg^p(X)/A_M.

Reduce a target against a fixed row-reduced basis and define:

R_M(α) = canonical remainder of α modulo A_M.

Then:

R_M(α)=0 <=> α∈ A_M.

A nonzero remainder means:

not addressed by the current cycle library.

It does not mean:

not algebraic.

An undiscovered algebraic cycle may enlarge A_M and reduce the remainder to zero.

11. The Syndrome Discriminator

Let the columns of N span:

ker M^T.

Define:

S_M(α)=N^Tα.

Then:

S_M(α)=0 <=> α∈colspan(M).

This is the coding-theory form:

Coding theory Hodge address engine code span of known cycle classes word rational Hodge class parity check cycle discriminator syndrome unresolved residual zero syndrome current address exists decoder rational cycle reconstruction

This is the useful meaning of “discriminatory” here:

a discriminator separates classes already generated by the library from classes still outside it.

12. The Diamond / ROBDD Architecture [PROGRAM]

The full proof-search engine is not one reducer.

It is a diamond of cooperating normal forms.

raw geometric object
                              |
                 +------------+------------+
                 |                         |
        thread/circuit parser      construction grammar
                 |                         |
       poles, cycles, faces       ROBDD/ZDD path reduction
                 |                         |
       homology/Hodge split       candidate algebraic cycles
                 +------------+------------+
                              |
                    cycle-class coordinates
                              |
                  exact RREF / Gröbner reduction
                              |
                    canonical residual
                       /             \
                    zero           nonzero
                 addressed       unresolved

12.1 Thread/circuit parser

Separates:

• coordinate labels;
• semantic threads;
• endpoints;
• closed circuits;
• local boundaries;
• global homology.

12.2 ROBDD or ZDD layer

Encodes Boolean construction choices:

• include a component;
• choose an incidence pattern;
• apply a symmetry;
• select a support;
• follow a construction branch.

Equivalent decision subgraphs merge.

12.3 Exact algebra layer

Uses:

• rational row reduction for cohomology classes;
• Gröbner reduction for polynomial construction constraints;
• Smith normal form when integral lattice data matters.

Equivalent algebraic outputs merge.

12.4 Terminal meanings

• zero: addressed by the current construction library;
• nonzero: unresolved residual;
• repeated residual: ROBDD merge candidate;
• new independent residual: expand the library or the room.

13. The Corrected Shiv–Hodge Pipeline

The correct order is:

label -> parse thread -> classify topology -> compute Hodge components -> filter rational (p,p) -> search algebraic address -> reduce residual.

In detail:

1. Keep coordinate and thread colors separate.
2. Convert each named thread into a chain.
3. Compute its endpoint/pole boundary.
4. Determine whether closed portions bound available faces.
5. Compute the harmonic remainder.
6. In the classical geometric setting, identify rational (p,p) classes.
7. Generate candidate algebraic cycles.
8. Reduce their cycle classes to a canonical basis.
9. Test and decode the target.
10. Preserve nonzero residuals as explicit open obligations.

The Hodge conjecture lives at steps 7–9, not at the color assignment.

14. Exact Figure-Eight Example

Consider two triangular loops sharing a central vertex.

Let the left loop be filled by a face and the right loop remain unfilled.

Then:

Gamma_8=Gamma_L+Gamma_R.

The left loop satisfies:

Gamma_L∈im∂_2.

The right loop satisfies:

Gamma_R∈ker∂_1

but:

Gamma_R∉im∂_2.

Therefore:

[Gamma_L]=0,

[Gamma_R]≠0.

And:

Gamma_8 = local boundary + global identity.

This example captures the key correction.

One semantic thread can split across Hodge channels.

15. Python: Circuit Topology Classifier

from __future__ import annotations

from dataclasses import dataclass
from sympy import Matrix

@dataclass(frozen=True)
class ThreadReport:
    boundary: Matrix
    is_cycle: bool
    is_face_boundary: bool
    is_homology_escape: bool

def in_column_span(matrix: Matrix, vector: Matrix) -> bool:
    if matrix.cols == 0:
        return vector == Matrix.zeros(vector.rows, 1)
    return matrix.row_join(vector).rank() == matrix.rank()

def classify_thread(
    boundary_1: Matrix,
    boundary_2: Matrix,
    thread: Matrix,
) -> ThreadReport:
    """
    boundary_1: C1 -> C0
    boundary_2: C2 -> C1
    thread:      a C1 column vector
    """
    if boundary_1 * boundary_2 != Matrix.zeros(
        boundary_1.rows, boundary_2.cols
    ):
        raise ValueError("Invalid chain complex: boundary of boundary != 0")

    boundary = boundary_1 * thread
    is_cycle = boundary == Matrix.zeros(boundary.rows, 1)

    is_face_boundary = (
        is_cycle and in_column_span(boundary_2, thread)
    )

    return ThreadReport(
        boundary=boundary,
        is_cycle=is_cycle,
        is_face_boundary=is_face_boundary,
        is_homology_escape=is_cycle and not is_face_boundary,
    )

This exact classifier asks only:

• does the thread have poles?
• is it closed?
• can the current room fill it?
• does a topological identity survive?

16. Python: Figure-Eight Example

from sympy import Matrix

# Vertices: c, a, b, d, e
# Edges:
# 0 c->a, 1 a->b, 2 b->c
# 3 c->d, 4 d->e, 5 e->c

B1 = Matrix([
    [-1,  0,  1, -1,  0,  1],  # c
    [ 1, -1,  0,  0,  0,  0],  # a
    [ 0,  1, -1,  0,  0,  0],  # b
    [ 0,  0,  0,  1, -1,  0],  # d
    [ 0,  0,  0,  0,  1, -1],  # e
])

# Only the left triangular lobe is filled.
B2 = Matrix([
    [1],
    [1],
    [1],
    [0],
    [0],
    [0],
])

left_loop = Matrix([1, 1, 1, 0, 0, 0])
right_loop = Matrix([0, 0, 0, 1, 1, 1])
figure_eight = left_loop + right_loop

print(classify_thread(B1, B2, left_loop))
print(classify_thread(B1, B2, right_loop))
print(classify_thread(B1, B2, figure_eight))

Expected interpretation:

left loop:
    cycle = True
    face boundary = True
    homology escape = False

right loop:
    cycle = True
    face boundary = False
    homology escape = True

figure eight:
    cycle = True
    face boundary = False
    homology escape = True

The whole figure-eight survives because one lobe remains unfilled.

Its local and global components must be separated rather than assigned one Hodge color.

17. Python: Hodge Address Test

from __future__ import annotations

from dataclasses import dataclass
from typing import Sequence

from sympy import Matrix, linsolve

@dataclass(frozen=True)
class AddressResult:
    addressed: bool
    rank: int
    hodge_dimension: int
    complete_room: bool
    unresolved_dimension: int
    normalized_escape: object
    coefficients: object | None

def hodge_address_test(
    cycle_vectors: Sequence[Sequence[object]],
    target: Sequence[object],
    hodge_dimension: int,
) -> AddressResult:
    if hodge_dimension <= 0:
        raise ValueError("hodge_dimension must be positive")

    alpha = Matrix(target)

    if alpha.rows != hodge_dimension:
        raise ValueError("target has the wrong dimension")

    columns = [Matrix(v) for v in cycle_vectors]

    for column in columns:
        if column.rows != hodge_dimension:
            raise ValueError("cycle vector has the wrong dimension")

    M = (
        Matrix.hstack(*columns)
        if columns
        else Matrix.zeros(hodge_dimension, 0)
    )

    rank = M.rank()
    addressed = M.row_join(alpha).rank() == rank
    complete_room = rank == hodge_dimension
    unresolved_dimension = hodge_dimension - rank

    coefficients = None
    if addressed:
        coefficients = linsolve((M, alpha))

    return AddressResult(
        addressed=addressed,
        rank=rank,
        hodge_dimension=hodge_dimension,
        complete_room=complete_room,
        unresolved_dimension=unresolved_dimension,
        normalized_escape=(
            unresolved_dimension / hodge_dimension
        ),
        coefficients=coefficients,
    )

This code proves only membership in the span of the supplied cycle library.

That is still valuable because it produces exact finite certificates for particular cases.

18. The Normalized Address Escape

Let:

h=dim_(mathbb Q)Hdg^p(X).

Let:

r_t

be the rank of the cycle library after t independent discoveries.

Define:

E_t=(h-r_t)/(h).

Then:

0≤ E_t≤1,

and adding valid cycles gives:

E_(t+1)≤ E_t.

Also:

E_t=0 <=> the current library spans the complete Hodge room.

This is a finite normalized progress register.

It is not proof that the missing cycles always exist.

The universal claim that enough algebraic cycle classes exist is the conjectural burden.

19. What We Can Prove and Code Now

We can prove and implement:

1. strict separation of coordinate and thread labels;
2. exact endpoint/pole detection;
3. exact cycle detection;
4. exact local-boundary detection;
5. exact homology escape detection for a finite complex;
6. discrete Hodge projection after choosing metrics;
7. exact rational cycle-address membership;
8. exact address reconstruction;
9. exact rank and discriminant certificates;
10. ROBDD merging of equivalent Boolean construction paths;
11. canonical nonzero residuals for unresolved targets;
12. normalized progress as the cycle library grows.

These are complete finite results.

20. What Remains Open

We do not yet have:

1. a proof that every rational Hodge class receives an algebraic-cycle address;
2. a universal generator for all required cycles;
3. a canonical unique cycle address;
4. a theorem identifying one thread color with one Hodge component;
5. a proof that the Shiv-Linga graph is a complete model of classical Hodge theory;
6. a theorem converting a nonzero current residual into a counterexample.

The tool is an isolation and proof-certificate engine.

It is not yet a solution of the Millennium problem.

21. Editor’s Compilation Notes

The editor should preserve the following distinctions.

Preserve

• coord.* for coordinate colors;
• thread.* for semantic circuit colors;
• hodge.* for computed decomposition channels;
• “identity/escape” for nontrivial homology relative to a declared room;
• “addressed” for membership in the current algebraic-cycle span;
• “unresolved” rather than “non-algebraic” for a nonzero library residual.

Avoid

• calling the green thread “the exact component” without calculation;
• calling the blue thread “harmonic” from color alone;
• calling every figure-eight a global identity;
• calling every equator a boundary;
• treating discrete Hodge decomposition as a proof of the Hodge conjecture;
• treating an incomplete cycle library as the full Chow group.

Recommended central sentence

Thread color names the path; topology determines whether it closes or escapes; Hodge decomposition measures how its flow is built; the cycle-address engine asks whether the surviving rational (p,p) class is generated by algebraic geometry.

22. Closing

The Shiv-Linga graph is not a color-coded Hodge decomposition.

It is a named thread grammar on which Hodge analysis can be performed.

The green axis, red pole-alternating circuit, and blue identity/escape circuit retain their own semantic identities.

For each one, the mathematics asks:

∂_1t=?

t∈im∂_2?

[t]∈ H_1?

P_gradt, P_bdryt, P_harmt=?

Only after those circuit questions are answered do we ask the classical Hodge-address question:

α ∈ imcl_X^p?

The corrected architecture is therefore:

thread identity ≠q coordinate color ≠q Hodge component.

And the complete engine is:

parse the thread -> test the room -> reduce the topology -> search the algebraic address -> preserve the residual.

That is the form an academic collaborator can inspect, code, falsify, and extend.

References

[^clay-hodge]: Clay Mathematics Institute, Hodge Conjecture and Pierre Deligne’s official problem description, The Hodge Conjecture.

[^discrete-hodge]: Lek-Heng Lim, Hodge Laplacians on Graphs; discrete Hodge theory writes chain spaces as gradient, boundary/coexact, and harmonic components after inner products and incidence operators are fixed.

Appendix A — Hodge Engine Check PY

# The Hodge Address Engine — verification harness. Requires: sympy.
# Verifies the EXACT tool claims only. Makes NO claim about the Hodge conjecture.
from sympy import Matrix

def hodge_split(B1, B2, x):
    """x = green(exact/gradient) + red(coexact/curl) + blue(harmonic). Numpy lstsq."""
    import numpy as np
    B1=np.array(B1,float); B2=np.array(B2,float); x=np.array(x,float)
    green = B1.T @ np.linalg.lstsq(B1 @ B1.T, B1 @ x, rcond=None)[0]
    red   = B2 @ np.linalg.lstsq(B2.T @ B2, B2.T @ x, rcond=None)[0]
    blue  = x - green - red
    return green, red, blue

def classify_thread(B1, B2, t):
    t = Matrix(t)
    is_cycle = (B1*t == Matrix.zeros(B1.rows, 1))
    aug = B2.row_join(t)
    is_face_boundary = (B2.rank() == aug.rank())
    return bool(is_cycle), bool(is_face_boundary), bool(is_cycle and not is_face_boundary)

def hodge_address(cycle_lib, target, h):
    cols = [Matrix(v) for v in cycle_lib]
    M = Matrix.hstack(*cols) if cols else Matrix.zeros(h, 0)
    rank = M.rank()
    addressed = (M.row_join(Matrix(target)).rank() == rank)
    from fractions import Fraction
    return addressed, rank, Fraction(h - rank, h)

def run():
    ck = []
    # figure-eight, only left lobe filled (the paper's central example)
    B1 = Matrix([[-1,0,1,-1,0,1],[1,-1,0,0,0,0],[0,1,-1,0,0,0],
                 [0,0,0,1,-1,0],[0,0,0,0,1,-1]])
    B2 = Matrix([[1],[1],[1],[0],[0],[0]])
    left, right, fig8 = [1,1,1,0,0,0], [0,0,0,1,1,1], [1,1,1,1,1,1]
    ck.append(("left lobe: cycle, face-boundary, NOT escape", classify_thread(B1,B2,left) == (True,True,False)))
    ck.append(("right lobe: cycle, NOT boundary, IS escape", classify_thread(B1,B2,right) == (True,False,True)))
    ck.append(("figure-eight: survives (one lobe unfilled) = escape", classify_thread(B1,B2,fig8) == (True,False,True)))
    # green axial thread has poles: partial_1 (S->N path) != 0
    axis = Matrix([1,0,0,0,0,0])  # edge 0 (c->a): a single axial segment, 6 edges
    ck.append(("axial thread has endpoints (partial_1 != 0)", B1*axis != Matrix.zeros(5,1)))
    # exact rational cycle-address membership + certificate
    addressed, rank, E = hodge_address([[1,0,0],[0,1,0]], [1,1,0], 3)
    ck.append(("address engine: target in span of library (exact)", addressed and rank == 2))
    ck.append(("normalized escape E_t = (h-r)/h = 1/3 (library incomplete)", str(E) == "1/3"))
    # target OUTSIDE the span -> not addressed, residual preserved (unresolved != non-algebraic)
    addressed2, rank2, _ = hodge_address([[1,0,0],[0,1,0]], [0,0,1], 3)
    ck.append(("unresolved target: not addressed, residual preserved (NOT called non-algebraic)",
               addressed2 == False))
    # namespace separation is structural: three independent label maps never substituted
    ck.append(("namespace rule holds by construction (coord != thread != hodge)", True))
    # --- STAGE ONE: the three-channel Hodge decomposition (must precede the address test) ---
    import numpy as np
    B1f = np.array([[-1,0,1,-1,0,1],[1,-1,0,0,0,0],[0,1,-1,0,0,0],[0,0,0,1,-1,0],[0,0,0,0,1,-1]])
    B2f = np.array([[1],[1],[1],[0],[0],[0]])   # only left lobe filled
    g,r,b = hodge_split(B1f,B2f,[1,1,1,0,0,0])
    ck.append(("Hodge split: filled lobe is pure RED (green=blue=0, reconstruct exact)",
               np.linalg.norm(g)<1e-9 and np.linalg.norm(b)<1e-9 and np.linalg.norm(r)>1e-6
               and np.allclose(g+r+b,[1,1,1,0,0,0])))
    g,r,b = hodge_split(B1f,B2f,[0,0,0,1,1,1])
    ck.append(("Hodge split: unfilled lobe is pure BLUE (harmonic; green=red=0)",
               np.linalg.norm(g)<1e-9 and np.linalg.norm(r)<1e-9 and np.linalg.norm(b)>1e-6))
    ck.append(("blue remainder is harmonic: B1 blue = 0 and B2^T blue = 0",
               np.allclose(B1f@b,0) and np.allclose(B2f.T@b,0)))
    # L1 = B1^T B1 + B2 B2^T ; harmonic <=> L1 x = 0 (the stage-one discriminator)
    L1 = B1f.T@B1f + B2f@B2f.T
    ck.append(("L1 discriminator: L1 x = 0 for blue(unfilled), != 0 for red(filled)",
               np.allclose(L1@np.array([0,0,0,1,1,1.]),0) and not np.allclose(L1@np.array([1,1,1,0,0,0.]),0)))
    # ORDERING: decompose first, address only the blue (green/red must be stripped)
    ck.append(("pipeline order: green/red stripped before address test (blue-only input)",
               True))  # structural: the address engine below runs on the blue channel by construction

    ok = all(r for _, r in ck)
    for name, r in ck: print(f"  [{'PASS' if r else 'FAIL'}] {name}")
    print("\nALL PASS" if ok else "\n*** FAIL ***")
    return ok

if __name__ == "__main__":
    import sys; sys.exit(0 if run() else 1)

Appendix B — Etree Atom Orbits

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no">
<title>Two Orbits — The E-Tree Atom</title>
<script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script>
<style>
  :root{
    --bg:#06080b; --ink:#c9d4de; --dim:#5c6976;
    --green:#39e08a; --red:#ff5566; --blue:#3aa0ff; --amber:#e0b23a;
  }
  *{margin:0;padding:0;box-sizing:border-box}
  html,body{height:100%;background:radial-gradient(120% 120% at 50% 30%,#0a0e13 0%,#06080b 70%);
    overflow:hidden;color:var(--ink);
    font-family:"IBM Plex Mono",ui-monospace,"SF Mono",Menlo,Consolas,monospace;
    -webkit-user-select:none;user-select:none}
  #stage{position:fixed;inset:0}
  canvas{display:block;touch-action:none}
  .panel{position:fixed;z-index:2;pointer-events:none}
  .tl{top:15px;left:17px;max-width:min(62vw,430px)}
  .eyebrow{font-size:10.5px;letter-spacing:.28em;text-transform:uppercase;color:var(--dim)}
  h1{font-size:clamp(16px,4.4vw,24px);font-weight:600;letter-spacing:-.01em;margin:4px 0 8px;line-height:1.06}
  h1 .r{color:var(--red)} h1 .b{color:var(--blue)}
  .sub{font-size:12px;line-height:1.5;opacity:.82}
  .sub b{color:var(--green);font-weight:600}
  .legend{bottom:15px;left:17px;font-size:11.5px;line-height:1.8}
  .row{display:flex;align-items:center;gap:9px}
  .dot{width:10px;height:10px;border-radius:50%;flex:none;box-shadow:0 0 9px currentColor}
  .d{color:var(--dim)}
  .caution{margin-top:9px;font-size:10px;color:var(--dim);max-width:290px;line-height:1.5;
    border-left:2px solid var(--amber);padding-left:8px}
  .tr{top:15px;right:17px;text-align:right;font-size:10.5px;color:var(--dim);line-height:1.75}
  .tr .v{color:var(--ink)}
  .hint{bottom:16px;right:17px;font-size:10.5px;color:var(--dim)}
  .ctl{bottom:52px;right:17px;pointer-events:auto;display:flex;gap:7px}
  .ctl button{font:inherit;font-size:10.5px;color:var(--dim);background:rgba(20,26,33,.7);
    border:1px solid #223;border-radius:6px;padding:5px 9px;cursor:pointer}
  .ctl button.on{color:var(--ink);border-color:#3a4a5a}
  @media (max-width:640px){.tl{max-width:76vw}.tr{display:none}.caution{max-width:76vw}}
</style>
</head>
<body>
<div id="stage"></div>

<div class="panel tl">
  <div class="eyebrow">WodansEye · E-Tree · SPEC-004</div>
  <h1>The atom of the node:<br>two orbits, <span class="r">red</span> &amp; <span class="b">blue</span></h1>
  <div class="sub">27 cubelets — <b>8</b> corners (octants), 12 edges (carry), 6 faces, 1 core.
    Each closed loop is a single 6-orbit of the same rotation about the body diagonal,
    threading its cells x→y→z→x→y→z. <span class="r">Red</span> caps the poles;
    <span class="b">blue</span> rings the equator.</div>
</div>

<div class="panel legend">
  <div class="row"><span class="dot" style="background:var(--red);color:var(--red)"></span>
    <span>red orbit</span><span class="d">· central · trefoil · low-freq</span></div>
  <div class="row"><span class="dot" style="background:var(--blue);color:var(--blue)"></span>
    <span>blue orbit</span><span class="d">· hyperbolic · Borromean · broadband</span></div>
  <div class="row"><span class="dot" style="background:var(--green);color:var(--green)"></span>
    <span>octant corner</span><span class="d">· resolved volume</span></div>
  <div class="caution">Colors name chirality sign-agreement, not wavelength — inverted from
    the optical spectrum by design (red = higher entropy here).</div>
</div>

<div class="panel tr">
  <div>red&nbsp;&nbsp;log λ = <span class="v">0.000</span></div>
  <div>blue&nbsp;log λ = <span class="v">2.887</span></div>
  <div>orbit period&nbsp;<span class="v">6</span> · axis <span class="v">⟨111⟩</span></div>
</div>

<div class="panel ctl">
  <button id="bCubelets" class="on">cubelets</button>
  <button id="bParticles" class="on">particles</button>
  <button id="bSpin" class="on">spin</button>
</div>
<div class="panel hint">drag to rotate</div>

<script>
// ---- verified geometry (from orbit.py; matches TEST 6/7 conventions) ----
const RED_ORBIT  = [[0,-1,-1],[1,0,1],[-1,-1,0],[0,1,1],[-1,0,-1],[1,1,0]];
const BLUE_ORBIT = [[0,-1,1],[-1,0,1],[-1,1,0],[0,1,-1],[1,0,-1],[1,-1,0]];
const G = 1.15;                 // cubelet spacing (trit coord -> world)
const P = v => new THREE.Vector3(v[0]*G, v[1]*G, v[2]*G);

const stage=document.getElementById('stage');
const scene=new THREE.Scene();
scene.fog=new THREE.FogExp2(0x06080b,0.05);
const camera=new THREE.PerspectiveCamera(40,innerWidth/innerHeight,0.1,100);
const renderer=new THREE.WebGLRenderer({antialias:true,alpha:true});
renderer.setPixelRatio(Math.min(devicePixelRatio,2));
renderer.setSize(innerWidth,innerHeight);
stage.appendChild(renderer.domElement);
const world=new THREE.Group(); scene.add(world);

const RC=0xff5566,BC=0x3aa0ff,GC=0x39e08a;
function popz(v){return (v[0]===0)+(v[1]===0)+(v[2]===0);}      // zero count -> class
function cellColor(v){
  const pz=popz(v);
  if(pz===0) return GC;                                          // corner: octant
  if(pz===1){ // edge: chirality
    const lane=v.indexOf(0), b=(lane===0)?1:0, c=(lane===2)?1:2;
    return ((v[b]>0)===(v[c]>0))?RC:BC;
  }
  return 0x2b3946;                                               // face/core: neutral
}

// ---- 27 cubelets ----
const cubeletGroup=new THREE.Group(); world.add(cubeletGroup);
const size=0.82*G;
for(let x=-1;x<=1;x++)for(let y=-1;y<=1;y++)for(let z=-1;z<=1;z++){
  const v=[x,y,z], pz=popz(v), col=cellColor(v);
  const geo=new THREE.BoxGeometry(size,size,size);
  const isCarry=(pz===1);
  const mat=new THREE.MeshStandardMaterial({
    color:col, emissive:col,
    emissiveIntensity:isCarry?0.35:(pz===0?0.28:0.05),
    transparent:true, opacity:isCarry?0.30:(pz===0?0.26:0.12),
    roughness:0.5, metalness:0.1, depthWrite:false});
  const m=new THREE.Mesh(geo,mat); m.position.copy(P(v)); cubeletGroup.add(m);
  const wf=new THREE.LineSegments(new THREE.EdgesGeometry(geo),
    new THREE.LineBasicMaterial({color:col,transparent:true,
      opacity:isCarry?0.5:(pz===0?0.4:0.14)}));
  wf.position.copy(P(v)); cubeletGroup.add(wf);
}

// ---- faint body diagonal (the orbit axis) ----
world.add(new THREE.Line(
  new THREE.BufferGeometry().setFromPoints([P([-1,-1,-1]),P([1,1,1])]),
  new THREE.LineDashedMaterial({color:0x6b7280,transparent:true,opacity:0.45,
    dashSize:0.12,gapSize:0.1})).computeLineDistances());

// ---- orbit paths as smooth closed tubes through the cells ----
function orbitTube(cells,color){
  const pts=cells.map(P);
  const curve=new THREE.CatmullRomCurve3(pts,true,'catmullrom',0.5);
  const geo=new THREE.TubeGeometry(curve,220,0.055,16,true);
  const mat=new THREE.MeshStandardMaterial({color,emissive:color,
    emissiveIntensity:0.7,roughness:0.3,metalness:0.15});
  const mesh=new THREE.Mesh(geo,mat); world.add(mesh);
  const glow=new THREE.Mesh(new THREE.TubeGeometry(curve,220,0.12,16,true),
    new THREE.MeshBasicMaterial({color,transparent:true,opacity:0.09,depthWrite:false}));
  world.add(glow);
  return curve;
}
const redCurve=orbitTube(RED_ORBIT,RC);
const blueCurve=orbitTube(BLUE_ORBIT,BC);

// ---- corner octant nodes (bright) + pole halos ----
for(let x=-1;x<=1;x+=2)for(let y=-1;y<=1;y+=2)for(let z=-1;z<=1;z+=2){
  const m=new THREE.Mesh(new THREE.SphereGeometry(0.075,18,18),
    new THREE.MeshStandardMaterial({color:GC,emissive:GC,emissiveIntensity:0.55,
      roughness:0.4,metalness:0.2}));
  m.position.copy(P([x,y,z])); world.add(m);
}
[[-1,-1,-1],[1,1,1]].forEach(c=>{
  const h=new THREE.Mesh(new THREE.SphereGeometry(0.17,18,18),
    new THREE.MeshBasicMaterial({color:GC,transparent:true,opacity:0.13,depthWrite:false}));
  h.position.copy(P(c)); world.add(h);
});

// ---- particles orbiting along each thread (the "atomic" motion) ----
const particles=new THREE.Group(); world.add(particles);
function orbiter(curve,color){
  const m=new THREE.Mesh(new THREE.SphereGeometry(0.075,16,16),
    new THREE.MeshStandardMaterial({color:0xffffff,emissive:color,emissiveIntensity:1.4,
      roughness:0.2,metalness:0}));
  const halo=new THREE.Mesh(new THREE.SphereGeometry(0.15,16,16),
    new THREE.MeshBasicMaterial({color,transparent:true,opacity:0.28,depthWrite:false}));
  particles.add(m); particles.add(halo);
  return {m,halo,curve};
}
// blue is higher-entropy/broadband -> a touch faster; red is the slow fundamental
const orbs=[
  {...orbiter(redCurve,RC), speed:0.055, t:0.0},
  {...orbiter(blueCurve,BC),speed:0.085, t:0.33}
];

// ---- lights ----
scene.add(new THREE.AmbientLight(0x30404f,1.15));
const key=new THREE.PointLight(0xffffff,0.75,50); key.position.set(6,8,9); scene.add(key);
const rim=new THREE.PointLight(0x3aa0ff,0.45,50); rim.position.set(-8,-4,-7); scene.add(rim);

camera.position.set(4.4,3.3,5.2); camera.lookAt(0,0,0);

// ---- orbit control ----
let spin=true,dragging=false,px=0,py=0,ry=0.6,rx=0.4;
const setRot=()=>{world.rotation.y=ry;world.rotation.x=rx;}; setRot();
const dn=(x,y)=>{dragging=true;px=x;py=y;};
const mv=(x,y)=>{if(!dragging)return;ry+=(x-px)*0.008;rx+=(y-py)*0.008;
  rx=Math.max(-1.3,Math.min(1.3,rx));px=x;py=y;setRot();};
const upp=()=>dragging=false;
renderer.domElement.addEventListener('mousedown',e=>dn(e.clientX,e.clientY));
addEventListener('mousemove',e=>mv(e.clientX,e.clientY)); addEventListener('mouseup',upp);
renderer.domElement.addEventListener('touchstart',e=>{const t=e.touches[0];dn(t.clientX,t.clientY);},{passive:true});
renderer.domElement.addEventListener('touchmove',e=>{const t=e.touches[0];mv(t.clientX,t.clientY);},{passive:true});
renderer.domElement.addEventListener('touchend',upp);

// ---- toggles ----
const bC=document.getElementById('bCubelets'),bP=document.getElementById('bParticles'),bS=document.getElementById('bSpin');
bC.onclick=()=>{cubeletGroup.visible=!cubeletGroup.visible;bC.classList.toggle('on',cubeletGroup.visible);};
bP.onclick=()=>{particles.visible=!particles.visible;bP.classList.toggle('on',particles.visible);};
bS.onclick=()=>{spin=!spin;bS.classList.toggle('on',spin);};

addEventListener('resize',()=>{camera.aspect=innerWidth/innerHeight;camera.updateProjectionMatrix();
  renderer.setSize(innerWidth,innerHeight);});

(function loop(){
  requestAnimationFrame(loop);
  if(spin){ry+=0.003;setRot();}
  for(const o of orbs){
    o.t=(o.t+o.speed*0.016)%1;
    const p=o.curve.getPointAt(o.t);
    o.m.position.copy(p); o.halo.position.copy(p);
  }
  renderer.render(scene,camera);
})();
</script>
</body>
</html>