This one easier. Install gmp.

Unpack the polymake 2.9.8 tarball.

Install whatever perl module required to get ./configure going. Before running ./configure, however before trying open support/locate_build_dir

and change line 78 from  uname -p to  uname -m

Now, go /lib/PTL/include/Bitset.h and edit line 57 that says

=__GMP_BITS_PER_MP_LIMB

change it to

=GMP_NUMB_BITS

save, configure and make!

pacman -S gmp perl-xml-libxml  perl-xml-libxslt  perl-xml-writer perl-term-readline

Al parecer, perl-term-readline no es suficiente, dando el error:

Can't locate object method "new" via package "Term::ReadLine::Gnu" 
at /root/poly/polymake-2.9.6/apps/common/rules/configure.rules line 26.

por lo que se procede a instalar (vía AUR) perl-term-readline-gnu

Crear un directorio, descargar y descomprimir polymake

# mkdir poly; cd poly
# wget http://www.math.tu-berlin.de/polymake/download-alpha/polymake-2.9.6.tar.bz2
# tar xvjf polymake-2.9.6.tar.bz2
# cd polymake-2.9.6

Editar support/utils.make y cambiar la línea que contenga   uname -p a    uname -i

Editar lib/PTL/include/Integer.h y modificar la línea #include <limits> a   #include <limits.h> . Esto evitará el error

/root/poly/polymake-2.9.6/lib/PTL/include/Integer.h:1188: error: ‘INT_MAX’ was not declared in this scope

• Procesador Intel Core 2 Duo T8100
• 320 Gb de disco duro (particionado asignando 25Gb a linux)
• 4 Gb de RAM

Pre-instalación

Obviamente el primer paso es descargar archlinux. En http://www.archlinux.org/download/ podemos descargar la imagen. Seleccionamos un mirror (en este caso mirror.neotuli.net).

Hay varias opciones:

• iso/img Hay dos formatos: iso es para grabar en cd, img es para unidad USB.
• core/ftp La versión FTP descarga las últimas versiones de cada programa instalado desde internet, mientras que la versión core trae incluidas en la imagen los paquetes por lo que no requiere conexion a internet.

Sin embargo, AMBAS imágenes producen el resultado después de actualizar los paquetes a sus últimas versiones. Dado que no me interesa bajar una imagen maś pesada para instalar paquetes que luego actualizaré, me decanto por la versión FTP (pero esta opción sólo debe usarse si se dispone de una conexión rápida).

Accedemos al directorio más reciente: 2009.2 y se descarga la imagen elegida. En mi caso:

archlinux-2009.02-2-ftp-i686.img
2009.02 : versión febrero de 2009
ftp : instalación de versiones más recientes desde internet
i686 : versión de 32 bits (recomendada sobre la de 64bits)
img : instalación desde USB (iso es para CD)

Total: 157MB

y siguiendo las instrucciones en http://wiki.archlinux.org/index.php/Install_from_USB_stick lo copiamos a la unidad USB

En linux:

 dd if=archlinux-2009.02-2-ftp-i686.img of=/dev/sdb

Una vez terminado el proceso, reiniciamos la computadora desde la unidad de USB.

Instalación

Al arrancar escogemos la primera opción: Boot Archlinux Live CD (aunque sea una unidad USB) y al aparecer el diálogo de login, ingresamos como root.

Lo primero es configurar el teclado para español. Ejecutamos km y seleccionamos de la primera lista: i386/qwerty/es.map.gz, en la segunda escogemos default-8×16.psfu.gz.

Ahora podemos iniciar propiamente el proceso de instalación con el comando

 /arch/setup 

Selección de origen

Lo primero es indicar de dónde se obtendran de los paquetes: del CD o de internet. Como vamos a usar instalación desde red seleccionamos FTP/HTTP. A cotinuación se nos indica que configuremos la red.

En mi caso, al tener internet inalámbrico, el diálogo no funcionará tal cual (porque está preparado para conexiones de ethernet). Así que presionamos Control-Alt-F2 para abrir una nueva consola virtual, ingresamos como root y ejecutamos

ifconfig wlan0 upi
iwconfig wlan0 essid drinired key passworddelared
dhcpcd wlan0

reemplazando, claro, el nombre de la red y el password apropiados. Si la configuración de la red es más compleja, por favor contactar al administrador de red.

Presionamos Control-alt-F1 para regresar a la instalación y accedemos a Choose mirror para seleccionar el sitio web que deseamos. Nuevamente selecciono http://mirror.neotuli.net (no es recomendable usar http://ftp.archlinux.org porque esa dirección es algo lenta).

Regresamos al menú principal

Ajuste del reloj

Seleccionamos local en vez de UTC (para evitar que la hora de Windows se cambie innecesariamente) y seleccionamos el huso horario apropiado:

2) America
30) Mexico
1) Central time

Luego ajustamos la fecha actual.

Preparar el disco duro

Ahora sí, la hora de ensuciarnos las manos. Hay que particionar el disco duro pero cfdisk no es la forma más sencilla. Esta es la parte maś delicada del proceso porque se indica dónde en el disco se instalará Arch y qué particiones se formatearán. Lo más recomendable es tener ya las particiones listas antes del proceso (ya sea con PartitionMagic en Windows o Gparted en linux), sino tienes particiones, dios te bendiga y mucha suerte, no explicaré cómo hacerlo.

En mi caso, ya tengo particiones preparadas:

/dev/sda2 – 10GB
/dev/sda5 – 16GB
/dev/sda7 – 1 GB
/dev/sda6 – 1 GB

Usaremos sda2 para la raíz, sda5 para home y sda6 para intercambio de memoria (swap). La partición sda7 no se usará.

En la instalación se escoge la segunda opción 2 Partition HD (manualmente) para ver que todo está en orden. Salimos y entramos a la tercera: 3 Set filesystem mount points es decir, asignar puntos de montaje.

Primero nos pregunta por la partición SWAP. Indicamos /dev/sda7. Luego pregunta por la partición asignada a / (root): /dev/sda2 con sistema de archivos ext3 Finalmente pregunta por puntos de montaje adicionales. Seleccionamos /dev/sda5, asignamos a /home (en vez de /boot como sugerido) escogiendo ext3.

Salimos aceptando a todo, se realizan los cambios y pasamos a la siguiente etapa.

Selección de paquetes

Después de un breve diálogo donde indica que ha descargado la lista de paquetes, se nos presenta la posibilidad de configurar la selección.

Asegurándonos de que [*] base esté seleccionado y [ ] base-devel no, nos lleva a la lista base de paquetes.

