viewof cambios = segmentado("cambios máximos", [1, 2, 3], 3)
viewof margen = segmentado("margen", [0, 1], 1)El solver como verificador de la percepción en KenKen desde imagen
Grupo 3 · Tópicos en Ciencias de la Computación · UPC
9 de octubre de 2026
Son dos tareas distintas que fallan de forma distinta: percibir el tablero y razonar sobre él.

Foto real, tomada con el celular a una pantalla.
Percibir
Tamaño, jaulas y etiquetas. Falla como falla una foto: luz, perspectiva, un ÷ que parece +.
Razonar
Un modelo de restricciones en CP-SAT. Exacto sobre la instancia que recibe.
Si la visión lee un 5 donde hay un 6, el solver resuelve con exactitud el puzzle equivocado.
¿Qué sobrevive a una lectura equivocada?
Leer bien el 97% de las etiquetas significa acertar unos 7 de cada 10 tableros completos.
La visión y el solver solo se comunican a través de la instancia.
1 · La app toma la foto y la envía en JSON. adb reverse la lleva por USB o Wi-Fi a la PC, sin abrir puertos.
2 · El nodo de cómputo (FastAPI) atiende POST /resolver en el puerto 8723.
3 · La Fase 1 reconstruye el tablero sin aprendizaje: tamaño, jaulas y etiquetas.
4 · La instancia es el contrato: lo único que la Fase 2 llega a ver.
5 · CP-SAT resuelve y cuenta soluciones, con tope de dos.
6 · Con una, se devuelve. Con ninguna, el solver intenta reparar la lectura. Con varias, se rechaza.
7 · La respuesta vuelve a la app: estado, solución, correcciones y dónde cae cada celda en la foto.
Umbral, contorno y homografía. Todo lo que sigue trabaja sobre la imagen enderezada.


Se prueba cada n posible: el correcto es el mayor cuyas líneas existen todas.
Toca cualquier n para probarlo.
Los bordes de jaula se imprimen más gruesos: basta medir el grosor de cada arista.

Los 17 recortes reales de la foto, con lo que leyó la visión debajo de cada uno.
Aquí, los puntos del ÷ se fundieron con la barra y la visión leyó 3+ dos veces. La instancia sigue siendo válida: nada en la Fase 1 puede saberlo.
Cada carácter se compara con plantillas dibujadas en 7 tipografías, y gana la más parecida.
Un modelo genérico en CP-SAT: sirve para cualquier tamaño y cualquier tablero.
def construir_modelo(inst):
n, m = inst.size, cp_model.CpModel()
x = [[m.NewIntVar(1, n, f"x{r}{c}") for c in range(n)]
for r in range(n)]
# cuadrado latino: 2n restricciones globales
for i in range(n):
m.AddAllDifferent(x[i])
m.AddAllDifferent([x[j][i] for j in range(n)])
# una restricción por jaula
for k, jaula in enumerate(inst.cages):
v, T = [x[r][c] for r, c in jaula.cells], jaula.target
if jaula.op == "=": m.Add(v[0] == T)
elif jaula.op == "+": m.Add(sum(v) == T)
elif jaula.op == "*": m.AddMultiplicationEquality(T, v)
else: # − y ÷: el orden de las celdas no importa
M = m.NewIntVar(1, n, f"M{k}")
mi = m.NewIntVar(1, n, f"m{k}")
m.AddMaxEquality(M, v)
m.AddMinEquality(mi, v)
m.Add(M - mi == T if jaula.op == "-" else M == T * mi)
return m, xkenken_cp/solver.py, condensado. Lo escribió el equipo, sin asistencia de IA.
\(x_{i,j} \in \{1,\dots,n\}\)
AllDifferent por fila y columna: \(2n\) restricciones globales.
Jaulas: \(=\), \(\sum\), \(\prod\) y, para \(-\) y \(\div\), el par \(\max/\min\): simétrico y sin booleanos.
El modelo es \(O(n^2)\), pero completar un cuadrado latino ya es NP-completo. En la práctica, la propagación basta: ningún tablero real ramifica.
Un puzzle publicado tiene una sola solución. Contarlas dice si lo que leyó la visión es confiable.
1
Una solución
La lectura es consistente. Se devuelve.
0
Ninguna
El solver demuestra que algo se leyó mal. Se intenta reparar.
≥ 2
Varias
La lectura no basta para decidir. Se rechaza, en llano.
Si no hay solución, el solver prueba lecturas parecidas hasta dar con la única que funciona.
for k, (jaula, cands) in enumerate(zip(inst.cages, opciones)):
lits = [] # cands: lo leído (peso 0) y alternativas
for j, (op, t, w) in enumerate(cands):
ell = m.NewBoolVar(f"l{k}_{j}")
if op == "+": m.Add(suma == t).OnlyEnforceIf(ell)
elif op == "*": m.Add(prod == t).OnlyEnforceIf(ell)
elif op == "-": m.Add(M - mi == t).OnlyEnforceIf(ell)
elif op == "/": m.Add(M == t * mi).OnlyEnforceIf(ell)
lits.append(ell)
if j > 0: # primero cambios; luego, plausibilidad
cambios.append(ell)
peso.append((100 + w) * ell)
m.AddExactlyOne(lits)
m.Add(sum(cambios) <= max_cambios)
m.Minimize(sum(peso))kenken_cp/reparar.py, condensado.
\[\ell_{k,c} \Rightarrow \textit{jaula}_k(c) \qquad \textstyle\sum_c \ell_{k,c} = 1\]
La visión leyó dos 3÷ como 3+. El solver lo detectó y lo corrigió.

