Binary Multiset Model: Theory & Applications

• Binary multiset models are mathematical structures defined by unordered collections of 0s and 1s, using occurrence vectors to capture symbol multiplicities and weights.
• They employ ordering constraints, using lexicographic comparisons to enforce generalized arc consistency in constraint satisfaction problems.
• These models underpin deletion-correcting codes by utilizing residue-based weight partitioning for optimal construction and effective error correction.

A binary multiset model concerns mathematical structures and algorithmic properties of multisets drawn from a binary alphabet, typically in the context of combinatorial constraints, coding theory, or error correction. Central concepts include representing unordered collections of binary symbols by multiplicity (weight), imposing ordering constraints on such multisets, and addressing deletion channels where symbol order is lost. The study of binary multiset models intersects global constraint satisfaction, symmetry breaking, fuzzy CSPs, and the design of deletion-correcting codes in unordered settings (0905.3769, Kreindel et al., 9 Jan 2026).

1. Formal Definitions and Occurrence Vectors

A length-$n$ binary multiset, over alphabet $\Sigma = \{0,1\}$, is specified by the unordered collection of $n$ symbols, equivalently a multiplicity vector $x = (x_0, x_1) \in \mathbb{N}^2$, subject to $x_0 + x_1 = n$. The weight $w(S)$ of a multiset $S$ is the number of $1$s present, so $w(S) = x_1$, with $w(S) \in \{0, 1, ..., n\}$. The set of all binary multisets of length $n$ is denoted $S_2(n)$.

The structure of a multiset can also be captured by its occurrence vector (in this context, a 2-dimensional vector $(x_0, x_1)$), encapsulating the count of each symbol without regard to order. For general domains, the occurrence vector would have one coordinate per symbol in the value range, ordered in a standard way, e.g., $(\mathrm{occ}_u,\ldots,\mathrm{occ}_\ell)$. This vector underpins both constraint propagation and code construction in binary multiset settings (0905.3769, Kreindel et al., 9 Jan 2026).

2. Binary Multiset Ordering Constraints

A binary multiset ordering constraint imposes an ordering, not on ordered tuples but on the multisets themselves. For two multisets $M$ and $N$ over an ordered universe $V$, strict multiset order $M <_m N$ is recursively defined:

• $M <_m N$ if $M$ does not contain the maximum in $M \cup N$, but $N$ does.
• Otherwise, if both contain the maximum, remove one copy from each and recurse.

The non-strict order $M \leq_m N$ holds iff either $M <_m N$ or $M = N$. For binary multisets $S, T \in S_2(n)$, this reduces to a lexicographic comparison of their occurrence vectors; that is,

$$mset(S) \leq_m mset(T) \ \Longleftrightarrow \ occ(mset(S)) \leq_{lex} occ(mset(T)),$$

where the vectors are ordered as $(x_1, x_0)$ (0905.3769).

In CSPs, the constraint $X \leq_m Y$ (where $X$ and $Y$ are disjoint vectors of variables) ensures the assignment to $X$ forms a multiset less-than-or-equal to $Y$ under $<_m$, often to break symmetries or support fuzzy satisfaction ranking.

3. Generalized Arc Consistency via Linear-Time Propagation

To enforce generalized arc consistency (GAC) for $X \leq_m Y$, an efficient linear-time propagator can be implemented as follows (0905.3769):

1. Build occurrence vectors for the floors and ceilings of $X$ and $Y$: i.e., $ox = occ(\mathrm{floor}(X))$, $oy = occ(\mathrm{ceil}(Y))$.
2. Identify pivot indices $\alpha, \beta$ and flags $\gamma, \delta$ that characterize the point(s) of first difference and potential inversion in support for the constraint.
3. Pruning: The domains of $x_i$ are pruned above specified thresholds relative to $\alpha$ and $\beta$ by checking if setting $x_i$ to its maximum value violates the ordering. Symmetric pruning applies to $y_j$ for lower bounds.
4. Complexity: All steps are done in $O(n + m + R)$ time, where $R$ is the value-range size ($R = u-\ell+1$), and $n, m$ are the sizes of $X$ and $Y$.

