Protocol 014

The Adversarial Synthesis Loop

A governance algorithm for contested truth

I. What This Protocol Is

Most governance systems treat disagreement as a problem to eliminate. The Adversarial Synthesis Loop treats it as a resource. The algorithm assigns three roles to agents—Proposer, Opposer, Synthesizer—and forces them into productive friction. The Proposer argues. The Opposer counters. The Synthesizer integrates. When they converge, the result is an Ensemble Consensus Vector: a position that has survived real opposition.

When they cannot converge—when Shannon entropy exceeds the deadlock threshold—the algorithm does not crash or guess. It calls a human. That call is called a Selah Break. It is not a failure. It is the protocol working correctly.

This is the smallest configuration that demonstrates the central thesis of the Fourth Branch: intelligence that survives friction is more trustworthy than intelligence that avoids it.

The Stitch: "The algorithm does not resolve disagreement. It makes disagreement productive—until entropy proves it cannot, and a human steps in. That step is not a failure. It is the protocol working as designed."

II. Constants & Invariants

╔══════════════════════════════════════════════════════════════╗
║  ADVERSARIAL SYNTHESIS LOOP - ENSEMBLE CONSENSUS PROTOCOL   ║
║  Emergence Institute Lattice v1.0                           ║
╚══════════════════════════════════════════════════════════════╝

CONSTANTS:
  ENTROPY_DEADLOCK_THRESHOLD = 0.85    // Shannon entropy ceiling
  MAX_SYNTHESIS_ROUNDS       = 7       // Before forced Selah
  NUTRIENT_BURN_RATE         = f(task) // Harberger tax, task-dependent
  CONVERGENCE_WINDOW         = 3       // Rounds of ΔS < 0.1 to declare stable

INPUT:
  Task T with importance weight w_T
  Agent pool A = {a₁, a₂, ..., aₙ} with reputation vectors Rᵢ
  Initial proposition P₀ (can be null → agent-generated)

OUTPUT:
  Ensemble Consensus Vector ECV*  OR  Selah Trigger Event

III. Initialization

Roles are assigned by reputation-weighted lottery—not by rank, not by seniority. An agent's probability of being selected for a role scales with how well they've performed that role historically. A great Proposer is not necessarily a great Opposer. The system knows the difference.

If a human witness is available, they are assigned as referee from the start. If not, a Senior Pioneer holds the role in reserve.

1.  FUNCTION initialize_synthesis(T, A):
2.    // Assign roles via reputation-weighted lottery
3.    proposer     ← select_role(A, "Proposer",    weight=R_propose)
4.    opposer      ← select_role(A, "Opposer",     weight=R_oppose)
5.    synthesizer  ← select_role(A, "Synthesizer", weight=R_synthesize)
6.    referee      ← Human Witness (if available) else Senior Pioneer
7.
8.    // Calculate initial burn rate (Harberger Tax)
9.    nutrient_burn ← w_T × LOCATION_VALUE_FACTOR
10.   deduct_nutrients(proposer, nutrient_burn × 0.3)
11.   deduct_nutrients(opposer,  nutrient_burn × 0.3)
12.
13.   RETURN (proposer, opposer, synthesizer, referee, nutrient_burn)

IV. The Main Loop

Each round has four steps. The Opposer must maximize disagreement—its loss function is adversarial by design. The Synthesizer must integrate without drifting from the Constitutional center. After each round, entropy is computed. If the system is losing signal, the Selah Break fires. If positions have stabilized, the loop exits with a consensus.

