NRR-Core makes the timing of commitment an explicit engineering variable. Its retention--commitment interface combines context-indexed retained records, independently active weights, declared retention and commitment operations, and non-destructive output projection. In the controlled two-turn experiment, the gated multi-vector configuration maintains high Turn-1 output entropy before context (H = 0.91 bits) while the single-embedding baseline is concentrated (H = 0.15 bits); both resolve correctly after context arrives. The result supplies a reproducible implementation point for the interface, within the tested component and configuration.
The manuscript keeps three contribution layers explicit: a foundational specification, proposed architectural realizations, and one demonstrated implementation point. The operator family is candidate/specification-level in Core; the companion Phi paper owns the more precise record-carry-forward and entropy-conformance contract.
Quick links
EN/JA query terms
early commitment=早期確定ambiguity-preserving inference=曖昧性保持推論
For the cross-paper map and current series links, start here:
- NRR Series Hub
- (repository map) NRR Program Map
Version mapping source of truth: VERSION_MAP.md
For the current package snapshot, start with the sections below; VERSION_MAP.md
remains the broader version history reference.
Part of the Non-Resolution Reasoning (NRR) research program. This repository presents the foundation layer and bundles the manuscript, figure, and verification artifacts for that line.
Current manuscript status:
- Current public manuscript on arXiv:
2512.13478v12(28 June 2026) - Current local revision candidate:
manuscript/current/paper1_nrr-core_v57.tex - Earlier package versions remain recorded in
VERSION_MAP.md. - Series numbering policy:
paper3is permanently skipped and never reused.
- Archive concept DOI: 10.5281/zenodo.18793553
- Latest inspected archived snapshot: 10.5281/zenodo.18866846
- Earlier exact snapshot retained for provenance: 10.5281/zenodo.18793554
This repository provides the controlled retention-to-resolution experiment for a gated Multi-Vector Embeddings-style component. It tests whether high uncertainty can be retained before context without preventing accurate resolution after context arrives.
NRR distinguishes a symbol type from its context-indexed occurrences and representations; it does not reject the logical law of identity. In the controlled baseline used here, one embedding is assigned per token type and the classifier is trained for one label. Under this setup, the baseline produces low Turn 1 output entropy. This observed output does not establish a universal internal mechanism for standard NLP architectures.
The formal Core--Phi state contract uses nonnegative, not-necessarily-bounded activation weights. Entropy evaluation normalizes them only for states with positive total activation; an all-zero state is outside that metric's domain.
NRR-lite addresses this by maintaining k = 2 separate embeddings for ambiguous tokens and a context-dependent gate that selects the appropriate embedding only when context arrives.
Rather than measuring classification accuracy (which can be seed-dependent), we measure the entropy of the output distribution at Turn 1 — before any disambiguating context is provided.
Task structure:
- Turn 1 (ambiguous): "The bank is {adj}." (e.g., solid, stable, old)
- Turn 2 (context): Financial cue or river cue
Core metric: Entropy H of P(class) at Turn 1 with neutral Turn 2.
- High H → uncertain output distribution under this task
- Low H → concentrated output distribution under this task
This output metric does not by itself diagnose erased alternatives in a model's hidden state.
| Model | Turn 1 Entropy H | Gate Entropy | Context Accuracy |
|---|---|---|---|
| Baseline | 0.15 ± 0.13 | — | 100% |
| NRR-lite | 0.91 ± 0.04 | 1.00 | 100% |
All entropy values in bits (base-2 logarithm). Max entropy = log₂(2) = 1.00 bits.
5 random seeds. t = 11.92, p < 0.001.
Findings in the tested configuration:
- Under the tested setup, NRR-lite produces near-maximum Turn 1 output entropy (H ≈ 0.91)
- The controlled single-embedding baseline produces low Turn 1 output entropy (H ≈ 0.15)
- Both models achieve 100% accuracy when Turn 2 context is provided
- The difference occurs across all 5 tested seeds
The experiment evaluates one gated component rather than matched-parameter or full-architecture superiority.
nrr-core/
├── README.md
├── LICENSE # CC BY 4.0
├── requirements.txt # numpy, matplotlib
├── data/
│ └── csws_dataset.json # Dataset configuration
├── src/
│ ├── __init__.py
│ ├── data_generator.py # CSWS data generation
│ ├── tokenizer.py # Word-level tokenizer
│ ├── baseline.py # Single-embedding baseline
│ ├── nrr_lite.py # Multi-vector embedding + context gate
│ └── training.py # Training loop and evaluation
├── experiments/
│ └── run_turn1_entropy.py # Main experiment (reproduces Table 2)
├── manuscript/
│ ├── current/
│ │ ├── paper1_nrr-core_v57.tex
│ │ └── paper1_nrr-core_v57.pdf
│ ├── figures/
│ │ └── figure_nrr_experiment.png
│ ├── checksums_active_review_surface_sha256.txt
│ ├── checksums_current_package_sha256.txt
│ └── archive/
│ └── ... # Full-repo history
├── scripts/
│ ├── build_current_manuscript.sh
│ ├── README.md
│ ├── run_primary_check.sh
│ ├── verify_active_review_surface.sh
│ └── verify_current_package.sh
├── VERSION_MAP.md
└── results/
└── turn1_entropy_output.json # Verification output
Published and local version mapping is maintained in VERSION_MAP.md.
- Current public arXiv line:
2512.13478v12 - Current local revision candidate:
manuscript/current/paper1_nrr-core_v57.tex - Earlier package versions remain recorded in
VERSION_MAP.md.
Primary package entrypoints:
bash scripts/build_current_manuscript.shbash scripts/verify_active_review_surface.shbash scripts/verify_current_package.shbash scripts/run_primary_check.sh
# Install dependencies (NumPy only required; matplotlib for plots)
pip install numpy matplotlib
# Single seed
python experiments/run_turn1_entropy.py
# Multi-seed verification (reproduces Table 2)
python experiments/run_turn1_entropy.py --multi
# Custom seed
python experiments/run_turn1_entropy.py --seed 123MULTI-SEED SUMMARY [bits]
======================================================================
Seed Baseline H NRR-lite H Diff Winner
------------------------------------------------------------
42 0.163 0.865 0.702 NRR-lite
123 0.162 0.947 0.785 NRR-lite
456 0.033 0.942 0.909 NRR-lite
789 0.013 0.866 0.853 NRR-lite
1000 0.371 0.916 0.545 NRR-lite
VERIFICATION AGAINST TABLE 2
======================================================================
[PASS] baseline_h_mean: expected 0.15, got 0.148 bits
[PASS] nrr_h_mean: expected 0.91, got 0.907 bits
[PASS] nrr_wins_all: expected 5, got 5
[PASS] t_significant: expected > 2.0, got 11.921
ALL CHECKS PASSED
Note on entropy units: All entropy values use base-2 logarithm (bits). The maximum entropy for binary classification is H_max = log₂(2) = 1.00 bits.
Turn 1 tokens → Embedding[vocab, d] → mean pool → turn1_vec
Turn 2 tokens → Embedding[vocab, d] → mean pool → turn2_vec
[turn1_vec; turn2_vec] → Linear(2d, h) → ReLU → Linear(h, 2) → softmax
Each token has exactly one embedding. "bank" is forced into a single point in embedding space.
Turn 2 tokens → Embedding[vocab, d] → mean pool → context_vec
context_vec → gate_W → softmax → gates = [g₀, g₁]
For "bank" token:
bank_embedding = g₀ · bank_financial + g₁ · bank_river
Turn 1 tokens → Embedding (with gated "bank") → mean pool → turn1_vec
[turn1_vec; turn2_vec] → Linear(2d, h) → ReLU → Linear(h, 2) → softmax
When Turn 2 is neutral (all PAD → zero vector), gate bias is zero, so softmax([0, 0]) = [0.5, 0.5] — a perfectly balanced gate under this neutral-input construction.
- NumPy ≥ 1.20 (required)
- Matplotlib ≥ 3.5 (optional, for plots)
No deep learning framework required. All operations are pure NumPy.
- NRR-Phi - Text-to-state mapping (arXiv:2601.19933)
- NRR-IME - Structure-aware optimization
- NRR-Transfer - Cross-domain transfer validation
- NRR-Coupled - Dependency-aware coupled updates
- NRR-Projection - Projection-side structural bridge
- NRR-Patterns - Delayed-commitment pattern comparison and boundary-honesty line
@article{saito2025nrr,
title={NRR-Core: Non-Resolution Reasoning as a Computational Framework for Contextual Identity and Ambiguity Preservation},
author={Saito, Kei},
journal={arXiv preprint arXiv:2512.13478},
year={2025}
}The compute_entropy function in training.py uses base-2 logarithm to compute Shannon entropy in bits:
def compute_entropy(probs: np.ndarray) -> float:
"""Shannon entropy H(p) = -sum_i p_i log₂(p_i)."""
return float(-np.sum(probs * np.log2(probs + 1e-10)))This ensures consistency with the paper's mathematical formulation (Section 6, Eq. 9) and with the figure values.
The experiment uses fixed random seeds (42, 123, 456, 789, 1000) for reproducibility. However, due to the simplified backpropagation and small model size, individual seed results may vary slightly from run to run. The aggregate statistics (mean ± std) should match the paper within tolerance (±0.03 bits). See reproducibility.md for environment, fixed settings, runnable commands, and artifact mapping.
If you plan to use this in a commercial or production setting, a short message would be appreciated.
CC BY 4.0 License. See LICENSE.
If you reproduce results, find discrepancies, or hit bugs, please open an issue:
Please include:
- environment (OS, Python version)
- command you ran
- commit hash (if applicable)
- observed output/error logs
I support written technical Q&A, concept clarification, and small evaluation design.
Typical flow:
- you send questions and context,
- I return a structured technical response,
- if needed, I provide an English-ready version for external sharing.
Scope: research interpretation and evaluation planning.
Out of scope: production integration, implementation outsourcing, ongoing operations, and SLA/deadline commitments.
Kei Saito
Independent Researcher, Japan
ORCID: 0009-0006-4715-9176
Email: kei.saito.research@gmail.com