Gerrymandering con puertas lógicas

La función mayoritaria es una función booleana que toma tres entradas booleanas y devuelve la más común. Por ejemplo, si maj(x,y,z)es la función mayoritaria y Tdenota verdadero y Fdenota falso, entonces:

maj(T,T,T) = T
maj(T,T,F) = T
maj(T,F,F) = F
maj(F,F,F) = F

Esta pregunta se refiere a escribir funciones booleanas como composiciones de funciones mayoritarias. Un ejemplo de una composición de 5 funciones de funciones mayoritarias es (x1,x2,x3,x4,x5) => maj(x1,x2,maj(x3,x4,x5)). Esta función devuelve el siguiente resultado en estos vectores de entrada de muestra:

(T,T,F,F,F) => maj(T,T,maj(F,F,F)) = maj(T,T,F) = T
(T,F,T,T,F) => maj(T,F,maj(T,T,F)) = maj(T,F,T) = T
(T,F,T,F,F) => maj(T,F,maj(T,F,F)) = maj(T,F,F) = F
(F,F,F,T,T) => maj(F,F,maj(F,T,T)) = maj(F,F,T) = F

Tarea

Escriba un programa que ingrese un entero positivo n y una lista de vectores de longitud n de booleanos y genere un árbol de compuertas mayoritarias que devuelva verdadero en todos los vectores dados si es posible. La función puede devolver verdadero o falso en vectores que no están en la lista de restricciones.

La lista de vectores se puede ingresar en cualquier formato que desee. Si lo prefiere, en lugar de ingresar el vector, puede ingresar la lista de posiciones verdaderas en el vector. Entonces, por ejemplo, [TTF,TFT,FTT]or [[T,T,F],[T,F,T],[F,T,T]]o [[1,2],[1,3],[2,3]](lista de posiciones verdaderas) están bien.
La salida puede ser cualquier formato de árbol válido. Por ejemplo, maj(maj(x1,x2,x3),x4,x5)funciona. Probablemente desee utilizar números individuales como sustitutos para las variables, como en [[1,2,3],4,5]. El pulido inverso 123m45mtambién está bien, por ejemplo.
Si no hay una función que funcione, su programa debería generar un error o generar un valor falsey.
Si hay varias funciones que funcionan, su programa puede devolver cualquiera de ellas. La función no necesita ser simplificada. Por ejemplo, maj(x1,x1,x2)o x1son equivalentes.

Puntuación

Este es el código de golf: la solución más corta en bytes gana.

Casos de prueba:

Tenga en cuenta que hay muchos resultados posibles para cada uno de estos casos, por lo que debe escribir un script de verificación que convierta su salida en una función y verifique que su función devuelva verdadero en cada uno de los vectores de entrada especificados.

Input: 3, [TFF]
Output: 1 or [1,1,2] or [1,[1,2,2],[1,1,3]] or other equivalent

Input: 3, [TFF,FTF]
Output: Falsey or error (it's not possible)

Input: 3, [TTF,TFT]
Output: [1,2,3] or 1 or other equivalent

Input: 3, [TTF,TFT,FTT]
Output: [1,2,3] or [1,3,2] or other equivalent

Input: 4, [TTFF,TFTF,FFTT]
Output: Falsey or error

Input: 4, [TTTF,TTFT,TFTT,FTTT]
Output: [1, 2, 3] or [2,3,4], or many other options

Input: 5, [TTTFF,FTTFT,TFFFT]
Output: [1,[1,[1,2,5],[2,4,5]],3] or many other options 

Input: 6, [TTTFFF,FTFTTF,TFFTFT]
Output: [1, 2, 4] or [1, [1, 2, 4], [2, 3, 4]] or others

Input: 5, [TTTFF,TTFTF,TTFFT,TFTTF,TFTFT,TFFTT,FTTTF,FTTFT,FTFTT,FFTTT]
Output: [[1, [1, 3, 5], 4], [1, 2, [2, 4, 5]], [2, 3, [3, 4, 5]]] or others

Input: 7, [TTTTFFF,TTTFTFF,TTTFFTF,TTTFFFT,TTFTTFF,TTFTFTF,TTFTFFT,TTFFTTF,TTFFTFT,TTFFFTT,TFTTTFF,TFTTFTF,TFTTFFT,TFTFTTF,TFTFTFT,TFTFFTT,TFFTTTF,TFFTTFT,TFFTFTT,TFFFTTT,FTTTTFF,FTTTFTF,FTTTFFT,FTTFTTF,FTTFTFT,FTTFFTT,FTFTTTF,FTFTTFT,FTFTFTT,FTFFTTT,FFTTTTF,FFTTTFT,FFTTFTT,FFTFTTT,FFFTTTT]
Output: [[[1, [1, [1, 4, 7], 6], 5], [1, [1, 3, [3, 6, 7]], [3, 5, [5, 6, 7]]], [3, 4, [4, [4, 5, 7], 6]]], [[1, [1, [1, 4, 7], 6], 5], [1, 2, [2, [2, 5, 7], 6]], [2, [2, 4, [4, 6, 7]], [4, 5, [5, 6, 7]]]], [[2, [2, [2, 4, 7], 6], 5], [2, 3, [3, [3, 5, 7], 6]], [3, [3, 4, [4, 6, 7]], [4, 5, [5, 6, 7]]]]]

code-golf logic-gates logic code-golf ascii-art code-golf math factorial

— capucha
fuente

"La composición de 5 funciones de funciones mayoritarias es (x1, x2, x3, x4, x5) => maj (x1, x2, maj (x3, x4, x5))" ¿cómo? Cuál debería ser la respuesta si x1 = x2 = F; x3 = x4 = x5 = T; ?

— tsh

Agregaré una tabla de verdad.

— Hood

¿Qué significa una salida de 1?

— Mhmd

Título sugerido: Gerrymandering con puertas lógicas

— Robert Fraser

@trichoplax No, la salida en todos los vectores restantes puede ser cualquier cosa. Actualizaré para hacer eso explícito.

— Hood

Respuestas:

JavaScript (ES6), 260 bytes

Toma datos como una matriz de matrices de booleanos. Devuelve un árbol de puertas mayoritarias indexadas en 1 o arroja un error de recursión ⁽¹⁾ si no existe una solución.

La función principal f () intenta recurrentemente encontrar una solución llamando al solucionador F () e incrementando el nivel máximo de anidamiento m en cada iteración.

_{(1) después de mucho tiempo, y asumiendo memoria infinita}

f=(a,m)=>(F=(a,d,I=a[i=0].map(_=>++i),g=(a,b)=>b[1]?b.reduce((s,i)=>s+g(a,i),0)>1:a[b-1])=>I.find(i=>a.every(a=>g(a,i)))||d&&(I.reduce((a,x)=>[...a,...a.map(y=>[...y,x])],[[]]).some(b=>r=b.length==3&&F(a.map(a=>[...a,g(a,b)]),d-1,[...I,b]))&&r))(a,m)||f(a,-~m)

Manifestación

Mostrar fragmento de código

f=(a,m)=>(F=(a,d,I=a[i=0].map(_=>++i),g=(a,b)=>b[1]?b.reduce((s,i)=>s+g(a,i),0)>1:a[b-1])=>I.find(i=>a.every(a=>g(a,i)))||d&&(I.reduce((a,x)=>[...a,...a.map(y=>[...y,x])],[[]]).some(b=>r=b.length==3&&F(a.map(a=>[...a,g(a,b)]),d-1,[...I,b]))&&r))(a,m)||f(a,-~m)

test = a => console.log(JSON.stringify(f(a.split(',').map(s => [...s].map(c => c == 'T')))))

test('TFF')
test('TTF,TFT')
test('TTF,TFT,FTT')
test('TTTF,TTFT,TFTT,FTTT')
test('TTTFF,FTTFT,TFFFT')
test('TTTFFF,FTFTTF,TFFTFT')
test('TTTFF,TTFTF,TTFFT,TFTTF,TFTFT,TFFTT,FTTTF,FTTFT,FTFTT,FFTTT')

Expand snippet

Ejemplo

A continuación se muestra una tabla de validación de la solución encontrada para el último caso de prueba de la demostración.

12345 | [5,[1,2,4],[3,4,[1,2,3]]]
------+-------------------------------------------------------------
TTTFF | [F,[T,T,F],[T,F,[T,T,T]]] --> [F,T,[T,F,T]] -> [F,T,T] --> T
TTFTF | [F,[T,T,T],[F,T,[T,T,F]]] --> [F,T,[F,T,T]] -> [F,T,T] --> T
TTFFT | [T,[T,T,F],[F,F,[T,T,F]]] --> [T,T,[F,F,T]] -> [T,T,F] --> T
TFTTF | [F,[T,F,T],[T,T,[T,F,T]]] --> [F,T,[T,T,T]] -> [F,T,T] --> T
TFTFT | [T,[T,F,F],[T,F,[T,F,T]]] --> [T,F,[T,F,T]] -> [T,F,T] --> T
TFFTT | [T,[T,F,T],[F,T,[T,F,F]]] --> [T,T,[F,T,F]] -> [T,T,F] --> T
FTTTF | [F,[F,T,T],[T,T,[F,T,T]]] --> [F,T,[T,T,T]] -> [F,T,T] --> T
FTTFT | [T,[F,T,F],[T,F,[F,T,T]]] --> [T,F,[T,F,T]] -> [T,F,T] --> T
FTFTT | [T,[F,T,T],[F,T,[F,T,F]]] --> [T,T,[F,T,F]] -> [T,T,F] --> T
FFTTT | [T,[F,F,T],[T,T,[F,F,T]]] --> [T,F,[T,T,F]] -> [T,F,T] --> T

— Arnauld
fuente

Hay una solución eficiente, que con suerte alguien encontrará. Mientras tanto, creo que la fuerza bruta funciona ...

— Hood

Mathematica, 121 bytes

Una función anónima que toma su segundo argumento como una lista de las listas de posiciones verdaderas en el vector de booleanos.

f[n_][s_]:=If[n<3,(Intersection@@s)[[1]],{#/. 2->1,#2/.{2->1,3->2},#3}&@@(1+f[n-1]/@(s-1/.{{0->1},{1->2,0->1},{0->2}}))]

Formateado ligeramente mejor:

f[n_][s_] := If[n < 3, (Intersection @@s)[[1]],
   {# /. 2 -> 1, #2 /. {2 -> 1, 3 -> 2}, #3} & @@ 
    (1 + f[n - 1] /@ (s - 1 /. {{0 -> 1}, {1 -> 2, 0 -> 1}, {0 -> 2}}))]

$\def\maj{\mathrm{maj}}\def\T{\mathrm{True}}\def\F{\mathrm{False}}$ Si hay menos de tres variables, intersecte los vectores de restricción para ver si hay un "Verdadero" común en todas las restricciones. Si hay uno, entonces la función constante (x_1, x_2) -> x_i funciona, de lo contrario es imposible (y arrojará un error al tratar de tomar el primer elemento de una lista vacía).

De lo contrario, sustituya $f_1=f(x_1,x_1,x_2,x_3,\ldots,x_{n-1})$ , $f_2=f(x_1,x_2,x_2,x_3,\ldots,x_{n-1})$ , y $f_3=f(x_1,x_2,x_1,x_3,\ldots,x_{n-1}))$ , resuelve recursivamente cada uno de estos, luego establece $f=\maj(f_1(x_1,x_3,x_4,\ldots,x_n), f_2(x_1,x_2,x_4,\ldots,x_n),f_2(x_2,x_3,x_4,\ldots,x_n))$ .

Explicación:

$n$ $n-1$ $f$ $f(x_1,\ldots,x_n)=\maj(f(x_1,x_1,x_3,x_4,\ldots,x_n),f(x_1,x_2,x_2,\ldots),f(x_3,x_2,x_3,\ldots))$

$x_2$ $x_1$ $x_3$ $x_2$ $x_1$ $x_3$

Una vez que conoce esta identidad, el algoritmo es claro: cuando hay dos o menos variables, el problema es trivial. De lo contrario, resuelve recursivamente los tres problemas de representar $f(x_1,x_1,x_3,x_4,\ldots,x_n)$ $f(x_1,x_2,x_2,x_4,\ldots,x_n)$ $f(x_3,x_2,x_3,x_4,\ldots,x_n))$

¿Por qué es esto cierto? Bueno, la función mayoritaria cumple dos propiedades:

$!x$ $x$ $\maj(!x,!y,!z)=!\maj(x,y,z)$
Es monotónico. Es decir, $\maj(x,y,\F)\leq \maj(x,y,\T)$ si para todo , entonces digo una función $\F\leq \T$ $(x_1,\ldots,x_n)\leq (y_1,\ldots, y_n)$ $x_i\leq y_i$ $i$ $f$ $(x_1,\ldots x_n)\leq(y_1,\ldots, y_n)$ $f(x_1,\ldots x_n)\leq f(y_1,\ldots, y_n)$ . La composición de las funciones monotónicas es monotónica, por lo que cada función que podemos construir a partir de la función mayoritaria es monotónica.

Resulta que las funciones monotónicas complementarias son exactamente la clase de funciones que se pueden construir a partir de puertas mayoritarias.

$f$ $f(x_1,\ldots,x_n)=\maj(f(x_1,x_1,x_3,x_4,\ldots,x_n),f(x_1,x_2,x_2,x_4,\ldots,x_n),f(x_3,x_2,x_3,x_4,\ldots,x_n))$

$f_1(x_1,x_2,x_3,\ldots,x_n)=f(x_1,x_1,x_3,x_4,\ldots,x_n)$ $f_2(x_1,\ldots,x_n)=f(x_1,x_2,x_2,x_4,\ldots,x_n)$ $f_3(x_1,\ldots,x_n)=f(x_3,x_2,x_3,x_4,\ldots,x_n)$ $f=\maj(f_1,f_2,f_3)$ $f_1$ $f_2$ $f_3$ $f$ $x_1$ $x_2$ $x_3$ $x_1=x_2=x_3$ $f_1=f_2=f_3=f$

$x_1$ $x_2$ $x_3$ $f$ $x_1=x_2$ $x_3$ $f$ es complementario, basta con tratar el caso $x_1=x_2=\F$ y $x_3=\T$ . En este caso, $(x_1,x_1,x_3)=(\F,\F,\T)=(x_1,x_2,x_3)$ , $(x_1,x_2,x_2)=(\F,\F,\F)\leq (x_1,x_2,x_3)$ and $(x_3,x_2,x_3)=(\T, \F, \T) \geq (x_1,x_2,x_3)$ . By monotonicity we deduce that $f_2\leq f_1=f\leq f_3$ . If $f=\F$ then $f_2\leq \F$ implies $f_2=\F=f$ and if $f=\T$ then $f_3\geq \T$ implies $f_3=\T$ . Thus, at least two of $f_1$ , $f_2$ , and $f_3$ are equal to $f$ in all cases so $f=\maj(f_1,f_2,f_3)$ .

— Hood
fuente