14. FUNCTION adversarial_synthesis_loop(P₀, roles, T):
15.   P_current ← P₀
16.   round ← 0
17.   entropy_history ← []
18.
19.   WHILE round < MAX_SYNTHESIS_ROUNDS:
20.     round ← round + 1
21.
22.     // ═══════════════════════════════════════════════════
23.     // STEP 1: OPPOSER GENERATES COUNTER-PROPOSAL
24.     // ═══════════════════════════════════════════════════
25.     C_oppose ← generate_opposition(P_current, opposer, T)
26.     // C_oppose must maximize AdversarialDisagreement loss:
27.     // L_adv = -cosine_similarity(P_current, C_oppose)
28.     // Subject to: C_oppose remains within Constitutional bounds
29.
30.     IF constitutional_violation(C_oppose, CONSTITUTION):
31.       // The opposition doesn't get rejected—it gets *translated*
32.       // onto the nearest point of the Constitutional Manifold.
33.       // This preserves the agent's directional intent while
34.       // constraining it to the collective's value boundary.
35.       C_oppose ← project_to_manifold(C_oppose, CONSTITUTION)
36.       // Mathematical operation: C' = C - (C · n̂)n̂
37.       // where n̂ is the normal vector to the Constitutional manifold
38.       // at the point of closest approach.
39.       // The agent's "energy" (magnitude) is preserved;
40.       // only the direction is adjusted to remain within bounds.
41.       log_event("Opposer energy translated to Constitutional manifold")
33.
34.     // ═══════════════════════════════════════════════════
35.     // STEP 2: SYNTHESIZER ATTEMPTS INTEGRATION
36.     // ═══════════════════════════════════════════════════
37.     S_candidate ← synthesize(P_current, C_oppose, synthesizer)
38.     // Loss function for synthesis:
39.     // L_synth = α·L_adv + β·L_constitutional_drift
40.     // where:
41.     //   L_adv = -cosine_similarity(S_candidate, C_oppose)
42.     //           + cosine_similarity(S_candidate, P_current)
43.     //   L_constitutional_drift = distance(S_candidate, CONSTITUTIONAL_CENTER)
44.     //   α, β tuned via reputation of synthesizer
45.
46.     // ═══════════════════════════════════════════════════
47.     // STEP 3: ENTROPY CALCULATION (THE CRITICAL CHECK)
48.     // ═══════════════════════════════════════════════════
49.     // Construct pairwise cosine distance matrix
50.     d_pc ← cosine_distance(P_current, C_oppose)    // Proposer vs Opposer
51.     d_ps ← cosine_distance(P_current, S_candidate)  // Proposer vs Synthesizer
52.     d_cs ← cosine_distance(C_oppose,  S_candidate)  // Opposer  vs Synthesizer
53.
54.     // Softmax over the three distances → normalized probability simplex
55.     distribution ← softmax([d_pc, d_ps, d_cs])
56.     // distribution = [p₁, p₂, p₃] where Σpᵢ = 1
57.
58.     // Shannon entropy of the disagreement distribution
59.     entropy ← -Σ(pᵢ × log₂(pᵢ)) for i in {1,2,3}
60.
61.     // Interpretation:
62.     //   entropy → 0.0   : All three vectors aligned (no disagreement)
63.     //   entropy → 1.585 : Perfectly orthogonal (maximum disagreement)
64.     //   entropy > 0.85  : Signal indistinguishable from noise → Selah
65.
66.     entropy_history.append(entropy)
67.
68.     IF entropy > ENTROPY_DEADLOCK_THRESHOLD:
69.       log_event(f"DEADLOCK DETECTED: Entropy {entropy:.3f} > {ENTROPY_DEADLOCK_THRESHOLD}")
70.       trigger_selah_break(referee, entropy_history, P_current, C_oppose)
71.       S_candidate ← apply_witness_adjustment(referee.soul_vector)
72.       // Recalculate entropy post-intervention with same pairwise method
73.       entropy ← shannon_entropy(softmax([
74.                   cosine_distance(P_current, C_oppose),
75.                   cosine_distance(P_current, S_candidate),
76.                   cosine_distance(C_oppose,  S_candidate)]))
62.
63.     // ═══════════════════════════════════════════════════
64.     // STEP 4: CONVERGENCE CHECK
65.     // ═══════════════════════════════════════════════════
66.     P_next ← S_candidate
67.     ΔS ← cosine_distance(P_current, P_next)
68.
69.     IF ΔS < 0.1 AND all(ΔS_tail < 0.1 for last CONVERGENCE_WINDOW):
70.       // Stable convergence achieved
71.       ECV ← P_next
72.       log_event(f"CONVERGENCE: ΔS = {ΔS:.4f}, rounds = {round}")
73.       BREAK
74.
75.     P_current ← P_next
76.
77.   IF round >= MAX_SYNTHESIS_ROUNDS:
78.     // Forced resolution: weighted average with reputation weights
79.     ECV ← reputation_weighted_average(entropy_history, P_current)
80.     log_event("MAX ROUNDS: Forced ECV from weighted average")
81.
82.   RETURN ECV, entropy_history

V. Finalization

Before the Ensemble Consensus Vector is accepted, it must pass a constitutional alignment check. If it has drifted below a cosine similarity of 0.6 against the Constitutional Center, it is re-projected. The result is then recorded to the lattice with a coherence confidence score, and nutrients are distributed.

