Código binário com restrição

Suponha que eu tenha um alfabeto de n símbolos. Eu posso codificá-los eficientemente com$\lceil \log_2n\rceil$-bits strings. Por exemplo, se n = 8:
A: 0 0 0
B: 0 0 1
C: 0 1 0
D: 0 1 1
E: 1 0 0
F: 1 0 1
G: 1 1 0
H: 1 1 1

Agora eu tenho a restrição adicional de que cada coluna deve conter no máximo p bits definidos como 1. Por exemplo, para p = 2 (en = 8), uma solução possível é:
A: 0 0 0 0 0
B: 0 0 0 0 1
C: 0 0 1 0 0
D: 0 0 1 1 0
E: 0 1 0 0 0
F: 0 1 0 1 0
G: 1 0 0 0 0
H: 1 0 0 0 1

Dados nep, existe um algoritmo para encontrar uma codificação ideal (menor comprimento)? (e pode-se provar que calcula uma solução ideal?)

EDITAR

Até agora, foram propostas duas abordagens para estimar um limite mais baixo do número de bits $m$. O objetivo desta seção é fornecer uma análise e uma comparação das duas respostas, a fim de explicar a escolha da melhor resposta .

A abordagem de Yuval é baseada em entropia e fornece um limite inferior muito bom:$\frac{logn}{h(p/n)}$ Onde $h(x) = xlogx + (1-x)log(x)$.

A abordagem de Alex é baseada em combinatória. Se desenvolvermos um pouco mais o raciocínio dele, também é possível calcular um limite inferior muito bom:

Dado $m$ o número de bits $\geq\lceil log_2(n)\rceil$, existe um único $k$ de tal modo que

$$1+\binom{m}{1} + ... +\binom{m}{k} \lt n \leq 1+\binom{m}{1} + ... + \binom{m}{k}+\binom{m}{k+1}$$ Pode-se convencer que uma solução ideal usará a palavra-código com todos os bits baixos, depois as palavras-código com 1 bit de altura, 2 bits de altura, ..., k bits de altura. Para o$n-1-\binom{m}{1}-...-\binom{m}{k}$ símbolos restantes a serem codificados, não está claro em quais palavras de código é ideal usar, mas, com certeza, os pesos $w_i$ de cada coluna será maior do que seria se pudéssemos usar apenas palavras de código com $k+1$ bits altos e têm $|w_i - w_j| \leq 1$ para todos $i, j$. Portanto, pode-se diminuir o limite$p=max(w_i)$ com $$p_m = 0 + 1 + \binom{m-1}{2} +... + \binom{m-1}{k-1} + \lceil \frac{(n-1-\binom{m}{1}-...-\binom{m}{k}) (k+1)}{m} \rceil$$

Agora, dado $n$ e $p$, tente estimar $m$. Nós sabemos isso$p_m \leq p$ então se $p \lt p_{m'}$, então $m' \lt m$. Isso fornece o limite inferior para$m$. Primeiro calcule o$p_m$ então encontre o maior $m'$ de tal modo que $p \lt p_{m'}$

É isso que obtemos se traçarmos, por $n=1000$, os dois limites inferiores juntos, o limite inferior com base na entropia em verde, o baseado no raciocínio combinatório acima em azul, obtemos:

Ambos parecem muito semelhantes. No entanto, se traçarmos a diferença entre os dois limites inferiores, ficará claro que o limite inferior baseado no raciocínio combinatório é melhor no geral, especialmente para valores pequenos de$p$.

Eu acredito que o problema vem do fato de que a desigualdade $H(X) \leq \sum H(X_i)$ é mais fraco quando $p$ fica menor, porque as coordenadas individuais se correlacionam com pequenas $p$. No entanto, este ainda é um limite inferior muito bom quando$p=\Omega(n)$.

Aqui está o script (python3) que foi usado para calcular os limites inferiores:

from scipy.misc import comb
from math import log, ceil, floor
from matplotlib.pyplot import plot, show, legend, xlabel, ylabel

# compute p_m 
def lowerp(n, m):
  acc = 1
  k = 0
  while acc + comb(m, k+1) < n:
    acc+=comb(m, k+1)
    k+=1

  pm = 0
  for i in range(k):
    pm += comb(m-1, i)

  return pm + ceil((n-acc)*(k+1)/m)