Si se sabe lo que se está haciendo, se puede retirar alguno de los paquetes activos (por ejemplo, yo no uso conexión vía telefónica, por ello retiro ppp y rp-pppoe. Aquí el criterio de cada quien.

Se puede añadir paquetes que no estén marcados, por ejemplo yo añado wireless-tooos, iwlwifi-3945-ucode.

Instalación de paquetes

Entramos a 4 Install packages y un diálogo nos da la bienvenida, presionamos OK y se inicia la descarga. En mi caso, se descargaron 390 mb durante 20 minutos.

Mientras termina el proceso, puedes presionar Control-Alt-F2 y navegar por la web en modo texto con el comando elinks.

Al terminar, si indica un error porque no todos los paquetes se descargaron, ingresa nuevamente en la opción de instalar, pero esta vez sólo se descargan los paquetes faltantes.

Cuando todo se completa, se instalan los paquetes y el sistema ya está prácticamente instalado.

Configuración del sistema

Ahora vamos a configurar los parámetros base. Usando el editor que prefieras (vi editamos algunos de los archivos que se presentan. Por ahora sólo necesitamos:

En /etc/rc.conf

LOCALE = "es_ES.utf8"
KEYMAP = "es"
HOSTNAME = "combinatorica"

El hostname es el “nombre” de la computadora en la red, no tiene que ser igual a éste.

Instalar el gestor de arranque

En 6 Install Bootloader seleccionamos la opción GRUB, editamos el archivo deconfiguración y descomentamos las líneas para Windows:

# (2) Windows
title Windows
rootnoverify (hd0,0)
makeactive
chainloader +1

Aceptamos e indicamos instalar en /dev/sda. ¡Listo! Hemos terminado la instalación. Reiniciamos ahora sin el llavero y entramos a neustro flamante nuevo sistema

El sistema obtenido es muy básico (menos de 1gb) con las herramientas esenciales y muy ligero (nada innecesario está corriendo). El siguiente paso es personalizarlo e instalar los programas que usaremos.

Se quiere analizar los procesos por los cuales un colectivo, una comunidad, desea elegir una opción entre un grupo de alternativas. El proceso democrático estándar funciona muy bien cuando sólo hay dos opciones: cada votante selecciona su opción preferida y el ganador de la votación corresponde a la opción que tiene más apoyo.

Sin embargo, cuando hay más de dos candidatos la situación no es tan clara. Por ejemplo, supongamos que hay tres candidatos A, B, C. Hay 6 diferentes formas de ordenar la preferencia de los votantes:

• A  B  C : (20)
  
• A  C  B : (26)
  
• B  A  C : (18)
  
• B  C  A : (26)
  
• C  A  B : (2)
• C  B  A : (8)
  

Los números a la izquierda de cada orden indican el número (o porcentaje) de votantes que ordenan a los candidatos en ese orden de preferencia: por ejemplo, hay 26 votantes (o el 26% de los votantes) para los que A es el mejor candidato, C el segundo y B el peor de todos.

Se efectúa la votación, cada votante selecciona su candidato favorito. El resultado de la elección es:

• A : 20 + 26 = 46 votos a favor.
• B : 18 + 26 = 44 votos a favor.
• C : 2 + 8 = 10 votos a favor.

El ganador de la elección es A con 46 votos a favor. Dado que A ganó la elección, debe ser el mejor candidato. ¿no? Veamos…

¿Cuanta gente piensa que B es mejor candidato que C?

• Hay 20 + 18 + 26 =64 votantes que prefieren a B sobre C.
• Hay 26 + 2 + 8 = 36 votantes que prefieren a C sobre B.

Hasta ahí no hay ninguna sorpresa, la mayoría de los votantes prefiere a B sobre C.

¿Cuanta gente piensa que A es mejor candidato que B?

• Hay 20 + 26 + 2 = 48 votantes que piensan que A es mejor que B.
• Hay 18 + 26 + 8 = 52 votantes que piensan que B es mejor que A.

Entonces… la mayoría de los votantes prefieren a B sobre A.

Es decir… la mayoría de los votantes piensa que B es mejor candidato que A,  y la mayoría de los candidatos piensa que B es mejor candidato que C. Sin embargo…. ¡B pierde la elección!

—-

Referencia. Taylor & Pacelli. Mathematics and Politics: Strategy, Voting, Power and Proof. Springer. 2008.

mathml en firefox

El problema… Internet Explorer no soporta MathML y firefox necesita unas fuentes extras para mostrar correctamente ciertas expresiones (como radicales). La solución viene en dos pasos

• Instalar las fuentes STIX, lo cual resuelve el problema en los navegadores Mozilla (así por ejemplo sqrt(2/x)  ya no se mostrará erróneamente como sqrt(2)/x  al no ser extensible el símbolo de radical)
• Instalar MathPlayer, lo cual permite que Internet Explorer entienda el Doctype apropiado para soporte MathML.

El resultado (en Internet Explorer):

MathML en internet explorer

El estándar MathML debería ser más utilizado, pero para ello es necesario que el soporte para ambos se extienda más por lo que ya saben… a instalar las fuentes stix y el mathplayer.

: Drini: Vamos a jugar un juego, mi estimado Luis. Yo pienso un color (como blanco, rojo, azul, etc. para simplificar, nada de «azul prusiano» o «rojo bermellón»). Tienes una oportunidad de adivinar. Si atinas, te doy 20 euros, si pierdes, me das 10. ¿Vale?
: Luis: Ok.

(Drini piensa VERDE)

: Luis: Pues… estás pensando en VERDE.
: Drini: No, fallaste, estaba pensando en CAFE
: Luis: Bueno, psshh… toma los 10 euros, pero me parece que has hecho trampa
: Drini: ¿trampa yo? ¿cómo te atreves a sugerir eso?

Lola

: Drini: Vamos a jugar un juego, Luis. Yo pienso un color (como blanco, rojo, azul, etc. para simplificar, nada de «azul prusiano» o «rojo bermellón»). Tienes una oportunidad de adivinar. Si atinas, te doy 10 euros, si pierdes, me das 5. ¿Vale?
: Luis: Hmm… ¿y quién me garantiza que no mentirás sobre tu elección?
: Drini: Bueno, aquí anda Netito, le digo a Netito el color que pienso, tú adivinas y él corrobora mi elección.
: Luis: Ok, me parece.
: Drini: Ya pensé el color, acércate, Netito, para que te diga mi elección.

(Netito se acerca)

: Drini: (en secreto) Mira Netito, tú limítate a asentir a lo que yo diga y te ganas 5 euros, ¿ok?
: Netito: Ok.

: Drini: Estamos listos, Luis, ya pensé un color. Adivina.
: Luis: Estás pensando AZUL.
: Drini: No, pensé en ROJO. ¿verdad Netito?
: Netito: Sí, pensó ROJO.
: Luis: Pshh.. otra vez perdí, toma los 10 euros. Nos vemos luego.
: Drini: Bye, Luis.

(Drini le da 5 euros a Netito)

Matrix

Los ejemplos son bastante metafóricos, y en realidad está hablando de Internet, para aquellos a los que no les ha caído el veinte.

En un entorno digital, donde las interacciones no son persona a persona, hay un elemento de incertidumbre siempre presente sobre la fiabilidad de la información. ¿Cómo garantizar que la persona con la que hablamos sea quien afirma ser? Podría ser alguien más tomando su lugar (usando su mismo nombre de usuario, robando sus contraseñas, etc.) Por ejemplo, si alguien muestra un correo electrónico o un «log» de una conversación como prueba de algo, ¿cómo saber que no han sido alterados o inventados?

Además, toda la información que transita por Internet, cada mensaje, cada correo, pasa (sin que se note) por docenas de servidores intermediarios (netitos), cada uno de ellos puede alterar la información. Y es que en el ejemplo había muy poco en juego. Pero ¿y si fuera esencial certificar la veracidad de alguna afirmación? Por ejemplo, si estuviera en juego la contraseña a una cuenta bancaria, o si hubiera información confidencial que no deba ser manipulada…

Un listo podría notar que en los ejemplos bastaba con que yo escribiera en un papel el color pensado, y lo mostrara después de su elección, pero en línea, donde las personas no interactúan cara a cara, eso no es posible. El equivalente digital sería almacenar la información en un sitio (por ejemplo en una pagina web) y luego indicar al jugador que acceda a la página, pero nuevamente los mismos fallos se presentan: yo podría alterar la información antes de que el otro jugador la vea, podría una tercera persona intervenir (a favor mío o del otro jugador). Piensa que podrían no ser 5 euros en juego, sino 500mil. Incluso si yo pusiera la información en una página protegida con contraseña, podría yo cambiarla antes de que el oponente acceda a ella (yo hago trampa), pero también podría la otra persona «adivinar» la clave y leer la respuesta sin que yo me entere (siendo ahora yo la víctima).

El problema de certificar información digital es bastante complejo. Concentrándonos en la situación del juego, lo esencial del problema es:

1. Se tiene que fijar un dato (el color)
2. Se tiene que mantener secreto un tiempo y revelarse luego de algún evento.
3. Se tiene que certificar que la información no se haya manipulado en el tiempo intermedio.

Una forma de solucionarlo es cifrando el color y entregándolo al inicio del juego. Así nos aseguramos que el recipiente no conozca la información antes de tiempo (por estar cifrada), así como que yo no la pueda cambiar (porque desde el inicio del juego el otro participante ya tiene la respuesta en su poder).

Corre

: Drini: Vamos a jugar un juego, Luis. Yo pienso un color (como blanco, rojo, azul, etc. para simplificar, nada de «azul prusiano» o «rojo bermellón»). Tienes una oportunidad de adivinar. Si atinas, te doy 10 euros, si pierdes, me das 5. ¿Vale?
: Luis: Hmm… ¿y quién me garantiza que no mentirás sobre tu elección?
: Drini: Bueno, aquí anda Netito, le digo a Netito el color que pienso, tú adivinas y él corrobora mi elección.
: Luis: No, yo sé que ustedes son amiguetes y lo más probable es que se pongan de acuerdo para estafarme. A otro perro con ese hueso.
: Drini: Tengo otra idea. Yo escojo el color, lo cifro mediante un código y lo escribo en esta pizarra, así te aseguras de que ya no puedo cambiar mi elección. Después de que adivines, te digo cómo descifrar el código y verificas si la respuesta que das coincide o no.
: Luis: Bueno, así me parece bien, porque ya no puedes cambiar tu respuesta (está en la pizarra) y yo podré comprobar si acierto o no cuando me reveles el código. ¡Juguemos!
: Drini: Perfecto, entonces escribo en la pizarra… TIRH.
: Luis: Me parece que pensaste en GRIS
: Drini: No, fallaste de nuevo, el color que pensé es AZUL. Paga tus 10 euros.
: Luis: ¡Momento! Revélame el código para que yo pueda asegurarme de realmente perdí.
: Drini: Claro, el código de cifrado es:

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
T N O S U J Y B X E V H G A P D M C L F R Q W K Z I

Cada letra de la fila superior se cambia por la letra de la fila inferior.
: Luis: Psshh… pues sí, perdí toma tus 10 euros.
: Drini: Je, je, je…

Matrix recargado

Nuevamente, me he pasado de listo. Antes de continuar, considera el siguiente cifrado:

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
Z Y X W V U T S R Q P O N M L K J I H G F E D C B A

Mucho más natural, ¿no? Y bajo ese esquema.. TIRH = ….

Ha quedado clara la falla del sistema en el último escenario. No basta con hacer público el mensaje cifrado. También hay que hacer público el método de cifrado antes de la toma de decisiones porque de lo contrario no se está garantizando el tercer punto del problema (el mensaje no debe ser alterado).  La trampa se hace ya no alterando el mensaje, sino la forma de descifrar el mensaje (para obtener la respuesta que se quiera).

Ahora, si al inicio del juego le diera la tabla de código a Luis podría él revertir el cifrado al leer TIRH en la pizarra y darme la respuesta correcta sin necesidad de adivinar, por lo que revelar el método al inicio del juego asegura que se cumple la condición 3 pero ya no la condición 2 (que el mensaje debe ser secreto hasta que yo decida revelarlo). Ser o no ser…

De nueva cuenta, la historia es metafórica, la situación bien podría corresponder a dos empresas haciendo una transacción de varios millones, pero que la trasferencia electrónica se deba hacer sólo después de haber firmado el contrato, siendo imprescindible que un documento permanezca secreto durante las negociaciones pero al mismo tiempo no sea posible modificarlo. E incluso, aunque no se diera el método de cifrado al inicio del proceso (permitiendo a la empresa Drini Co. hacer trampa al final), sería posible que la Luis contratara un hacker que descubriera la forma de descifrar el documento (permitiendo a Luis Inc. hacer trampa al inicio).

El Señor de los Anillos

Malo si haces (revelar el código al inicio), malo si no haces (revelar el código al final). Aparentemente.

La verdadera causa del problema es que los cifrados usados en el ejemplo son reversibles. Es decir, si se conoce el método se puede pasar de un mensaje «en claro» a un mensaje «cifrado» y viceversa.
Una vez fija la tabla, es posible ir y venir entre las dos formas sin ningún esfuerzo, quien posea la tabla poseerá todas las piezas del rompecabezas.

Incluso podríamos imaginar un sistema en donde los métodos de cifrado y descifrado sean distintos, revelaríamos el método de cifrado al inicio y revelamos el de descifrado al final. Aunque en apariencia más robusto que el esquema anterior, en realidad padece de los mismos problemas. Por ejemplo: el oponente podría descubrir por sí mismo el método de descifrado tomando ventaja durante el proceso.

La solución está en (redoble de tambores…) usar un sistema de cifrado que «no se pueda descifrar». Siendo más precisos, una proceso para cifrar un mensaje que no se pueda revertir, por lo que no sea posible obtener el mensaje original a partir del mensaje en clave (aunque se conozca el proceso de cifrado).

De esta forma, al inicio del proceso los participantes se ponen de acuerdo en el proceso de cifrado, se da el mensaje en clave garantizando la inviolabilidad del mismo, y al no ser posible revertir el proceso se garantiza también el secreto.

En teoría se oye bien, pero ¿cómo obtener tal método? La respuesta es: mediante funciones de hash. Pero antes…

Las dos torres

Antes de explicar cómo obtener un método que no se pueda revertir, primero vamos a ver cómo obtener un método que sea »difícil» de revertir.

Ya en el rollo digital, lo primero que haremos será trabajar con números. Convertimos cada letra a un número como sigue:

A B C D E F G H I J  K  L  M  N  O  P  Q  R  S  T  U  V  W  X  Y  Z
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

Así, por ejemplo, la palabra «WIKI» corresponde a (23 9 11 9).

El método de cifrado es:

• El número correspondiente a cada letra, se eleva a la quinta potencia, se divide entre 29 y se toma el resto para obtener el valor cifrado

Por ejemplo, la letra V (que corresponde al número 22) se transforma en la M porque:

22⁵ = 5153632  dividiendo entre 29 se obtiene 177711 y el resto de la división es 13, correspondiendo a la letra M.

Bajo este esquema, PEDRO se convierte, por ejemplo, en SVIOJ. El sistema es relativamente simple (con una calculadora se puede cifrar  un texto manualmente en unos par de minutos) pero es muy invertir el proceso.

Como reto, descifrar el mensaje ALBE (es decir, qué palabra de 4 letras se convierte, mediante el proceso descrito, en ALBE). La siguiente sección proporciona una forma de solución.

El regreso del rey

Supongamos que queremos descifrar la letra K (es decir, 11). Tenemos que hallar un número x tal que al elevarlo a la 5, dividir entre 29 y tomar el resto, el resultado sea 11. En otras palabras, resolver la ecuación de congruencia x^5 = 11 (mod 29), el cual ya no es un problema elemental de teoría de números y se conoce como el problema del logaritmo discreto.

Pero realmente no es necesario estudiar aritmética avanzada para descifrar el mensaje. El esquema sigue padeciendo de la misma debilidad: los mensajes con completamente reversibles. En otras palabras, no hay dos letras que se transformen o cifren en una misma. Así, como ya sabemos que la P se convierte en S, cada vez que aparezca una S en el mensaje cifrado sabremos que el original es P.

Como consecuencia, para descifrar el mensaje basta /construir/ la tabla nuevamente y se obtiene un diccionario para realizar la traducción en cualqueir sentido. Disponiendo de métodos electrónicos es cuestión de minutos reconstruir la tabla de cifrado

A B C D E F G ...
A C K I V D P ...

así, si recibiéramos el mensaje cifrado KADV, sabríamos que el original es CAFE, sin necesidad de hacer más cálculos.

Hay que aclarar un punto sutil. No estamos «descifrando» en el sentido de invertir el proceso de codificación (porque no calculamos el logaritmo discreto) lo cual es difícil, sino que hicimos trampa reconstruyendo todas las posibilidades de cifrado para obtener un diccionario. Pero.. ¿y si eso no fuera posible? Por cierto, la solución del reto en la sección anterior es AQUI (AQUI se cifra como ALBE).

Matrix revoluciones

Una función de hash es una función que es «fácil» de calcular, pero imposible de revertir por no ser «uno a uno».

Supongamos que ahora el método de cifrado consiste en elevar al cubo, dividir entre 19 y tomar el resto.

Cuando hagamos la trampa de reconstruir el diccionario obtendremos:

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
A H H G K G A R G L A R L H L K K R S A H H G K G A

Y nuestro truco habrá sido derrotado, porque si recibimos el mensaje HARL ya no sabremos si corresponde a la palabra BALO o CARO

La novedad es que este nuevo sistema ya no es «uno a uno» (correspondencia exacta entre un código y otro) sino que hay colisiones en el método. Por tanto, es realmente imposible saber a ciencia cierta el mensaje original

Dado que es imposible «descifrar» el mensaje ¿qué utilidad puede tener tal tipo de función? La respuesta es: certificación digital.

Si en el juego de adivinar colores, yo pensara AZUL acordando publicar el hash (cifrado) con el método de elevar al cubo y dividir entre 19, pondría en la pizarra: AAHR

Dado que hay muchas palabras que dan el mismo hash, específicamente, hay 625 diferentes palabras de 4 letras con el hash AAHR, Luis tendría que calcular todas las 625 combinaciones para poder adivinar mi color.

Quizás aquí convenga cambiar un poco el juego para hacer énfasis en los puntos finos de la situación. Si el juego consistiera en adivinar una palabra de 4 letras (no necesariamente un color), y digamos, yo pienso CABO, el hash que haré público será HAHL. Luis tiene que adivinar qué palabra de cuatro letras pensé, habiendo 625 diferentes posibilidades. Para él, saber el hash le es inútil (porque no puede usarlo para recuperar la palabra original dado que hay colisiones). De esta forma, el hash asegura la segunda condición del problema (mantiene el secreto), pero ¿qué hay de la tercera, que yo no pueda falsificar la respuesta?

Imaginemos que Luis por suerte propone CABO, la misma palabra que yo había pensado. Para hacer trampa, tendría yo que encontrar una palabra de 4 letras que tenga el mismo hash y en realidad no es difícil hacerlo: por ejemplo NABO, NANO, CANO, VANO, etc.

Sin embargo, lo que sucede es que la función que di como ejemplo NO es una buena función de hash, es una función muy simple para propósitos ilustrativos. Sin embargo hay funciones de hash que sí satisfacen el tercer criterio (la inviolabilidad del mensaje).

¿Porqué es una mala función de hash? La principal debilidad es que hay demasiadas colisiones, lo que proporciona bastante espacio de maniobra para generar nuevas combinaciones con el mismo hash. Es decir, hay mucha probabilidad de colisión. El enfoque de crear un diccionario para romper el hash no es de mucha utilidad ya que en aplicaciones el diccionario no contendría 26 letras sino que constaría de miles de millones de entradas.

Las funciones de hash usadas en aplicaciones reales son algoritmos muchísimo más complejos que los del ejemplo, imposibles de revertir y prácticamente imposible generar un mensaje falso que tenga el mismo hash que un mensaje dado. Dependiendo del algoritmo y de los parámetros que se usen, se obtienen diferentes grados de seguridad.

Por ejemplo, el hash MD5 se usa comúnmente para verificar que la descarga de un archivo sea correcta (si el hash del archivo descargado no coincide con el hash publicado en el sitio web, es que la descarga se realizó incorrectamente) funciona porque la probabilidad de que el archivo corrupto tenga el mismo hash que el archivo original es casi nula. Pero aunque es seguro para certificar la información en una descarga cualquiera en Internet, no sería apropiado para certificar una transferencia de millones de euros, en cuyo caso se usaría un hash mucho más fuerte (de mayor complejidad y que haga uso de mayor cantidad de recursos computacionales).

La vida de Brian

Una aplicación de certificación con hashes es la comprobación digital de identidad.

El problema es éste: yo tengo una cuenta en un sistema (digamos Wikipedia). Si por alguna razón alguien robara mi contraseña, podría suplantar mi «identidad» en el sistema y actuar en mi nombre. Incluso podría cambiar la pregunta que se usa para recuperar la información, cambiar la dirección de correo electrónica asociada a la cuenta. En otras palabras, yo perdería por completo la posibilidad de recuperarla.

Bueno, podría yo acudir a los administradores del sistema quienes podrían reasignarme una nueva contraseña para recuperar la cuenta. Pero el problema surge de nuevo: ¿cómo garantizar que efectivamente soy yo quien está pidiendo la ayuda?

Es decir, otra persona podría intentar hacerse pasar por mi, pidiendo ayuda para que se le reasigne una clave y entonces los administradores del sistema le entregarían las llaves del reino, pensando que me las entregan a mi. No pueden enviar tampoco una contraseña a la dirección de correo, porque podría haber sido alterada.

Siendo un problema de certificación, de nueva cuenta podemos resolverlo usando hashes públicos. Como bien se dice, la prevención es la mejor solución.

En este momento, selecciono una frase cualquiera, por ejemplo:

Mira siempre el lado bueno de la vida

y calculo su hash bajo un esquema criptográfico de alta seguridad conocido, por ejemplo, SHA-512. Entonces hago público hoy el hash (por ejemplo, incluyéndolo en mi página de usuario):

82748725d9aabf69f9aded742f7e7faee94f6b9228b
767434eb4030fd4b8a9869503e90ee09700df8ddde0
929253cc07236d48f956a2de6eb30ab19085d47959

indicando que es una certificación digital de mi identidad

Transcurre el tiempo y sucede el temido evento de que mi cuenta es robada, mis datos alterados, mi correo electrónico cambiado, etc. Acudo con los administradores del sistema pidiendo ayuda:

: Drini: Buenos días, necesito ayuda para recuperar mi cuenta que ha sido robada. ¿podrían asignarme una nueva contraseña?
: Devs: No, porque podrías ser un impostor ¿quién nos garantiza que tú eres el dueño original de la cuenta?
: Drini: Ah, porque tengo una certificación digital de mi identidad. El día 17 de julio de 2008 puse en mi página de usuario el hash SHA-512. El impostor no conoce la frase original pero yo sí, la cual es:
«Mira siempre el lado bueno de la vida»
: Devs: Ok, espera un par de minutos mientras calculamos el hash de esa frase.
(…..)
: Devs: ¡Coinciden! Eso nos prueba que eres el dueño de la cuenta, ¿a dónde quieres que enviemos la nueva contraseña?

Asunto resuelto. ¿porqué funciona el esquema? Porque aunque otra persona tenga posesión de mi cuenta, no podrá crear una frase que tenga el mismo hash que publiqué, debido a que estoy usando un hash de alta seguridad.

En realidad, el problema de los colores es una metáfora de esta situación. Poner el hash en mi página de usuario, equivale a seleccionar un color y mantenerlo secreto, hasta que llega un momento (el final del juego/la certificación de la identidad) en que revelo la frase original, garantizando que la respuesta es la misma que la seleccionada originalmente.

Para más información: [[en:Commitment_scheme]] pero ojo, que cualquiera puede editar la wikipedia de modo que no se puede confiar en su información.

Existen herramientas en línea para calcular y verificar hashes: [1] y [2]

En estos días mi trabajo en el doctorado involucra contar cuántos puntos con coordenadas enteras tienen ciertos «poliedros» en 12 dimensiones. Tales poliedros están determinados por las formas diferentes en que se puede descomponer un número como sumas ordenadas, es decir particiones. Así, dado que 6=3+1+1+1, entonces [3,1,1,1] es una partición de 6.

Las distintas particiones de n=6 son

[6] [5, 1] [4, 2] [4, 1, 1] [3, 2, 1] [3, 1, 1, 1]
[2, 2, 2] [2, 2, 1, 1] [2, 1, 1, 1, 1] [1, 1, 1, 1, 1, 1, 1]

En la aplicación particular que estoy trabajando, únicamente nos importan particiones de longitud 3. Entonces de las anteriores sólo se considerarían

[4, 1, 1]
[3, 2, 1]
[2, 2, 2]

Como siempre es mejor usar la computadora para las tareas mecánicas, me propuse elaborar un programa en Python que genere particiones de un número entero.

El esquema básico es el siguiente:

1. Recorrer todos los números n, n-1, n-2, .., 3, 2, 1  para ocupar la primera posición
2. Una vez fija la primera posición k,  el resto se genera «uniendo» esa primera posición con todas las particiones de n-k.

Por ejemplo, si n=6,  y k=4 entonces todas las particiones que inician con 4 se obtienen de las particiones de 2: [2] y [1,1], dando como resultado [4,2] y [4,1,1], ambas mencionadas arriba.

En particular, una partición es una lista, y el resultado del programa debe ser una lista de listas. Finalmente, aunque en mi aplicación sólo es necesario calcular particiones de longitud 3, me conviene poder calcular particiones de cualquier otra longitud fija.

Bosquejo inicial

# coding=latin1
def particiones(n):
    if n==1:                   # Esto detiene la recursión, si n=1, la única partición es [1],
                               # por lo que la lista de las particiones es [ [1] ]
        return [ [1] ]
    elif n<1:
        return []          # Por si acaso atrapar casos "raros". Si n=0, no hay particiones, regresar []
                           # de modo similar para n<0.
    listaparticiones=[]        # incialmente no tenemos ninguna partición calculada
    for k in range(n,0,-1):      # Aquí recorremos todos los valores k para el primer elemento
        cola= particiones(n-k)     # generamos la lista de particiones de n-l
        for x in cola:             # y para cada una de ellas...
            particion= [k] + x      # la unimos con el primer elemento
            listaparticiones.append(particion)   # y la agregamos a la lista
     return listaparticiones       # al final devolvemos todas las que hayamos construido

lista=particiones(5)        # calcularemos las particiones de n=5...
for p in particiones(5):    # y luego las mostraremos
print p

Todo listo, corremos y…

[4, 1]
[3, 1, 1]
[2, 2, 1]
[2, 1, 1, 1]
[1, 3, 1]
[1, 2, 1, 1]
[1, 1, 2, 1]
[1, 1, 1, 1, 1]

Se ha omitido [5] porque la recursión termina cuando n<0 la lista sobre la que se itera es vacía. Esto se soluciona cambiando

        elif n<1:
                return [] 

por

        elif n<1:
                return [ [] ]          

Sin embargo, algo ha salido mal, porque [1,3,1] no es partición. El problema es que el esquema original no contempla que las «colas» que generan las particiones de n-k no pueden iniciar con un entero mayor que la «cabeza» k.

Otro problema menos evidente y mucho más interesante, es que se están efectuando muchísimas recursiones, en cada paso manteniendo en memoria listas muy grandes de particiones de forma innecesaria (por ejemplo, hay 200 000 particiones de n=50, y al efectuar la recursión fácilmente se usarán varios megabytes de memoria para algo tan sencillo). Además, se hace necesario almacenar la lista de particiones en una variable para poder recorrerla, como en:

lista=particiones(5)
for p in particiones(5):
      print p

La solución a ésto es descartar el enfoque rudimentario de hacer recursiones sobre listas y usar generadores.

Generadores en python

Un generador es una forma conveniente de crear funciones que regresan valores pertenecientes a una lista sin tener que calcular toda la lista de antemano. En el ejemplo anterior, es necesario calcular TODA la lista de particiones

lista=particiones(5)

antes de poder mostrar siquiera la primera. Sería mucho más conveniente que particiones() diera cada una de ellas al necesitarlas, sin necesidad de calcularlas todas de antemano, lo cual se obtiene mediante el uso de generadores.

Otro uso de los generadores es devolver los elementos de una lista infinita, y como matemáticos esto es muy útil, sobre todo si se quiere modelar series y sucesiones.

Por ejemplo, queremos generar una lista de las primeras t aproximaciones a la suma 1 + (1/2) + (1/3) + … + (1/n).  La función sería:

def armonica():
     suma=0.0        # inicializamos valores
     n=0.0
     while True:   # ciclo infinito!!
         n=n+1         # aumentamos la variable
         suma = suma + 1/n    # calculamos la nueva suma
         yield suma           # regresamos el nuevo valor

El uso de yield en vez de return convierte a la función en un generador, que regresa sus valores de uno en uno en vez de todos al mismo tiempo.

Y el siguiente es un ejemplo de su uso:

t=6
z=armonica()
for j in range(t):
     print z.next()

resultando en

1.0                # 1
1.5                # 1 + 1/2
1.83333333333      # 1 + 1/2 + 1/3
2.08333333333      # 1 + 1/2 + 1/3 + 1/4
2.28333333333      # 1 + 1/2 + 1/3 + 1/4 + 1/5
2.45               # 1 + 1/2 + 1/3 + 1/4 + 1/5 + 1/6

Siendo clave la línea

print z.next()

en la que calcula el siguiente término, sin necesidad de recalcular los anteriores y sin necesidad de calcular los siguientes (al no saber cuántos se le pedirán).

Por ejemplo, si queremos generar todas las aproximaciones hasta que excedamos 3 podemos usar:

for x in armonica():
     print x
     if x >3: break

Este ejemplo es más ilustrativo, porque no sabemos ni siquiera cuántos elementos se calcularán, simplemente se calcula de uno en uno hasta obtener alguno que exceda 3. La línea for x in armonica(): está haciendo uso de que armonica() es un iterador, por lo que se puede recorrer de uno en uno como cuando se recorre range().

De vuelta al problema

Necesitamos entonces 2 cambios: usar generadores y establecer un tope (opcional) al elemento inicial, tope que es necesario para evitar obtener resultados del tipo [1, 3, 1, 1].

def particiones(n, tope=None):     # tope es un parámetro opcional
    if tope==None: tope=n          # si no está presente, la cabeza de la partición puede ser
                                   # tan grande como n mismo
    if n==1:
        yield  [1]          # dado que ya no regresamos una "lista de listas"
    elif n<1:               # sino sólo un elemento, ya no necesitamos los corchetes extra
        yield []
    else:                    # necesario pues a diferencia de return, la función no termina al
                             # al llegar a yield, sino que sólo se pausa
        for k in range(min(n,tope),0,-1):   # min(n,tope) impide que las cabezas sean mayores topes
            for cola in particiones(n-k,tope=k):  # y cada cabeza es tope de las subllamadas
                particion= [k] + cola
                yield particion

Notemos que ya no fue necesario usar variables auxiliares como listaparticiones y colas para almacenar las listas temporales, sino que el uso de generadores (yield) permite acceder a las funciones mismas como si fueran listas.

Usamos la función anterior como:

for x in particiones(5):
        print x

Obteniendo:

[5]
[4, 1]
[3, 2]
[3, 1, 1]
[2, 2, 1]
[2, 1, 1, 1]
[1, 1, 1, 1, 1]

O como en

for x in particiones(6,tope=4):
    print x

que resulta en

[4, 2]
[4, 1, 1]
[3, 3]
[3, 2, 1]
[3, 1, 1, 1]
[2, 2, 2]
[2, 2, 1, 1]
[2, 1, 1, 1, 1]
[1, 1, 1, 1, 1, 1]

Las cuales son las particiones de 6 sin elementos mayores a 4.

Toques finales

Casi estamos listos, sólo falta ahora filtrar de forma opcional aquellas particiones que tengan una longitud dada. Añadiremos un nuevo parámetro auxiliar «partes» que dirá el número de partes en que se divide n:

def particiones(n, tope=None, partes=-1):
    # sólo usaremos "partes" cuando sea positiva, por eso el valor inicial de -1
    if tope==None: tope=n
    if n==1:
        yield  [1]
    elif n<1:
        yield []
    else:
        for cabeza in range(min(n,tope),0,-1):
            for cola in particiones(n-cabeza,tope=cabeza,partes=partes-1):  # cada subllamada disminuye las partes en 1
                particion= [cabeza] + cola
                if (partes<0) or ((partes>0) and (len(particion)==partes) ):   # cuando el número de partes no importa
                                                                                # o coincide con el número de partes requerido
                    yield particion                                # devolver la partición

Dado que en cada etapa se filtran las particiones para devolver las que tienen el número de partes necesario, en las etapas más profundas de la recursión se regresan menos particiones y por tanto al construir las particiones totales al salir de las recursiones se hacen muchas menos concatenaciones, de modo que el programa corre mucho más rápido que si directamente se generaran todas y a la salida final se filtraran las que tienen el tamaño deseado.

El resultado de invocar a la función con

for x in particiones(6, partes=3):
    print x

es:

[4, 1, 1]
[3, 2, 1]
[2, 2, 2]

Podemos incluso combinar los parámetros. Así, pedimos las particiones de 10 cuya primera entrada no exceda de 6 y que tengan 4 partes:

for x in particiones(10, partes=4, tope=6):
    print x

obteniendo:

[6, 2, 1, 1]
[5, 3, 1, 1]
[5, 2, 2, 1]
[4, 4, 1, 1]
[4, 3, 2, 1]
[4, 2, 2, 2]
[3, 3, 3, 1]
[3, 3, 2, 2]

Y con eso damos por terminado el trabajo que queríamos.

Para activar la búsqueda inversa, hay que agregar

\usepackage[active]{srcltx}

en el preámbulo del documento tex. El kdvi activa sin problema la búsqueda inversa, y funciona muy bien con Kate como editor, el problema es que si se escoge Kile en las opciones de kdvi como editor, la búsqueda inversa siempre te lleva a la primera línea, lo cual realmente es inútil.

El problema se debe a una línea de comando incompleta usada por Kile para compilar el documento. La solución es ir a al menú de opciones, y en la configuración de Kile seleccionar en el árbol Tools|Build y posteriormente localizar LaTeX en el listado de comandos en la mitad de la pantalla. En la derecha aparecerá comando «latex», y las opciones son

-interaction=nonstopmode ‘%source’

Ahí se cambia la línea de las opciones a

-interaction=nonstopmode -src ‘%source’

con lo cual, al compilar los documentos, la búsqueda inversa funcionará tal y como debe.

Pasas mucho tiempo mejorando y puliendo un artículo de Wikipedia. Lo has dejado bonito. Quizás no es para destacado, pero sí lo wikificaste, lo extendiste, lo neutralizaste, le añadiste referencias. Pero en el futuro los guerreros de ediciones pueden arruinarlo. Puede llegar uno de los que buscan empujar su punto de vista y arruinar la neutralidad… uno nunca sabe.

¿Qué es Veropedia?

Veropedia (http://veropedia.com) es un proyecto que busca almacenar copias «estables» de los artículos de Wikipedia. Artículos de calidad, con referencias, neutrales, de modo que se presente siempre una copia buena de los artículos, sin guerras de edición, sin vandalismo.
Los veropedistas mejoramos artículos de Wikipedia, localizamos los artículos buenos ya existentes y los subimos a Veropedia, tales proceso se llama «veroificar» un artículo. Una vez en veropedia, los enlaces interwiki tienen 2 colores: verde y azul. Cuando el destino de un enlace ya se encuentra en Veropedia, el enlace se muestra en verde. Cuando el enlace es azul, significa que el destino aún no ha sido veroificado y por tanto el enlace te regresa a Wikipedia (donde puedes leer y mejorar el artículo).

¿Y porqué debe importarme Veropedia?

Qué bueno que preguntas, y éso es lo que quisiera platicarte en el resto de este ensayo.

Bueno, existen ya muchos clones de Wikipedia en la red. Por ejemplo, una búsqueda rápida muestra que [[es:Archivo binario]] está copiado en:

• wapedia.mobi/es/Archivo_binario
• http://www.enciclonario.com/enciclopedia/Archivo_binario
• es.wikisrc.org/wiki/Archivo_binario
• http://www.babylon.com/definition/archivo_binario/Spanish
• http://www.boonic.com/enciclopedia/69062.php
• http://www.territorioscuola.com/wiki/es.wikipedia.php?title=Archivo_binario
• http://www.dimelo.com/GS/SeeTheme.aspx?String=Archivo+binario
• astrored.org/enciclopedia/wiki/Archivo_binario
• http://www.songtranslator.net/wiki/wiki.php?title=Archivo_binario
• http://www.wiki-pedia.pl/es/wiki/Archivo_binario.html
• http://www.cetratec.org/mediawiki/index.php?title=Archivo_binario
• http://www.encyklopediapolska.pl/es/wiki/Archivo_binario.html
• http://www.oec.eu/archivo_binario_es.html
• http://www.wiki-net.pl/es/wiki/Archivo_binario.html
• es.wikimobs.com/index.php?title=archivo_binario
• etcétera….

Todos esos sitios copian el contenido de Wikipedia y lo presentan en su sitio. Incluso algunos ni siquiera mencionan que fue tomado de Wikipedia (como cetratec). Bah. Parásitos. ¿Necesitamos otro más? ¿porqué Veropedia es diferente?

En cada uno de los casos listados, se toma el trabajo y no se aporta nada de vuelta. Sí, el contenido de Wikipedia es libre para reusarse (incluso para fines comerciales, por eso se permiten los sitios anteriores). Pero ninguno de ellos le proporciona un beneficio directo a Wikipedia. Veropedia es diferente porque Veropedia fomenta la mejora de los artículos en Wikipedia.

¿Cómo ayuda Veropedia a Wikipedia?

Veropedia no busca ser simplemente un clon de Wikipedia. Dado que el objetivo de Veropedia es coleccionar artículos buenos, los Veropedistas están constantemente mejorando artículos de Wikipedia para alcanzar los estándares buscados y poderlos añadir a Veropedia. No es posible editar artículos en Veropedia para mejorarlos, necesariamente deben mejorarse en Wikipedia antes de poder añadirlos a Veropedia. De esta forma, Veropedia no es sólo una copia pasiva como las muchas existentes. Veropedia es una copia activa, fomentando que los veropedistas (que, de hecho, son wikipedistas veteranos). Mejorar Wikipedia es mejorar Wikipedia. Mejorar Wikipedia es mejorar Veropedia.

Así, Veropedia no es una copia mantenida por una empresa que sólo busca copiar el contenido de Wikipedia y obtener ganancias con la copia: Veropedia está formada por wikipedistas veteranos. A la cabeza del proyecto está Danny (Danny Wool) quien hasta el año pasado trabajaba para la Fundación Wikimedia. Los aspectos técnicos los llevan varios wikipedistas de la wiki inglesa (de donde surgió la idea), quienes participan en la Veropedia en inglés.

El compromiso que tiene Veropedia con los ideales de Wikipedia, se hace patente incluso en su portada, donde es prominente un enlace invitando a donar para apoyar a Wikipedia. ¿Cuántos clones hacen lo mismo?

Pero.. Veropedia se beneficia gratuitamente del trabajo de los Wikipedistas ¿no?

A diferencia de todos los sitios listados anteriormente, que sólo buscan un provecho comercial, Veropedia tiene por objetivo crear una copia estable de artículos buenos. Todos los sitios en los enlaces del inicio,

• copian a Wikipedia
• ponen publicidad
• se benefician de Wikipedia
• no aportan nada a Wikipedia
• no fomentan el espíritu libre
• incluso, algunos incluso tratan de ocultar el origen del contenido para aparentar que ellos mismos lo han escrito.

Veropedia:

• usa el contenido de Wikipedia
• tiene mínima o nula publicidad
• se beneficia de Wikipedia
• fomenta la mejora de artículos de Wikipedia
• fomenta el espíritu libre al atribuir claramente el origen del contenido así como la licencia
• fomenta la llegada de editores a Wikipedia

Estoy en contra del uso de mi esfuerzo para fines comerciales.

Papi, la licencia GFDL explícitamente lo permite, es parte de que el contenido sea libre. Ahora, puede usarse de forma parasitaria como los otros clones de Wikipedia, o puede usarse de forma responsable y beneficiosa para todos. Criticar a Veropedia haciéndose de la vista gorda en los clones, es simplemente criticar por criticar.

Además, si tanto te repugna, te irrita, te enoja, la posibilidad de uso comercial de tu trabajo.. ¡no colabores en Wikipedia! Mejor créate una wiki donde todo tenga derechos reservados y se te tenga que pedir autorización para reusar tu contenido. Recuerda que el contenido libre tiene 3 permisos irrevocables:

• Permiso de copia
• Permiso de modificación
• Permiso de reuso para cualquier fin (sí, hasta para usos comerciales)

Recuerda también que hay ahem, otros sitios (con ánimo de lucro y con el beneplácito de San Jimbo) que toman contenido de Wikipedia.

Bueno, me interesa Veropedia. ¿Cómo ayudo?

Lo más importante que puedes hacer para ayudar a Veropedia,
es mejorar los artículos de Wikipedia.

Sé que sueno muy repetitivo. Pero ése es el punto más importante. Es un círculo virtuoso de beneficio mutuo. El siguiente paso es obtener una cuenta en Veropedia. Entra a #veropedia en freenode, y pregúntale a Danny o a Eagle que te ayuden a sacar una cuenta. Platica con la gente del canal. Verás que todos son wikipedistas de abolengo, todos comprometidos con los principios de Wikipedia. La Veropedia en español (al momento de escribir ésto), aún no está abierta, pero sí está contemplado abrirla. Sólo estamos a la espera de que unos cuantos wikipedistas (digamos, cinco) muestren interés por participar, se comprometan a mejorar artículos de Wikipedia para subirlos al sistema, soliciten su cuenta, y entonces iniciará Veropedia en español.

Cietra unversdiad ineglsa dsecubrio que si al escrbiir las palaabrs, la pirmera y la ulitma lertas etsán en su lgaur , no improta el oerdn de las dmeas, uno peude leer «calramnete»…

Cierta universidad inglesa descurió que si al escribir las palabras, la primera y la última letras están en su lugar no importa el orden de las demás, uno puede leer «claramente» las palabras sin necesidad de mucho esfuerzo, ya que el cerebro procesa por «palabras» en lugar de letra por letra.

Nunca he escuchado que digan cuál es la universidad, ni nadie que me lo cuenta en realidad ha leído tal artículo. Sin embargo, con una demostración similar a la anterior, todo mundo queda convencido.

¿Será? Pues… ¡NO!
La afirmación es incorrecta y tiene su trampa. Cabe aclarar que ninguna de las personas que me mencionan tal hecho lo hace de mala fe, ya que viene acompañada de «eivdnceia». Así que ellos no están conscientes de la pequeña trampa que a ellos mismos les han jugado.

La afirmación es esta:
Basta que la primera y la última letra estén en posición, sin importar el orden de las demás, para que podamos reconocer «en segiuda» la palarba.
Bueno, si quiero probar que la afrimacóin es falsa, dbereía de dejar de dar eejmpols de que sí funciona.

Y sin más preámbulos…. regresar al título. ¡¡No es tan sencillo de leer!! A pesar de que la primera y la última letra están en su lugar. La pequeña trampa es que en todos los ejemplos que se han dado de muestra, las letras dseordneadas, en realidad no estaban tan desordenadas.

La afirmación sólo es cierta si el grado de desorden de la palabra es pequeño. Uno puede preguntarse cómo es que uno puede medir qué tan desordenada está una palabra, y la respuesta viene en el curso básico de teoría de grupos, ya que una palabra desordenada es, a final de cuentas, una permutación de sus letras. Y toda permutación se puede expresar como producto de transposiciones, y se le puede asignar un número mínimo de inversiones, etc…
(si a alguien le interesa, que me envíe un correo solicitando más detalles).

Así que el desorden de las letras «de enmedio» sí importa. Claro que dí muchos ejemplos que sí funcionan, y hasta ahora sólo he dado uno que no, bien podría ser la excepción. Por lo que aquí van otros ejemplos:

• ¿Cmoo eacilpxr un mrgalio en un mdnuo ddnoe tdoo tneie enoicacilpxn?
• Doreitucsin ptnemasorgilee puqroe Aromy sainetsoa que mar y amar no se paidon uazilitr para una rmia
• Y así vomas atnalede, betos que ramen crtnoa la ctneirroe, itnemetnasecne asodartsarrs hicaa el pdasao
• Los aonmuls doreidicen caibmar la fhcea de la eugertna
• Asetige aetns de usrase
• El ptneicae dtrepseó htneirbmao
• La eidepolcicna lerbie
  
• Nsetoe que en cada lenia, la rlgea se clpmue

Sí, en cada ejemplo la regla se cumple, la primera y la última letra están en posición, mientras que todas las demás están revueltas. Pero en mis ejemplos, los desórdenes no son pequeños (una o dos letras incorrectas), sino que he maximizado el número de inversiones (es decir, el mayor desórden posible) con las letras de enmedio, pero el resultado ya no se puede leer tan fácil como si estuvieran escritas correctamente, como decía la afirmación.

Claro que todos los ejemplos fueron construidos con un método, (que no es difícil de descifrar), y que conociendo el método se pueden leer los ejemplos con relativa facilidad, pero lo importante es que no se pueden leer casi igual de rápido que si estuvieran correctamente.

También hay que tomar en cuenta que en el inglés (el lenguaje original del estudio), la mayoría de las palabras son de una o dos sílabas, mientras que en español, frecuentemente aparecen palabras de 2, 3 o 4 sílabas. Y claro, si hay menos letras, el desorden posible es menor (aunque también hay contraejemplos a la afirmación en inglés, pero esa es otra historia).

Así, la afirmación correcta es:

Si en una palabra, la primera y la última letra se dejan en su posición, y las demás letras se cambian ligeramente de su posición, es posible entender la palabra sin mucho esfuerzo.

Eso ya no es tan impresionante ¿verdad? Y suena un poco tonto armar tanto alboroto por algo que es un tanto evidente.

Como postdata (con un pequeño guiño a hein?) ¿sabías que la palabra crédulo no está en el diccionario?: