Compact Binary-Register Encoding

• Compact Binary-Register Encoding is a representation technique that uses compact binary registers or bit fields to store only the distinguishing information of structured objects.
• It reduces resource usage by separating identity from payload, enabling efficient hardware synthesis, quantum simulation, and data compression with logarithmic scaling of register width.
• Empirical evaluations show significant gains, such as a 6.67× reduction in RNLU size for hardware implementations and substantial qubit savings in quantum TSP and Fock state encodings.

Searching arXiv for the cited topic and papers to ground the article. Compact Binary-Register Encoding designates a family of representations in which structured objects are stored or manipulated through compact collections of binary registers, bit fields, or binary codewords rather than through larger unary, one-hot, tree-based, ROM-based, or direct mode-by-mode descriptions. In the cited literature, the term appears in several domain-specific senses: a given binary sequence can be generated by a Register with Non-Linear Update (RNLU) of expected size $O(n/\log_2(n/p))$; Traveling Salesman Problem tours can be encoded with $O(n\log n)$ qubits rather than $O(n^2)$ one-hot variables; second-quantized Fock states can be stored using only occupied-mode registers with qubit cost $O(I(\log M+\log W))$; dense segmentation heads can replace $K$ one-hot channels by $m \approx \lceil \log_2 K\rceil$ binary channels; and selected 64-bit floating-point values can be represented by 32 stored bits and reconstructed exactly by table lookup (Li et al., 2013, Lin et al., 1 May 2026, Kirby et al., 2021, Kujawa et al., 1 Oct 2025, Neal, 2015).

1. Core representational principle

Across these works, compactness is obtained by separating identity from payload and by encoding only the information needed to distinguish admissible states. In the RNLU construction, a length-$n$ sequence partitioned into $m=\lceil n/p\rceil$ output blocks is indexed by $r=\lceil \log_2 m\rceil$ extra bits, so that the output update functions depend only on those $r$ bits rather than on the full state. In second-quantized simulation, a Fock basis state is stored in a fixed number $O(n\log n)$0 of sorted mode registers $O(n\log n)$1, with unused registers set to an all-zero sentinel state. In compact TSP formulations, each unfixed tour position is represented by a $O(n\log n)$2-qubit binary register with $O(n\log n)$3 after fixing one start city. In proof complexity, witness variables $O(n\log n)$4 are replaced by binary witness bits $O(n\log n)$5, with the atomic event “witness $O(n\log n)$6 equals $O(n\log n)$7” represented by $O(n\log n)$8. In large multi-class segmentation, the final $O(n\log n)$9-channel output is replaced by $O(n^2)$0 binary channels, with $O(n^2)$1 for vanilla binary encoding and larger $O(n^2)$2 for ECOC redundancy (Li et al., 2013, Kirby et al., 2021, Lin et al., 1 May 2026, Dantchev et al., 2020, Kujawa et al., 1 Oct 2025).

Domain	Encoded object	Compactness statement
RNLU sequence generation	Binary sequence of length $O(n^2)$3 with degree $O(n^2)$4	Expected size $O(n^2)$5
Second-quantized simulation	Occupied modes in Fock states	$O(n^2)$6
TSP quantum encoding	Tour positions after fixing one city	$O(n^2)$7 qubits
Large-class segmentation	$O(n^2)$8 semantic classes	Output size $O(n^2)$9
Exact numeric storage	Selected IEEE-754 doubles	32 stored bits with exact 64-bit reconstruction

The common effect is that register width scales with the logarithm of the number of admissible choices, while legality, uniqueness, or reconstruction is shifted to update logic, decoding logic, penalties, or lookup tables. This suggests a broad design pattern rather than a single formalism.

2. Register-level sequence generation and low-transition signaling

The most explicit hardware formulation appears in the RNLU model. A $O(I(\log M+\log W))$0-stage RNLU has state variables $O(I(\log M+\log W))$1 and update functions $O(I(\log M+\log W))$2 with

$O(I(\log M+\log W))$3

Unlike LFSRs and NLFSRs, RNLUs allow both feedback and feedforward connections and do not require the chain relation $O(I(\log M+\log W))$4. The construction for a given sequence $O(I(\log M+\log W))$5 and degree of parallelization $O(I(\log M+\log W))$6 splits the state into $O(I(\log M+\log W))$7 output bits and $O(I(\log M+\log W))$8 extra bits, chooses an extra-bit generator $O(I(\log M+\log W))$9, assigns a unique extra-bit label to each output block, marks unused truth-table entries as don’t cares, and sets the extra-bit stages to the next-state functions of $K$0. The resulting expected size is

$K$1

hence $K$2 for random sequences. Logic synthesis with ABC on random sequences up to $K$3 bits gave the summary results that, for $K$4 and $K$5, the previous minimum-stage RNLU is approximately $K$6 larger, and for $K$7 and $K$8, the previous $K$9-parallel RNLU is approximately $m \approx \lceil \log_2 K\rceil$0 larger (Li et al., 2013).

A related compact register interpretation occurs in rate-1 binary convolutional decoding. Forward and backward BCJR SISO MAP decoders can be represented by dual SISO channel encoders implemented with shift registers over the complex field. For FBC, FFC, and GC generators, the dual encoders replace trellis-state recursions by delay-line or feedback shift-register realizations, and bidirectional MAP decoding is obtained by combining forward and backward register contents rather than by storing full $m \approx \lceil \log_2 K\rceil$1 and $m \approx \lceil \log_2 K\rceil$2 tables. The stated complexity changes from conventional BCJR complexity $m \approx \lceil \log_2 K\rceil$3 and state-vector storage to dual-encoder complexity approximately $m \approx \lceil \log_2 K\rceil$4 with memory $m \approx \lceil \log_2 K\rceil$5 (Li et al., 2012).

Compact binary-register encoding is also used to reduce transition activity in buses and memories. In write-efficient memory and bus encoding, a $m \approx \lceil \log_2 K\rceil$6-bit word $m \approx \lceil \log_2 K\rceil$7 is mapped to an $m \approx \lceil \log_2 K\rceil$8 bit word $m \approx \lceil \log_2 K\rceil$9 so as to minimize $n$0. The paper derives exact closed forms for the optimal finite-length scheme, Partitioned Inversion, Pure Random, Random Inversion, and Shift Inversion. For $n$1 and $n$2, sub-optimal schemes assisted by predefined random codebooks achieve a bit-flip reduction of approximately $n$3, compared to the $n$4 reduction offered by the significantly more complex optimal scheme (Valentini et al., 12 Jun 2026).

3. Quantum encodings of data, Fock states, and tours

In quantum machine learning, compact amplitude encoding stores two real training vectors in one register by using the real and imaginary parts of the same amplitude vector:

$n$5

with $n$6. This Compact Hadamard Classifier removes the label qubit, reduces the index register by one qubit, and therefore reduces the number of qubits by two relative to the Hadamard-test classifier. Training-state preparation is reduced from $n$7 controlled state-preparation gates to $n$8, the number of controls is reduced by one, the measurement is simplified from $n$9 to $m=\lceil n/p\rceil$0, and numerical evaluations on Iris and Wine datasets show a positive entanglement difference $m=\lceil n/p\rceil$1, meaning that the compact classifier generates less entanglement than the previous method (Blank et al., 2022).

For second-quantized Hamiltonians, compact encoding means that qubit states encode only the occupied modes in physical occupation-number basis states. A many-body basis state is represented by $m=\lceil n/p\rceil$2 sorted mode registers, each storing internal quantum numbers $m=\lceil n/p\rceil$3, a mode index $m=\lceil n/p\rceil$4, and occupancy $m=\lceil n/p\rceil$5. The total qubit cost is

$m=\lceil n/p\rceil$6

which is optimal up to logarithmic factors and contrasts with direct encodings that require $m=\lceil n/p\rceil$7 qubits. The paper combines this representation with sparse-Hamiltonian simulation oracles $m=\lceil n/p\rceil$8 and $m=\lceil n/p\rceil$9, obtaining query complexity

$r=\lceil \log_2 m\rceil$0

for time-independent Hamiltonians and gate complexity multiplied by the oracle cost $r=\lceil \log_2 m\rceil$1 (Kirby et al., 2021).