if __name__ == '__main__':
  n = 100

  # compute lower bound based on combinatorics
  pm = [lowerp(n, m) for m in range(ceil(log(n)/log(2)), n)]
  mp  = []
  p = 1
  i = len(pm) - 1
  while i>= 0:
    while i>=0 and pm[i] <= p: i-=1
    mp.append(i+ceil(log(n)/log(2)))
    p+=1
  plot(range(1, p), mp)

  # compute lower bound based on entropy
  lb = [ceil(log(n)/(p/n*log(n/p)+(n-p)/n*log(n/(n-p)))) for p in range(1,p)]
  plot(range(1, p), lb)

  xlabel('p')
  ylabel('m')
  show()

  # plot diff
  plot(range(1, p), [a-b for a, b in zip(mp, lb)])
  xlabel('p')
  ylabel('m')
  show()

Existe um limite inferior adicional que podemos construir, que abordará casos como o que o usuário3030830 mencionou em seu comentário à resposta de Yuval. (Casos em que$p$ é particularmente pequeno.) Suponha que soubéssemos $m$ já: Então nós temos $pm$total de bits alto em todas as palavras de código. Como estamos interessados ​​nos casos em que$p$é pequeno, vemos esses bits altos como nosso recurso limitador e queremos criar um código com ele (e ver quantas palavras de código podemos extrair). Podemos ter 1 palavra de código com todos os 0s, então$m$ palavras de código com um único 1; $m \choose 2$ com dois 1s, etc. Se chamarmos o maior número de bits em uma palavra de código $k$, então

$$pm = 0\cdot 1 + 1\cdot m + 2\cdot {m \choose 2}+... \le \sum_i^k i{m \choose i}$$ Enquanto nosso número de palavras de código $n$ é igualmente limitado por $$n \le \sum_i^k {m \choose i}$$ Se olharmos para o caso em que $p \le m$, então $k \le 2$já está implícito na primeira desigualdade. ($pm = m^2 = m + 2{m \choose 2}$) Então, o código consistiria no$0$-palavra, $m$ solteiro-$1$-words e $(p-1)m/2$ dois-$1$-palavras. portanto $$n \le 1 + m + (p-1)m/2$$ ou invertendo $$m \ge \frac{2(n-1)}{p+1} .$$ Isso produzirá o limite inferior apertado de $m\ge 5$ no exemplo que você fornece, mas, como mencionado anteriormente, provavelmente só será muito útil enquanto $p \approx m$ (ou $p \approx \sqrt n$)

Aqui está um limite inferior e uma construção assintoticamente correspondente, pelo menos para alguns intervalos dos parâmetros. Denotar por$m$ o número de colunas e suponha, por simplicidade, que $p \leq n/2$.

Começamos com um limite inferior em $m$. Deixei$X$seja a codificação do símbolo escolhido uniformemente aleatoriamente. Deixei$X_1,\ldots,X_m$ ser as coordenadas individuais e deixar $w_i \leq p$ ser o peso do $i$coluna. Então

$$\log n = H(X) \leq \sum_{i=1}^m H(X_i) = \sum_{i=1}^m h(w_i/n) \leq m h(p/n).$$ Portanto $$m \geq \frac{\log n}{h(p/n)}.$$ Aqui $H$ é a entropia de uma variável aleatória $H(X) = -\sum_x \Pr[X=x] \log \Pr[X=x]$ e $h$ é a função entropia $h(x) = -x\log x-(1-x)\log(1-x)$. (Você pode usar qualquer base para o logaritmo que desejar.)

A construção assintoticamente correspondente, que deve funcionar para $p = \Omega(n)$, escolhe $m$ um pouco maior que esse limite inferior e escolhe um esquema de codificação aleatória, cada bit sendo definido como $1$ com alguma probabilidade $q/n$ que é um pouco menor que $p/n$. Escolhendo os parâmetros corretamente, devemos obter que isso resulte em uma codificação legal (todas as palavras de código são diferentes e todos os pesos de coluna são no máximo$p$) com probabilidade positiva.

Aqui está uma metodologia de pesquisa simples. Começamos a partir de um limite inferior do número de bits e tentamos encontrar uma codificação legal. Especificamente.

Seja m o número atual de bits. Codifique o símbolo i como bi1, bi2, ..., bim.

Restrições: bi xor bj não é 0 - em outras palavras, a codificação de cada símbolo é única

Para todos j: sum_i bij <= p.

Este é um problema de satisfação pseudo-booleano (bem, pode ser facilmente codificado como um problema de satifiabilidade padrão). Portanto, continue aumentando m até encontrar uma que seja satisfatória (ou faça uma pesquisa binária usando os limites inferior e superior para encontrar o mínimo m).

Obviamente, isso não garante que, na prática, você seja capaz de encontrar o m mínimo, a verificação do SAT poderá atingir o tempo limite.