The core data structures and invariants hinge on the structure of the occurrence vectors, and the algorithm refrains from full enumeration by reducing the problem to bound checks under precomputed support indices.

4. Fundamental Lemmas and Correctness

Key structural lemmas underpin correct and complete propagation (0905.3769):

• Support Reduction Lemma: For disjoint, non-repeated $X,Y$, constraint $GAC(X \leq_m Y)$ holds if and only if for every $x_i$, the assignment obtained by setting $x_i$ to $\max(x_i)$ and others to their minimum supports $X \leq_m Y$; dually for $y_j$, set to $\min(y_j)$ in $Y$.
• Lexicographic Lemma: For any two ground multisets $M,N$, $M \leq_m N$ if and only if $occ(M) \leq_{lex} occ(N)$, where the lexicographic order is imposed from the largest to smallest symbol.

These results justify both the algorithmic bound-check reasoning and the correctness of using occurrence vectors as an efficient representation. Only these "extreme value" substitutions need be checked, rather than all possible assignments.

5. Deletion-Correcting Codes in the Binary Multiset Model

In coding theory, binary multiset deletion-correcting codes address the problem where unordered multisets undergo symbol deletions (not caring which specific symbols are deleted, just reducing multiplicities). For $t$-deletion in $S \in S_2(n)$, the output is a multiset of size $n-t$ (Kreindel et al., 9 Jan 2026).

The distance between multisets $S, T$ is $d(S,T) = |w(S) - w(T)|$, based solely on their weights. A $t$-deletion-correcting code is a subset $C \subseteq S_2(n)$ such that balls of radius $t$ (under deletion) do not overlap:

$\min_{S \neq T \in C} d(S,T) \geq t+1.$

The maximum possible code size is

$$S_2(n, t) = \max \{ |W| : W \subseteq \{0,1,\ldots,n\}, \min_{w \neq w' \in W} |w-w'| \geq t+1 \} = \left\lceil \frac{n+1}{t+1} \right\rceil.$$

6. Optimal Construction and Decoding in the Binary Model

An explicit optimal construction requires that the weight $w(S)$ of each codeword $S$ is congruent to a fixed residue mod $t+1$:

$$C(a) = \{ S \in S_2(n) : w(S) \equiv a \pmod{t+1} \}.$$

This partitioning ensures distinct codewords have weights separated by at least $t+1$, guaranteeing correctability. Encoding is a matter of assigning the appropriate weight, while decoding is a one-pass procedure: the receiver determines $w'$ (the weight after deletion) and infers the original by solving $w = w' + u$, with $u \equiv a - w' \pmod{t+1}$, $u \in \{0,1,\ldots,t\}$.

This construction precisely matches the Singleton-type upper bound for code size. Redundancy is

$$R = \log_2(n+1) - \log_2 S_2(n,t) = \log_2(t+1) + o(1),$$

for large $n$, showing that redundancy is dominated by the logarithm of the number of residue classes.

7. Applications: Constraint Satisfaction and Error Correction

Multiset orderings are valuable for symmetry breaking in CSPs with matrix models. Imposing $row_1 \leq_m row_2 \leq_m \cdots \leq_m row_k$ can break row-permutation symmetries and reduce search space size. Multiset ordering is incomparable to lexicographic ordering but can be combined with it, for orthogonal symmetry breaking on rows and columns, yielding experimentally smaller search trees in certain domains (e.g., Progressive Party Problem, Sports-Scheduling).

In fuzzy CSPs, multiset order provides a foundation for the leximin approach, sorting satisfaction levels and using reverse multiset ordering for branch-and-bound optimization. For error correction, the binary multiset model provides a complete resolution of the space and exact constructions, with the congruence-based approach yielding both optimal codes and efficient decoding (Kreindel et al., 9 Jan 2026). Experimental results confirm both the theoretical bounds and the computational efficiency of these schemes.

Native GAC propagation for multiset ordering constraints is theoretically and empirically stronger than decompositions using global cardinality constraints or lexicographic subconstraints, providing algorithmic advantages (0905.3769).

---

References:

• (0905.3769) Multiset Ordering Constraints
• (Kreindel et al., 9 Jan 2026) Multiset Deletion-Correcting Codes: Bounds and Constructions