Compact binary-register encoding has also become a central tool in quantum TSP formulations. In the variational framework, fixing a start city leaves $r=\lceil \log_2 m\rceil$2 unfixed tour positions, each stored in a $r=\lceil \log_2 m\rceil$3-qubit binary register with $r=\lceil \log_2 m\rceil$4, for a data-qubit count of $r=\lceil \log_2 m\rceil$5. The distance Hamiltonian is built from binary-code projectors

$r=\lceil \log_2 m\rceil$6

with repetition and invalid-code penalties added when feasibility is not enforced by the ansatz. A permutation-preserving ansatz based on auxiliary-controlled swaps of neighboring registers keeps the state in the feasible permutation subspace and removes the need for those penalties. Numerical simulations on TSP instances with 4, 5, and 6 cities achieved best average success rates of $r=\lceil \log_2 m\rceil$7, $r=\lceil \log_2 m\rceil$8, and $r=\lceil \log_2 m\rceil$9, respectively, and a local two-qubit divide-and-conquer implementation was evaluated on SpinQ Gemini Pro and SpinQ Triangulum II NMR quantum computers (Lin et al., 1 May 2026).

A complementary route-generation construction represents a candidate TSP route as a sequence of $r$0 binary time registers, applies Hadamards to create a uniform superposition, uses parity ancillas and a final “good” flag to mark valid permutations, and encodes the tour length as a phase

$r$1

The route register alone uses $r$2 qubits, the validity oracle uses $r$3 parity ancillas, one good flag, and one clean MCX ancilla, and the fraction of valid tours among all assignments is

$r$4

so amplitude amplification still yields exponential overall complexity despite the compact qubit count (Stasik et al., 22 Mar 2026).

4. Succinct classical representations, codebooks, and exact reconstruction

In data compression and succinct data structures, compact binary-register encoding replaces explicit trees or full-width tables by bit-packed arrays, rank/select structures, and bounded lookup tables. For optimal alphabetic prefix-free codes, the codebook can be stored in $r$5 bits by keeping codeword lengths and block-level Binary Searchable Dictionaries, with encoding and decoding in $r$6 time. With $r$7 further bits, for any constant $r$8, one can encode and decode in $r$9 time. A nearly optimal alphabetic code can be stored in $O(n\log n)$00 bits with constant-time encoding and decoding, and reverse-lexicographic non-decreasing-length codes can be stored in $O(n\log n)$01 bits with $O(n\log n)$02 time, or in constant time with $O(n\log n)$03 further bits (Fariña et al., 2016).

A different exact-reconstruction scheme stores selected IEEE-754 double-precision numbers in 32 bits while preserving full 64-bit precision. The compact form consists of the sign bit, the 11 exponent bits, and the top $O(n\log n)$04 bits of the 52-bit mantissa; the remaining 32 mantissa bits are recovered by a table lookup indexed by $O(n\log n)$05 low-order bits of the retained mantissa and, optionally, by $O(n\log n)$06 exponent bits:

$O(n\log n)$07

The paper tabulates several representable subsets. Scheme B, covering decimal data with four or fewer digits to the left of the decimal point and two or fewer digits to the right, uses $O(n\log n)$08 and a 32-entry table of 128 bytes. Scheme Z, covering six decimal digits with the decimal point in any of seven positions, uses $O(n\log n)$09, $O(n\log n)$10, $O(n\log n)$11, and a direct table of 524,288 entries, or about $O(n\log n)$12 MB; indirect indexing reduces that to about $O(n\log n)$13 MB. Decoding requires only extraction of index bits and a table lookup, and the reported benchmarks show that this is consistently faster than decimal floating-point conversion (Neal, 2015).

5. Learning-based binary code design and dense prediction

In vision and retrieval, compact binary-register encoding is learned rather than prescribed. Large-margin compact binary image encodings map an input feature vector to an $O(n\log n)$14-bit code

$O(n\log n)$15

and optimize weighted Hamming margins over supervised triplets. The framework supports both patch-based non-parametric NBNN/I2C pipelines and image-based parametric models, permits any convex loss and convex regularization penalty, and is trained by column generation with weak learners found by smooth relaxations and L-BFGS. The paper reports, for example, that a 32-bit code reduces a 128D SIFT patch from approximately 512 bytes to 4 bytes, a 128× reduction, and that weighted-Hamming evaluation runs in 0.15 s per image per class at 16 bits, 0.24 s at 32 bits, and 1.11 s at 128 bits, versus 78.8 s for exact NBNN (Paisitkriangkrai et al., 2014).

