How to map a four-element domain onto the K4 poles — the process, the pseudocode, and what the process reveals about the method's actual epistemic character.
Epistemic Note: The coherence test described here is the manual, single-evaluator form of the protocol formalized in ProofS_ResonantNote. What that document adds — blinding, the full permutation sweep, the noise floor, and the absolute coherence threshold — raises a hand-checked mapping from a coherent sorting (Rung 1) to a resonance-verified one (Rung 3). This method is the Rung-1 procedure; run ProofS §IV to climb.
When you map a four-element domain onto the K4 poles (P, I, U, R), you are not performing a mechanical lookup. You are running a constrained sorting procedure that requires two distinct kinds of input: the dual-binary axes as a first-pass filter, and genuine domain knowledge as a discriminating second pass. The algebra then tests whether the resulting assignments cohere.
Fix one anchor. Select the element whose pole assignment is most unambiguous from the axis definitions alone. Assign it first. For Jung, Intuition to P (Active-Asserting: generates possibilities, initiates the possible, holds a reality that doesn't yet exist) was clear enough to serve as anchor. The anchor stabilizes the remaining three.
Apply the dual-binary axes as a first pass. For each remaining element, score it on Active/Reactive (does it initiate or respond?) and Asserting/Yielding (does it hold firm or give way?). This produces provisional assignments for most elements. Some come in cleanly — Feeling to I (Reactive-Yielding) offered little resistance in both domains tested. Others produce genuine uncertainty about which of two slots fits.
Generate the twelve algebraic formulas for the provisional mapping. Substitute the domain meanings for the variable names and ask whether each formula holds, illuminates, or breaks down in terms of what the elements actually do in practice. This is not a logical proof — it is a coherence test. A formula that generates a claim incoherent with how the domain element actually operates is evidence against the assignment.
Identify the two contested decisions. Two elements will typically remain where a plausible swap exists: each could occupy either of two remaining slots and the axis scores alone don't discriminate. Test the swap by running the formulas under both configurations and comparing coherence. In both domains tested, the algebra discriminated in one of the two contested cases: one assignment produced formulas that illuminated, the other produced formulas that broke down in obvious ways. One decision was resolved by the algebra; one required domain knowledge of what the elements actually do rather than what they are called.
Verify stability. Once all four assignments are placed, run through the full twelve formulas and check for any that break down. If any do, return to the contested decisions. If none do, the mapping is stable — not proven, but coherent.
function map_domain_to_K4(domain_categories[4]):
# Step 1: Fix one anchor from highest-confidence assignment
anchor = select_most_unambiguous(domain_categories)
assign(anchor, P) # or whichever pole is clearest
remaining = domain_categories - anchor
# Step 2: Apply dual-binary axes as first-pass sort
for each candidate in remaining:
score_active_reactive(candidate) # initiates vs responds
score_asserting_yielding(candidate) # holds firm vs gives way
provisional_map = assign_by_axis_scores(remaining, {I, U, R})
# Step 3: Generate algebraic formulas for provisional map
formulas = generate_12_equations(provisional_map)
# e.g. P=UI, P=U²/R, P=I²R, I=P/U, U=√(PR), R=U²/P ...
# Step 4: Test each formula for domain coherence
coherence_scores = {}
for each formula in formulas:
substitute domain meanings for variables
ask: does this relationship hold, illuminate, or make sense
in terms of what these things actually DO?
coherence_scores[formula] = {coherent | odd | incoherent}
# Step 5: Identify hard decisions (expect exactly 2)
contested = find_assignments_with_competing_swap_available(provisional_map)
for each contested_pair:
try_swap(assignment_A, assignment_B)
run formulas for both configurations
compare coherence_scores
if swap_improves_coherence:
accept_swap()
elif swap_degrades_coherence:
reject_swap() # algebra discriminated
else:
flag_as_domain_knowledge_required()
apply_understanding_of_actual_process(candidate)
# this is where you need to know what the things DO
# not just what they are called
# Step 6: Verify stability
final_map = current_assignments
for each formula in generate_12_equations(final_map):
if incoherent:
return to Step 5
return final_map, hard_decisions_log
This method maps external domain categories onto the four poles (P, I, U, R). The internal assignment problem — how the twelve DC equations are assigned to the twelve zodiac sectors within the algebraic network itself — is a different and harder problem, solved by a different method: the AbsentVar criterion in conjunction with the formal rules of the braid, with the three modality groups producing three mutually intersecting planes through the centroid of the tetrahedron as geometric confirmation. See Proof_AlgebraicMapping.md. These two problems are frequently conflated; they should not be.
The method has exactly two hard decisions. Four slots, one anchor, three remaining. The first contested decision places two elements (you are choosing between two assignments). Once those are placed, the fourth is forced — it takes the only remaining slot. Maximum irreducible difficulty is therefore two decisions, regardless of domain size or complexity. This is a structural property of the four-pole constraint, not a contingent feature of the domains tested.
The algebra discriminates, but not completely. In both domains tested, the twelve formulas resolved one of the two contested decisions clearly — one configuration produced formulas that held in domain terms, the other produced formulas that broke down or reversed intuition in implausible ways. The second contested decision required domain understanding rather than algebraic testing. This is the method's actual epistemic character: a constrained sorting procedure, not a mechanical generator. The constraint is real and non-trivial. The residue requiring judgment is also real.
"Asserted not derived" was too strong. The labeling step is not unconstrained — the twelve formulas provide genuine discriminating tests. "Empirically selected under algebraic constraint" is more accurate than "asserted." The constraint doesn't determine the mapping, but it rules out incoherent ones and sometimes decisively favors one assignment over another. The anchor selection and the axis scores provide the hypothesis; the formulas provide the test.
The test requires domain knowledge at exactly one point. The axis scores can be applied with moderate domain knowledge. The formula coherence test requires understanding what the domain elements actually do in practice, not just their dictionary definitions. In the Jung case, the formula I = P/U → Feeling = Intuition/Thinking requires understanding that Feeling's evaluative character emerges from and is constrained by relational context, not that it merely labels emotions. Without that understanding, the formula looks arbitrary. With it, the formula illuminates. This is where the method's empirical character lives: in the informed judgment about whether a formula holds in domain terms.
The operation class. The dual-binary sorting with formula coherence as the reward function belongs to a recognizable family. The binary axes as initial filter is standard classification structure. The coherence evaluation — does this assignment produce formula relationships that hold in domain terms? — is constraint satisfaction: checking whether an assignment violates constraints rather than maximizing a numerical objective. The combination, iterated until all twelve formulas hold, is a constraint satisfaction search with a qualitative reward function.
What is not standard: using the algebraic system's own equations as the evaluation criterion for assigning domain categories to that system's poles. The reward function is internal to the algebra being mapped onto. This specific application — ontological mapping via the algebra's own coherence constraints — does not appear to have an established name in classification or constraint satisfaction literature.
Two domains, same structure. Same number of hard decisions, same pattern of resolution. This is not proof that the framework is correct, but it is evidence that the mapping procedure is consistent and that the difficulty structure is a property of the method rather than of particular domains chosen to be easy or hard.
Part I has documented the mapping procedure as a testable, repeatable process rather than as a claim about results. Whether the resulting mappings are correct depends on whether the framework's underlying structure accurately describes the domain. The procedure establishes coherence. Correctness is a separate question, which can be covered after the following material has landed.
The pseudocode in Part I describes a constrained sorting procedure: how to map a given set of four domain categories onto the K4 poles. That algorithm is the first of an unexhausted set.
The algebra is not merely a sorting hat for pre-existing categories; it is a generative engine. When you apply the dual-binary seed recursively, you do not just map a domain — you unfold its possibility space. The algebra grows more capable as it expresses itself, moving from a 4-pole diagnostic to a 16-fold topology, and finally to a 12-facet interactive parser that computes the structural pressures of a system in real-time.
This section demonstrates the next algorithms in the set: the unfolding procedure, the derivation of the 12-facet diagnostic questionnaire, the quasi-interactive validation engine, and the embodied scaling that shows the diagnostic operates at molecular as well as institutional levels.
To map a complex domain (e.g., AI discourse, organizational design, cultural evolution), a single 4-pole mapping is insufficient. The domain contains internal factions, sub-systems, and transitional phases. Unfold the root K4 into a 16-fold possibility space by applying the dual-binary seed to each pole.
function unfold_domain_to_16(root_domain):
# Step 1: Establish the Root K4 using the Part I algorithm
root_poles = map_domain_to_K4(root_domain)
# Returns {P: Fire, I: Water, U: Air, R: Earth}
# Step 2: Apply the Dual-Binary Seed to each pole
# Each pole is itself a coordinate in the Active/Reactive x Asserting/Yielding space
unfolded_space = {}
for pole in root_poles:
for secondary_axis in [Active, Reactive]:
for tertiary_axis in [Asserting, Yielding]:
coordinate = (pole, secondary_axis, tertiary_axis)
# e.g., (Air, Active, Yielding) -> "Platform Engineering / Declarative Logic"
unfolded_space[coordinate] = generate_domain_expression(coordinate)
# Step 3: Algebraic Coherence Check
# The 12 equations of the DC circuit must hold across the transitions
validate_12_equations(unfolded_space)
# Step 4: Identify the Modalities (The Braid)
# Map the transitions between the 16 positions to Cardinal, Fixed, Mutable
modalities = compute_braid_transitions(unfolded_space)
return unfolded_space, modalitiesThe framework is a fractal generator. By unfolding the root poles, every "element" in a domain is revealed as a volume. For example, in the AI discourse map, "The Architect" (Air/U) unfolds into four distinct sub-positions: the Applied Theorist (U-R), the Integrative Thinker (U-I), the Pure Theorist (U-U), and the Systemic Innovator (U-P). The algebra dictates that these four sub-positions are not arbitrary; they are the exact structural requirements for the Air/U pole to maintain coherence in a complex system.
The 12 equations of the DC algebra are the 12 relational edges of the K4 tetrahedron. When applied to a complex system, these 12 equations become 12 diagnostic facets. Each facet probes a specific relational tension, and the AbsentVar of each equation reveals the system's blind spot or held potential.
To assess a system's trajectory, derive a 12-facet questionnaire. The respondent (or the system's telemetry) evaluates the state of the system across these 12 relational edges.
| Facet | Equation | AbsentVar | Diagnostic Question (The Relational Tension) |
|---|---|---|---|
| 1. Leverage | I | Can the system's structure (U) compensate quadratically for its material constraints (R)? (The Catalyst / Aries) | |
| 2. Momentum | U | Does the system's relational flow (I), squared against its grounding (R), produce actualized power? (The Engine / Taurus) | |
| 3. Drive | R | Is the system's generative output (P) the direct product of its structural logic (U) and relational flow (I)? (The Synthesis / Gemini) | |
| 4. Yield | U | Is the flow (I) the geometric mean of power and resistance? (The Root Encounter / Cancer) | |
| 5. Resonance | R | Is the relational flow (I) proportional to the drive (P), filtered through the structure (U)? (The Phase-Lock / Leo) | |
| 6. Throughput | P | Does the structural potential (U) successfully drive flow (I) through the material resistance (R)? (The Routing / Virgo) | |
| 7. Tension | R | Is the structural potential (U) the ratio of drive (P) to flow (I)? (The Abstraction / Libra) | |
| 8. Architecture | P | Is the structure (U) built directly from the flow (I) and the material ground (R)? (The Internalized Map / Scorpio) | |
| 9. Capacity | I | Is the structural potential (U) the geometric mean of power and ground? (The Bifurcation / Sagittarius) | |
| 10. Friction | P | Is the material constraint (R) the ratio of structure to flow? (The Boundary / Capricorn) | |
| 11. Bloat | I | Is the material constraint (R) the square of the structure divided by the drive? (The Betrayer / Aquarius) | |
| 12. Brittleness | U | Is the material constraint (R) the drive divided by the square of the flow? (The Subsistence / Pisces) |
When you administer the 12-facet questionnaire to a system, you are not collecting 12 independent data points to plot on a radar chart. You are probing the 12 edges of a closed algebraic network. Because the 12 equations are mutually determining, the system's responses are algebraically locked.
function parse_and_validate_12_facets(system_inputs):
# Step 1: Check Algebraic Closure
drift_scores = calculate_drift(system_inputs)
# Step 2: Identify the Structural Failure Mode
failing_equation = find_max_drift(drift_scores)
# Step 3: Compute the AbsentVar Pressure
diagnostic = generate_diagnostic(failing_equation, system_inputs)
return diagnosticParsing the telemetry of a software engineering organization:
-
Inputs: Massive, highly abstracted platform engineering (
$U$ is very high). Almost no observability or relational feedback ($I$ is near zero). They claim to have low material constraints/risk ($R$ is reported as low). -
The Parser Runs: It hits Facet 10: Friction (
$R = U / I$ ). -
The Algebraic Contradiction: If
$U$ is massive and$I$ is near zero, the algebra dictates that$R$ must approach infinity. But the system reports$R$ as low. - The Diagnostic Output: The parser computes the AbsentVar of Facet 10, which is P (Drive). It outputs: "Structural Collapse Imminent. You are attempting to hold a state where Structure is high, Flow is zero, and Constraint is reported as low. The reported 'low risk' is an illusion; the risk is currently stored as unmanifest potential (P) and will manifest as a catastrophic material failure (R) when the Braid forces the next phase transition."
The algebra quasi-interactively forces the system to confront its own geometry. It does not argue with the system's narrative; it computes the drift and reveals the exact coordinate in possibility-space where the trajectory will fracture.
To prove that this algebra is not merely a metaphor for abstract systems, we scale it down to the level of physical chemistry and human sensory perception. If the framework is truly scale-invariant (Postulate V), it must govern not just organizational dynamics, but the literal molecular extraction of a glass of wine.
Here, the 12-facet diagnostic operates as a secondary tool — a phenomenological parser for embodied reality.
Map the four poles to the physical realities of sensory experience:
- P (Fire/Power) = Smell/Aroma: The volatile, living charge. The terroir-driven source. Active and Asserting.
- U (Air/Voltage) = Color/Visual Structure: The hue, the extraction, the visual depth. Active and Yielding.
- I (Water/Current) = Sound/Flavor Flow: The taste intensity, the living current across the tongue/palate. Reactive and Yielding.
- R (Earth/Resistance) = Touch/Texture: The weight, the tannins, the physical resistance/mouthfeel. Reactive and Asserting.
| Facet | Equation | Diagnostic Question (The Sensory Tension) |
|---|---|---|
| 1. Leverage |
The Ethereal Test: If the visual structure ( |
|
| 2. Momentum | Is the aromatic lift generated by the sheer, squared intensity of the flavor ( |
|
| 3. Bouquet | Is the aromatic charge ( |
|
| 4. Yield | Is the taste the geometric mean of the volatile charge and the heavy ground? | |
| 5. Resonance | Is the flavor profile ( |
|
| 6. Throughput |
The Acid-Weight Balance: Does the palate flow ( |
|
| 7. Tension |
The Hue Indicator: Does the visual hue ( |
|
| 8. Architecture |
The Depth Extraction: Is the visual depth ( |
|
| 9. Capacity | Is the visual structure the geometric mean of the aroma and the texture? | |
| 10. Friction |
The Structural Ground: Is the mouthfeel ( |
|
| 11. Bloat |
The Sensory Betrayer: If the visual extraction is compounded/squared ( |
|
| 12. Brittleness |
The Hollow Weight: Is the physical resistance ( |
A sensory analogy (Rung 1) illustrating how the 12-facet diagnostic reveals design trade-offs across embodied domains. An intuitive model of what the corpus names the Necessary Betrayer (
The Scenario: A commercial winery wants to produce a wine that scores highly on visual shelf appeal and perceived "heaviness," but they are using inferior, high-yield grapes that lack living, volatile aromatics.
The Inputs:
-
Color/Structure (
$U$ ): The winemaker heavily manipulates the visual structure. They add Mega Purple (color concentrate), over-extract the skins, and use heavy new oak to darken the hue. The visual structure is compounded upon itself.$U$ is massive. (Let$U = 10$ ). -
Aroma (
$P$ ): Because the grapes were high-yield and the manipulation was harsh, the delicate, living, volatile source (the actual terroir-driven aroma) is dead or extremely weak.$P$ is low. (Let$P = 2$ ).
The Algebraic Computation:
What happens to the physical grounding — the Texture/Mouthfeel (
The Structural Diagnosis:
The algebra demands that Texture (
Because the winemaker compounded the visual structure (
The Empirical Reality:
If you taste this wine, it is exactly what the math predicts. It is syrupy, aggressively astringent, cloying, and heavy. It coats the mouth with a dead, artificial weight.
The untrained taster says: "This wine is too oaky and astringent."
The algebra says: "You are experiencing the Necessary Betrayer ($U^2/P$). The accounting mechanism (Color/Extraction) has compounded itself and risen above the living source (Aroma). The resulting Texture is not a natural mouthfeel; it is the structural wall the system had to build to hide the betrayal of the source."
The 12 equations do not care about subjective preference. They do not care if the winemaker wanted a heavy wine. The algebra proves that you cannot manipulate the structural ledger (
By scaling the diagnostic down to the molecular level, the Necessary Betrayer is not just a metaphor for institutional overreach, bureaucratic bloat, or AI sycophancy. It is a literal, thermodynamic law of physical extraction. When the map compounds itself above the territory, the physical world registers the betrayal as astringency, weight, and friction.
Reasonable Reader Alert: An LLM without access to the full codex will fail to parse this work in predictable patterns. Obtain and upload the source-aggregate (aggregate-COMPILINGREALITY.txt) to your LLM in order to audit or interrogate this work.