Tableros reales de KrazyDad, con la respuesta correcta sacada del propio PDF.
72
tableros reales de KrazyDad: 48 de 4×4, 16 de 6×6 y 8 de 9×9
895
etiquetas, cada una con su verdad exacta
5
cuadernillos: dos para desarrollar, tres que nadie miró
0
etiquetas puestas a mano
Los PDF son vectoriales: cada etiqueta está como texto con su caja. Proyectada con la homografía del tablero, da su celda. La celda sale de la geometría, no del detector, así que el detector no se mide contra sí mismo.
KrazyDad autoriza el uso escolar y prohíbe el comercial. Los PDF se descargan bajo demanda y no se redistribuyen.
Acertamos el 97% de 895 etiquetas, y 4 de cada 5 errores son el mismo: un 5 leído como 6.
97.09% de 895 etiquetas, κ de Cohen 0.969: «casi perfecto».
En los cuadernillos que nadie miró, 96.45% (p = 0.24 frente a desarrollo). Pero el fallo cambia: 16 de sus 17 errores son 5+ → 6+.
Ningún tablero mal leído terminó en una solución equivocada.
Solo si ninguna otra corrección parecida lleva a otro tablero. Prueba los parámetros.
function segmentado(rotulo, opciones, inicial) {
const raiz = document.createElement("div");
const et = document.createElement("span");
et.className = "control"; et.textContent = rotulo;
const grupo = document.createElement("div");
grupo.className = "segmentado";
raiz.append(et, grupo);
raiz.value = inicial;
for (const op of opciones) {
const b = document.createElement("button");
b.textContent = op;
b.setAttribute("aria-pressed", op === inicial);
b.onclick = () => {
raiz.value = op;
grupo.querySelectorAll("button").forEach(x => x.setAttribute("aria-pressed", x === b));
raiz.dispatchEvent(new Event("input", {bubbles: true}));
};
grupo.append(b);
}
return raiz;
}viewof cambios = segmentado("cambios máximos", [1, 2, 3], 3)
viewof margen = segmentado("margen", [0, 1], 1)Las 19 lecturas reales sin solución, reparadas con distintos parámetros.
La primera versión aceptaba la corrección mínima si era única de su tamaño (margen 0). En un 4×4 con dos 5+ leídos como 6+, arreglar uno solo ya cerraba el tablero, pero con otra solución.
Ahora se exige que ninguna corrección con un cambio más lleve a otro tablero. Si dos explicaciones son casi igual de plausibles, el nodo se abstiene.
Con restricciones globales, ningún tablero real necesita búsqueda.
9×9, mediana: 7.7 ms → 81.9 ms. Diez veces más.
Las 19 lecturas sin solución también se refutan sin ramificar.
Sirvieron para desarrollar, pero hacen creer que leemos mejor de lo que leemos.
El pipeline falló en los 16 primeros tableros reales: la rejilla se interrumpe, la tinta no cae en el píxel predicho, un margen fijo cortaba los dígitos y KrazyDad imprime glifos que el banco no tenía.
Muestra lo que decidió el solver, incluida la corrección.
uv run python -m kenken_nodo
adb reverse tcp:8723 tcp:8723
Leerlo y resolverlo tomó 111 ms.

Respaldo por si falla la demo en vivo: 1 min 27 s. Toca un capítulo para saltar.
La visión clásica lee bien
97.09% de 895 etiquetas sin aprendizaje. Su error se concentra en un par de glifos.
El solver verifica y repara
Contar soluciones frenó los 22 tableros mal leídos. La reificación reparó 16 de 19. Cero errores silenciosos.
Lo sintético no basta
Sirvió para construir. Las cifras que valen son las de tableros reales que nadie miró.
El solver no solo resuelve el puzzle: es el control de calidad de lo que la visión cree haber leído.
Rody Vilchez · José Villanueva · Jorge Garcia
Código: github.com/R0SEWT/cs-topics, en labs/tb1-kenken
Informe y fotos: release TB1 - KenKen
Estas diapositivas: kenken.rosewt.dev
Dataset de fotos: huggingface.co/datasets/rosewt/kenken-tb1-fotos
Usamos IA generativa (Claude Code) en el andamiaje de la visión, los scripts de medición, el informe y estas diapositivas. El modelo de CP lo escribió el equipo. Todas las cifras salen de scripts del repositorio y el equipo las revisó.
Release con el informe en PDF
Exactitud (%) sobre las 412 etiquetas del conjunto de desarrollo. «Plantillas» es nuestro método: correlación normalizada contra los caracteres dibujados en 7 tipografías.
| Método | Etiqueta | Operación | Número |
|---|---|---|---|
| Plantillas (este trabajo) | 98.8 | 99.3 | 98.8 |
| Tesseract 5.3.4 | 97.1 | 97.8 | 97.8 |
| RapidOCR (PP-OCR) | 64.8 | 68.4 | 94.2 |
| TrOCR base printed | 60.9 | 63.6 | 95.1 |
«Etiqueta» exige número y operación correctos; «Operación» y «Número» miden cada parte por separado.
Plantillas frente a Tesseract: discrepan en 11 etiquetas, 9 a favor de las plantillas (McNemar, p = 0.065). Al menos uno de los dos acierta 411 de 412. Es una cota optimista: se midió sobre el conjunto con que se ajustaron las plantillas.
resolver sobre la verdad de los 70 tableros (ms): el solver no es el cuello de botella.
| n | Tableros | Mediana | Máximo |
|---|---|---|---|
| 4 | 47 | 4.4 | 7.8 |
| 6 | 16 | 4.1 | 5.1 |
| 9 | 7 | 10.8 | 14.1 |
Sobre lo que el sistema lee, incluidas las instancias sin solución, el máximo es 20.4 ms. Intel Core Ultra 7 255U, OR-Tools 9.15, Python 3.13. La reparación tarda menos de 200 ms por tablero.
KenKen desde imagen · Grupo 3