In dense semantic segmentation with many classes, the same compactness idea produces a much more difficult optimization problem. Replacing one-hot labels by binary codes changes the output tensor and final-layer compute from $O(n\log n)$16 and $O(n\log n)$17 to $O(n\log n)$18, where $O(n\log n)$19 for vanilla binary encoding and $O(n\log n)$20 for ECOC. On whole-brain parcellation with $O(n\log n)$21 classes, vanilla binary encoding uses $O(n\log n)$22 channels and Hamming ECOC uses $O(n\log n)$23. Measured GPU memory during nnU-Net training drops from 26.7 GiB for one-hot encoding to 12.08 GiB for vanilla binary and 12.21 GiB for Hamming ECOC. However, the Dice Similarity Coefficient falls from $O(n\log n)$24 for one-hot encoding to $O(n\log n)$25 for vanilla binary, $O(n\log n)$26 for Hamming hard decoding, $O(n\log n)$27 for Hamming soft decoding, and $O(n\log n)$28 for the binary-tree output head. The paper identifies boundary errors, small-structure degradation, bitwise independence, decoding error propagation, and class imbalance as central failure modes (Kujawa et al., 1 Oct 2025).

These results distinguish two very different regimes. In retrieval and classification, compact binary codes can preserve or improve task performance while drastically reducing storage and enabling XOR-plus-popcount evaluation. In dense structured prediction, the same logarithmic output compression can remove the mutual exclusivity structure that one-hot softmax supplies automatically. This suggests that compact binary-register encoding is especially effective when the target object is naturally index-like or when the downstream metric is already Hamming-like.

6. Proof-complexity consequences and recurring limitations

Proof complexity provides a formal account of how binary-register encodings alter the logical difficulty of combinatorial principles. In unary encodings, existential witnesses are represented by variables $O(n\log n)$29 with at-least-one or exactly-one constraints. In the compact binary encoding, each witness is represented by $O(n\log n)$30 bits $O(n\log n)$31, and

$O(n\log n)$32

For $O(n\log n)$33-Clique, this reduces variables from $O(n\log n)$34 to $O(n\log n)$35; for PHP, from $O(n\log n)$36 to $O(n\log n)$37. The change in representation reshapes lower and upper bounds across systems. There is a Resolution-to-Res$O(n\log n)$38 simulation for binary Clique; binary PHP has almost-exponential lower bounds in Res$O(n\log n)$39 up to $O(n\log n)$40; treelike Resolution complexity for binary PHP is $O(n\log n)$41 rather than the unary $O(n\log n)$42; BinPHP$O(n\log n)$43 has Sherali–Adams size lower bound $O(n\log n)$44 but a +Squares refutation of degree $O(n\log n)$45 and size $O(n\log n)$46; and binary LOP has Sherali–Adams rank at most $O(n\log n)$47 and polynomial size (Dantchev et al., 2020).

The literature also records several recurrent limitations. The RNLU size guarantee is an expected-size analysis under a random-sequence assumption rather than a worst-case bound, and the construction is not guaranteed to find absolute minimal hardware for every sequence; practical gains depend on synthesis quality and shrink as $O(n\log n)$48 becomes small (Li et al., 2013). In compact quantum classifiers, state preparation remains the main cost, and extending compact amplitude encoding to feature-map encodings requires additional orthogonality and real-overlap conditions (Blank et al., 2022). In TSP route-superposition encodings, the exponentially small valid-tour fraction implies exponential total complexity even with amplitude amplification (Stasik et al., 22 Mar 2026). In second-quantized compact encoding, optimality is only “up to logarithmic factors,” and the approach assumes a constant number of interaction patterns and efficiently computable outgoing-state enumerators (Kirby et al., 2021). In large multi-class segmentation, the reported results are explicitly negative relative to one-hot baselines despite clear memory savings (Kujawa et al., 1 Oct 2025).

A recurring misconception is that compactness alone implies better end-task performance. The cited work does not support that claim. Instead, it shows a more specific principle: compact binary-register encoding is most effective when the target structure is combinatorial, index-valued, or sparsely occupied, when legality can be enforced cheaply or by construction, and when the induced decode or optimization problem does not destroy the structure that the original representation made explicit.