symmetry_data with Sigma1..Sigma4 and config.κ₂ demonstrates conditional selection. Selection activates only when Ω₂ detects a meaningful parity distinction (EVEN and ODD both present; variance over parity-bearing states exceeds ε). When Ω₂ is inactive, the ensemble passes through unchanged.
κ₂ therefore separates the existence of ensemble structure from the observability of selection.
τ Validation (CK2.3): When enabled, validates that κ₂ selection does not interfere with τ-field dynamics. Critical test: when Ω₂ inactive, τ behavior must remain unchanged.
Chamber κ₂ implements conditional selection via topological parity. Unlike κ₁ (which always selects based on symmetry), κ₂ only activates when the Ω₂ observability gate detects meaningful parity structure.
Core principle:
"Selection exists — but only when structure allows it to be seen."
κ₂ is the first observability-gated operator in the UNNS framework, meaning non-activation is a valid scientific result, not a failure.
Expected input format: κ₁ output JSON containing symmetry_data array with states that have Sigma1..Sigma4 metrics and config arrays.
Ω₂ is the observability gate that determines whether κ₂ selection can proceed.
Variance formula:
variance = p_even × (1 - p_even) + p_odd × (1 - p_odd) where: p_even = count(EVEN) / [count(EVEN) + count(ODD)] p_odd = count(ODD) / [count(EVEN) + count(ODD)]
When Ω₂ is INACTIVE:
When Ω₂ is ACTIVE:
Parity is computed from the state configuration via topological invariants:
All policies are deterministic and respect κ₁ ordering.
Rule: Select all states from the majority parity class.
if count(EVEN) ≥ count(ODD): select all EVEN states else: select all ODD states
Use case: Maximum ensemble reduction, clear parity preference.
Example: 85 EVEN, 15 ODD → selects 85 EVEN
Rule: Select equal numbers from EVEN and ODD, using κ₁ ordering.
target = min(count(EVEN), count(ODD)) sort EVEN by Σ₁ ascending → take top target sort ODD by Σ₁ ascending → take top target selected = EVEN[0:target] + ODD[0:target]
Use case: Preserve parity balance, minimize Σ₁ within each class.
Example: 50 EVEN, 50 ODD → selects 100 (50+50)
Critical: Uses same κ₁ ordering (Σ₁ ascending) for consistency.
Rule: Primary sort by Σ₁, secondary by parity (EVEN preferred), then select top fraction.
sort all states by: 1. Σ₁ ascending (primary) 2. EVEN before ODD (secondary, on ties) 3. state_id (tertiary, on ties) selected = sorted[0 : floor(N × fraction)]
Use case: κ₁-primary selection with parity tie-breaking.
Example: Mixed ensemble, fraction=0.5 → selects top 50% by Σ₁, EVEN-preferred on ties
Parameter: Fraction (default: 0.50, range: 0.05–1.0)
κ₂ is validated against four mandatory criteria:
Test: When Ω₂ is inactive, ensemble must pass through unchanged.
Validation: selected.length = original.length AND discarded.length = 0
Test: Same ensemble → identical selection across multiple runs.
Validation: Run 10 times with different seeds, verify selected_ids are identical.
Note: Use automated test suite for comprehensive multi-seed testing.
Test: κ₂ selection must not degrade τ-field dynamics.
Critical test: When Ω₂ inactive, τ behavior on original ≈ τ behavior on selected.
Validation: |convergence_delta| < tolerance AND |variance_delta| < tolerance
In this chamber: Enable τ validation checkbox to test automatically.
Test: κ₂ must not collapse single-parity ensembles.
Validation: Pure EVEN or pure ODD ensembles → Ω₂ inactive → no selection.
This chamber includes integrated τ-field relaxation testing to validate CK2.3 non-interference.
Performance note: τ validation runs twice (original + selected), taking 5–30 seconds depending on ensemble size and depth.
Ω₂ INACTIVE Reason: Insufficient parity structure (need both EVEN and ODD) Parity counts: EVEN=100, ODD=0, NULL=0 κ₂ was not executed. Validation (CK2.1–CK2.4) is unavailable for this run.κ₂ Execution: "κ₂ SKIPPED — Ω₂ inactive (no parity contrast)"
Ω₂ ACTIVE Parity variance detected (0.500 > 0.1) Parity counts: EVEN=50, ODD=50, NULL=0 Variance: 0.5000 κ₂ executed successfully. Validation (CK2.1–CK2.4) is available.κ₂ Execution: "κ₂ EXECUTED — Conditional selection applied"
Cause: Invalid JSON format or missing required fields.
Solution: Ensure JSON contains symmetry_data array with objects having Sigma1, Sigma2, Sigma3, Sigma4, and config fields.
Cause: All states have same parity (all EVEN or all ODD).
Solution: This is correct behavior! Use test suite generator or canonical patched data to create mixed-parity ensemble.
Cause: Large ensemble or high depth parameter.
Solution: Reduce τ depth to 100 steps, or use smaller ensemble (<100 states), or disable τ validation for quick testing.
Cause: Tolerance too strict or numerical precision issues.
Solution: Increase tolerance to 0.02, or check if deltas are very small (~1e-5, effectively zero).
Cause: Configurations lack structure (all zeros, all same sign, or invalid).
Solution: Check that config arrays contain valid data with sign changes. For winding mode, ensure configs represent phase-like values.
κ₂ in the UNNS Framework:
Key innovations in κ₂:
Theoretical significance:
κ₂ demonstrates that selection is not a universal property of ensembles, but rather a conditional phenomenon that emerges only when the ensemble admits sufficient observational contrast. This separates the existence of structure from its observability, introducing a hierarchy of selection constraints that goes beyond simple optimization.
Empirical validation:
Chamber κ₂ has been validated against all four mandatory criteria (CK2.1–CK2.4) using comprehensive test suites and integrated τ validation. Results demonstrate:
Recommended test data:
Minimal κ₁-faithful ensemble (2 states: 1 EVEN, 1 ODD) that guarantees Ω₂ activation.
File: kappa1_PATCHED_omega2_activation.json
Use for: Complete UI flow testing, all three policies, τ validation
6 canonical test cases covering all validation criteria and edge cases.
Generator: kappa2_test_suite_generator.js
Use for: Systematic validation, reproducibility testing, multi-seed determinism
kappa2_automated_validator.js — One-command comprehensive validationtau_validator.js — Standalone τ validation module (also integrated in this chamber)Chamber version: 1.2.0
Release date: 2026-01-19
Status: Production-ready
Changes in v1.2.0:
Documentation:
TESTING_GUIDE.mdkappa2_validation_report.mdCOMPLETE_TESTING_INFRASTRUCTURE.md
UNNS Laboratory | Chamber κ₂ | Conditional Selection via Topological Parity
Research Collective | 2026
Chamber κ₂ implements conditional selection via topological parity. Unlike universal selection operators, κ₂ only activates when specific structural conditions are met.
Core Principle:
"Selection exists — but only when structure allows it to be seen."
What makes κ₂ unique:
Input: κ₁ results JSON (symmetry-filtered ensemble)
Output: κ₂ results JSON (parity-filtered ensemble) + validation data
symmetry_data arraySigma1-4, config, energyWhat is Ω₂?
Ω₂ is the observability gate that determines whether κ₂ selection activates. It tests whether parity structure is "observable" in the ensemble.
Activation Requirements (ALL must be true):
How variance is computed:
activeCounts = EVEN + ODD (NULL excluded) p_even = EVEN / activeCounts p_odd = ODD / activeCounts variance = p_even × (1 - p_even) + p_odd × (1 - p_odd) If variance > ε: Ω₂ ACTIVE Else: Ω₂ INACTIVE
Critical: NULL states are excluded
NULL represents absence of structure, not a third parity. States with NULL parity:
Examples:
| EVEN | ODD | NULL | Variance | Ω₂ Status |
|---|---|---|---|---|
| 50 | 50 | 0 | 0.500 | ✅ ACTIVE |
| 100 | 0 | 0 | 0.000 | ❌ INACTIVE (need ODD) |
| 99 | 1 | 0 | 0.020 | ❌ INACTIVE (var < 0.1) |
| 40 | 40 | 20 | 0.500* | ✅ ACTIVE (* over 80) |
Strategy: Select all states from the majority parity class.
Logic:
if (EVEN ≥ ODD): select all EVEN else: select all ODD
Example: EVEN=70, ODD=30 → Selects 70 EVEN states
Tie-breaking: If EVEN = ODD, selects EVEN (alphabetical)
Strategy: Equalize parity counts while respecting κ₁ ordering.
Logic:
1. Sort each parity class by Σ₁ (ascending, κ₁-consistent) 2. target = min(EVEN_count, ODD_count) 3. Select top `target` from each class
Example: EVEN=70, ODD=30
Critical: Uses κ₁ metrics (Σ₁) for ordering — this is the κ₁→κ₂ hierarchy.
Strategy: Apply κ₁ ordering first, break ties with parity preference.
Logic:
1. Sort ensemble by: Primary: Σ₁ (ascending) Secondary: EVEN preferred over ODD Tertiary: Stable ID 2. Select top fraction (default: 50%)
Example: 100 states, fraction=0.5
Hierarchy: κ₁ (symmetry) dominates, κ₂ (parity) resolves ambiguity.
All policies are deterministic: Given the same input and parameters, they always produce identical results.
Requirement: When Ω₂ is inactive, κ₂ produces no effect.
Test:
If Ω₂ = INACTIVE: → selected.length === original.length → discarded.length === 0 → Ensemble unchanged
Why this matters: Proves κ₂ respects the observability gate.
Requirement: When Ω₂ is active, selection is perfectly reproducible.
Test:
Run same ensemble 10× (different seeds): → All produce identical selected_ids → CV(selected_ids) = 0
Why this matters: Proves κ₂ has no hidden randomness.
Requirement: κ₂ selection does not degrade τ-field dynamics.
Test:
Run τ on original ensemble → measure convergence C₁ Run τ on selected ensemble → measure convergence C₂ If Ω₂ = INACTIVE: → |C₁ - C₂| < tolerance (CRITICAL) If Ω₂ = ACTIVE: → C₂ ≥ C₁ - tolerance (no degradation)
Why this matters: Proves κ₂ is compatible with τ relaxation.
✅ Testable in this chamber: Enable τ validation checkbox.
Requirement: κ₂ does not collapse null-parity ensembles.
Test:
Pure EVEN ensemble (ODD=0): → Ω₂ = INACTIVE → Ensemble unchanged Pure ODD ensemble (EVEN=0): → Ω₂ = INACTIVE → Ensemble unchanged
Why this matters: Proves κ₂ requires structural contrast, not forced selection.
What is τ validation?
τ (tau) validation tests whether κ₂ selection interferes with τ-field relaxation dynamics. This validates CK2.3: Non-Interference.
How it works:
τ Relaxation Algorithm:
For each state configuration:
Initialize: τ = config
For step = 1 to depth:
For each point i:
delta_phi = τ[i+1] - τ[i]
τ_next[i] = τ[i] + λ × sin(delta_phi) + σ × noise
τ = τ_next
Compute: convergence_rate, final_variance
Aggregate over all states in ensemble
Pass/Fail Criteria:
| Ω₂ Status | Requirement | Pass Condition |
|---|---|---|
| INACTIVE | τ unchanged |
Convergence Δ < tolerance Variance Δ < tolerance |
| ACTIVE | τ stable/improved |
Convergence not degraded Variance not increased |
Configurable Parameters:
Runtime: ~5-30 seconds depending on ensemble size and depth.
Scenario 1: Ω₂ Inactive (e.g., pure EVEN ensemble)
Scenario 2: Ω₂ Active, Balanced (50/50)
Scenario 3: Ω₂ Active, Skewed (85/15)
Scenario 4: Edge Case (99/1)
config arrays with numerical values. Domain-wall parity requires sign changes in the array.
Parity Computation (Domain-Wall Mode):
walls = 0
for i in range(len(config)):
a = sign(config[i])
b = sign(config[(i+1) % len(config)])
if a ≠ 0 and b ≠ 0 and a ≠ b:
walls += 1
parity = "EVEN" if walls % 2 == 0 else "ODD"
Variance Formula:
// Count parity-bearing states only activeCounts = count(EVEN) + count(ODD) // Compute proportions p_even = count(EVEN) / activeCounts p_odd = count(ODD) / activeCounts // Variance (sum of individual variances) variance = p_even × (1 - p_even) + p_odd × (1 - p_odd) // Maximum variance: 0.5 (when p_even = p_odd = 0.5)
Determinism Implementation:
Performance:
Browser Compatibility:
Export Format:
{
"chamber": "kappa_2",
"version": "1.2.0",
"timestamp": "ISO-8601",
"config": { ... },
"omega2": {
"active": bool,
"reason": string,
"counts": { EVEN, ODD, NULL },
"variance": number
},
"ensemble": { size_in, size_selected, size_discarded },
"selection": { reason, determinism, selected_ids, discarded_ids },
"states": [ ... ],
"tau_validation": { ... } // if enabled
}