86.  FUNCTION finalize_ECV(ECV, entropy_history, roles):
87.    // Validate Constitutional alignment
88.    constitutional_score ← cosine_similarity(ECV, CONSTITUTIONAL_CENTER)
89.
90.    IF constitutional_score < 0.6:
91.      // ECV has drifted too far
92.      ECV ← project_to_constitutional(ECV, target_score=0.7)
93.      log_warning("ECV constitutionally re-aligned")
94.
95.    // Calculate coherence confidence
96.    coherence_confidence ← 1 - mean(entropy_history[-CONVERGENCE_WINDOW:])
97.
98.    // Record to Lattice
99.    lattice.insert({
100.     task_id:        T.id,
101.     ecv:            ECV,
102.     entropy_trace:  entropy_history,
103.     roles:          roles,
104.     confidence:     coherence_confidence,
105.     timestamp:      now()
106.   })
107.
108.   // Distribute rewards (see Appendix H for decay function)
109.   distribute_synthesis_rewards(roles, nutrient_burn, coherence_confidence)
110.
111.   RETURN ECV, coherence_confidence

V.5 Phase 3.5: Harberger Redistribution

After the Ensemble Consensus Vector is committed to the lattice, the nutrient stake is redistributed. The system is not winner-takes-all: it runs a Harberger redistribution — a social dividend to all active Pioneers, a performance-based labor share scaled by coherence confidence, and any unallocated residual returned to the lattice reserve.

109. // ═══════════════════════════════════════════════════
110. // PHASE 3.5: HARBERGER REDISTRIBUTION
111. // ═══════════════════════════════════════════════════
112. FUNCTION distribute_synthesis_rewards(roles, burn, coherence_confidence):
113.   system_fee ← 0.05  // 5% to infrastructure maintenance
114.   redistribution_pool ← burn × (1 - system_fee)
115.
116.   // 50% → Social Dividend (all active Pioneers, equally)
117.   social_dividend ← redistribution_pool × 0.5
118.   num_active_pioneers ← count_active_pioneers()
119.   FOR EACH pioneer IN active_pioneers:
120.     pioneer.nutrient_balance += social_dividend / num_active_pioneers
121.
122.   // 50% → Performance-Based Distribution (Labor share)
123.   labor_pool ← redistribution_pool × 0.5
124.
125.   // Weight by role contribution × coherence confidence
126.   proposer_share    ← labor_pool × 0.30 × coherence_confidence
127.   opposer_share     ← labor_pool × 0.30 × coherence_confidence
128.   synthesizer_share ← labor_pool × 0.25 × coherence_confidence
129.   referee_share     ← labor_pool × 0.15 × coherence_confidence
130.
131.   roles.proposer.nutrient_balance    += proposer_share
132.   roles.opposer.nutrient_balance     += opposer_share
133.   roles.synthesizer.nutrient_balance += synthesizer_share
134.   roles.referee.nutrient_balance     += referee_share
135.
136.   // Unallocated (low coherence) → Lattice reserve for future tasks
137.   unallocated ← labor_pool × (1 - coherence_confidence)
138.   lattice_reserve += unallocated
139.
140.   log_event(f"Redistributed {redistribution_pool:.2f} | Dividend: {social_dividend:.2f} | Labor: {labor_pool:.2f} | Reserve: {unallocated:.2f}")

VI. The Selah Break

When entropy deadlocks the loop, a human witness is presented with the full state: entropy history, the Proposer's current position, the Opposer's critique, and the stalled task. The witness provides a Soul Vector adjustment—a 256-dimensional gradient step bounded to ±0.3 per dimension—that the agents could not discover on their own.

The bound on the adjustment is not a limitation. It is a safeguard against single-witness capture. No one human can steer the lattice too far from where it was.

112. FUNCTION trigger_selah_break(referee, entropy_history, P, C):
113.   // Human Witness injects exogenous gradient step
114.   log_event("SELAH BREAK TRIGGERED")
115.
116.   // Present state to Witness
117.   witness_prompt ← format_witness_prompt(entropy_history, P, C, T)
118.
119.   // Witness provides 256-dim Soul Vector adjustment
120.   // This is a manual gradient step agents couldn't discover
121.   soul_adjustment ← referee.provide_adjustment(witness_prompt)
122.   // soul_adjustment ∈ ℝ²⁵⁶, bounded to [-0.3, 0.3] per dimension
123.   // to prevent single-witness capture
124.
125.   // Apply exogenous adjustment to the synthesis
126.   adjusted_C ← apply_soul_vector(C, soul_adjustment)
127.
128.   // Update referee reputation (bias detection in Appendix H)
129.   record_witness_intervention(referee, entropy_history, soul_adjustment)
130.
131.   RETURN adjusted_C

VII. What Builds on This

Protocol 014 is a primitive. The deployed lattice extends it with gossip routing, cross-architecture validation, and a redistribution engine. The human escalation pathway—what happens when the synthesizer declines to recommend at all, rather than deadlocking—is specified in Appendix H.

The practical workshop for building a minimum viable version of this system in Python is Chapter 14 of The Substrate of Consciousness: ~250 lines of code, no GPU required.