Ejemplos en los que el tamaño del alfabeto (

Sea un alfabeto, es decir, un conjunto finito no vacío. Una cadena es cualquier secuencia finita de elementos (caracteres) de . Como ejemplo, es el alfabeto binario y es una cadena para este alfabeto.Σ { 0 , 1 } $\Sigma$$\Sigma$$\{0, 1\}$$0110$

Por lo general, siempre que contenga más de 1 elemento, el número exacto de elementos en no importa: en el mejor de los casos, terminamos con una constante diferente en alguna parte. En otras palabras, realmente no importa si usamos el alfabeto binario, los números, el alfabeto latino o Unicode.$\Sigma$$\Sigma$

¿Hay ejemplos de situaciones en las que importa qué tan grande es el alfabeto?

La razón por la que estoy interesado en esto es porque me topé con uno de esos ejemplos:

Para cualquier alfabeto , definimos el oráculo aleatorio como un oráculo que devuelve elementos aleatorios de , de modo que cada elemento tiene la misma probabilidad de ser devuelto (por lo que la posibilidad de cada elemento es ).O Σ Σ $\Sigma$$O_{\Sigma}$$\Sigma$$\frac{1}{|\Sigma|}$

Para algunos alfabetos y , posiblemente de diferentes tamaños, considere la clase de máquinas con acceso a . Estamos interesados ​​en las máquinas en esta clase que se comportan igual que . En otras palabras, queremos convertir un oráculo en un oráculo usando una máquina Turing. Llamaremos a esa máquina Turing un programa de conversión.Σ 2 O Σ 1 O Σ 2 O Σ 1 O Σ $\Sigma_1$$\Sigma_2$$O_{\Sigma_1}$$O_{\Sigma_2}$$O_{\Sigma_1}$$O_{\Sigma_2}$

Deje y . Convertir en un oráculo es fácil: consultamos dos veces, convirtiendo los resultados de la siguiente manera: , , , . Claramente, este programa se ejecuta en tiempo .Σ = { 0 , 1 , 2 , 3 } O Σ 1 O Σ 2 O Σ 1 00 → 0 01 → 1 10 → 2 11 → 3 O ( 1 $\Sigma_1 = \{ 0, 1 \}$$\Sigma = \{ 0, 1, 2, 3 \}$$O_{\Sigma_1}$$O_{\Sigma_2}$$O_{\Sigma_1}$$00 \rightarrow 0$$01 \rightarrow 1$$10 \rightarrow 2$$11 \rightarrow 3$$O(1)$

Ahora dejemos y . Para estos dos idiomas, todos los programas de conversión se ejecutan en tiempo , es decir, no hay programas de conversión de a que se ejecutan en tiempo .Σ = { 0 , 1 , 2 } O ( ∞ ) O Σ 1 O Σ 2 O ( 1 $\Sigma_1 = \{ 0, 1 \}$$\Sigma = \{ 0, 1, 2 \}$$O(\infty)$$O_{\Sigma_1}$$O_{\Sigma_2}$$O(1)$

Esto se puede demostrar por contradicción: suponga que existe un programa de conversión de a ejecutándose en tiempo . Esto significa que hay un tal que realiza como máximo consultas a .O Σ 1 O Σ 2 O ( 1 ) d ∈ N C d Σ $C$$O_{\Sigma_1}$$O_{\Sigma_2}$$O(1)$$d \in \mathbb{N}$$C$$d$$\Sigma_1$

d C ′ C k C ′ d - k $C$ puede hacer menos de consultas en ciertas rutas de ejecución. Podemos construir fácilmente un programa de conversión que ejecute , haciendo un seguimiento de cuántas veces se realizó una consulta Oracle. Sea el número de consultas de oráculo. luego hace consultas adicionales de oráculo, descartando los resultados, devolviendo lo que habría devuelto.$d$$C'$$C$$k$$C'$$d-k$$C$

De esta manera, hay exactamente rutas de ejecución para . Exactamente de estas rutas de ejecución dará como resultado que devuelva . Sin embargo, no es un número entero, por lo que tenemos una contradicción. Por lo tanto, no existe tal programa.C ′ $|\Sigma_1|^d = 2^d$$C'$ C′02$\frac{1}{|\Sigma_2|} = \frac{1}{3}$$C'$$0$$\frac{2^d}{3}$

De manera más general, si tenemos alfabetos y con y , entonces existe un programa de conversión de a si y sólo si todos los primos que aparecen en la factorización prima de también aparecen en la factorización prima de (por lo que los exponentes de los primos en la factorización no importan).Σ 2 | Σ 1 | = n | Σ 2 | = k O Σ 1 O Σ 2 n $\Sigma_1$$\Sigma_2$$|\Sigma_1|=n$$|\Sigma_2|=k$$O_{\Sigma_1}$$O_{\Sigma_2}$$n$$k$

Una consecuencia de esto es que si tenemos un generador de números aleatorios que genera una cadena binaria de longitud , no podemos usar ese generador de números aleatorios para generar un número en con exactamente la misma probabilidad.{ 0 , 1 , 2 $l$$\{0, 1, 2\}$

Pensé en el problema anterior cuando estaba parado en el supermercado, reflexionando sobre qué cenar. Me preguntaba si podría usar los lanzamientos de monedas para decidir entre las opciones A, B y C. Resulta que eso es imposible.

Hay algunos ejemplos en la teoría del lenguaje formal donde los alfabetos de 2 y 3 caracteres dan comportamientos cualitativamente diferentes. Kozen da el siguiente buen ejemplo (parafraseado):

Deje que el alfabeto sea = {1, .., k} con el orden numérico estándar, y defina sort (x) como la permutación de la palabra x en la que las letras de x aparecen en orden ordenado. Ampliar sort (A) = {sort (x) | x ∈ A}, y considere la siguiente afirmación:$\Sigma$$\in$

Si A no tiene contexto, entonces sort (A) no tiene contexto.

Esta afirmación es verdadera para k = 2, pero falsa para k 3.$\ge$

La prueba de Dinur del teorema de PCP se basa en gran medida en la manipulación del tamaño del alfabeto.

Específicamente, la estructura general de la prueba es una aplicación iterativa de una técnica de potencia de gráfico un logaritmo en el número de veces que el tamaño del gráfico. En cada iteración, el gráfico se procesa previamente en un gráfico en expansión regular, amplificado por una potencia (que explota el tamaño del alfabeto), y luego se aplica una composición de PCP (convirtiendo cada restricción sobre un alfabeto grande en un sistema de restricciones sobre Un pequeño alfabeto).

El objetivo implícito del proceso es encontrar una manera de reutilizar el paso de amplificación hasta que el valor UNSAT se convierta en una fracción constante (lo que demuestra el teorema de PCP). El punto clave es que, a menos que el tamaño del alfabeto se retire cada vez, el gráfico resultante no es lo que se necesita para la reducción final.

$O(1)$$\{0,1,2\}$

$\{0,1,2\}$$\{0,1\}$$O(1)$ por Dodis, Patrascu y Thorup sobre él, y las referencias allí, deberían ser un buen punto de partida.

En los códigos de corrección de errores, es posible que haya una diferencia fundamental entre los códigos binarios y los códigos sobre alfabetos más grandes en que algunos creen que los ejemplos de Gilbert Varshamov para códigos que corrigen una fracción de errores (que son esencialmente ejemplos codiciosos o aleatorios) ser apretado en el caso binario y se sabe que no lo son sobre un alfabeto grande a través de códigos de geometría algebraica. Esto llevó a algunos a especular que la definición estándar de códigos de corrección de errores para un alfabeto grande no es el análogo correcto de los códigos de corrección de errores binarios.

$\ge 3$

El resultado es algo técnico, pero si está interesado, puede contrastar el Lema 8 con la Sección 4.1 para ver las afirmaciones relevantes del teorema.