Optimal Divide & Query

Optimal Divide & Query David Insa Cabrera

Contenido Introducción Depuración Algorítmica Divide & Query Limitaciones de Divide & Query Optimal Divide & Query Demostración DDJ Conclusiones

Depuración Algorítmica • Depuración algorítmica[Shapiro 82]Paradigma Lógico • DOS FASES: • Generar el árbol de ejecución • Recorrer el árbol de ejecución haciendo preguntas hasta encontrar el error Si se detecta el efecto de un error entonces la DA encontrará el error main = 4 ¿Qué es un Árbol de Ejecución? listSum [1,2] = 4 Ejemplo: main = listSum [1,2] listSum [] = 1 listSum (x:xs) = x + (listSumxs) 1+3 = 4 listSum [2] = 3 2+1 = 3 listSum [] = 1

Depuración Algorítmica • Recorriendo el árbol de ejecución • REGLA DE ORO: Cuando un nodo incorrecto no tiene hijos incorrectos, entonces este nodo es erróneo. main = 4 listSum [1,2] = 4 Ejemplo: main = listSum [1,2] listSum [] = 1 listSum (x:xs) = x + (listSumxs) 1+3 = 4 listSum [2] = 3 2+1 = 3 listSum [] = 1

Depuración Algorítmica • Recorriendo el árbol de ejecución • REGLA DE ORO: Cuando un nodo incorrecto no tiene hijos incorrectos, entonces este nodo es erróneo. main = 5 listSum [1,2] = 5 Ejemplo: main = listSum [1,2] listSum [] = 0 listSum (x:xs) = x + (listSumxs) + 1 1+3+1 = 5 listSum [2] = 3 2+0+1 = 3 listSum [] = 0

Depuración Algorítmica • do • node = selectNode(T) • answer = askNode(node) • if (answer = NO) • then M(node) = Wrong • buggyNode = node • N = {n ∈ N | (node n) ∈ E*} • elseN = N \ {n ∈N | (noden) ∈E*} • while (∃n ∈N, M(n) = Undefined) • returnbuggyNode

Contenido Introducción Depuración Algorítmica • Estrategias de la DA Divide & Query • Sesión de depuración Limitaciones de Divide & Query Optimal Divide & Query Demostración DDJ Conclusiones

Estrategias de la Depuración Algorítmica Estrategias Single Stepping Single Stepping Divide & Query Top Down Top Down - Left to Right Top Down - Heaviest First Top Down - More Rules First Divide & Query (by Shapiro) Divide & Query (by Hirunkitti) Divide by Rules & Query Hat Delta Hat Delta - More Wrongs Hat Delta - Less Rights Hat Delta - Best Division

Sesión de depuración Sesión de depuración main = sqrTest[1,2] sqrTestx = test (squares (listSumx)) test (x,y,z) = (x==y) && (y==z) listSum[] = 0 listSum(x:xs) = x + (listSumxs) squares x = ((square1 x),(square2 x),(square3 x)) square1 x = square x square x = x*x square2 x = listSum(list x x) list x y | y==0 = [] | otherwise = x:list x (y-1) square3 x = listSum(partialSumsx) partialSumsx = [(sum1 x),(sum2 x)] sum1 x = div (x * (incr x)) 2 sum2 x = div (x + (decr x)) 2 incr x = x + 1 decr x = x - 1

Sesión de depuración Sesión de depuración con la búsqueda Divide & Query(byHirunkitti). main = False Empezando la sesión de depuración… square2 3 = 9? SI square3 3 = 8? NO partialSums 3 = [6,2]? NO sum1 3 = 6? SI sum2 3 = 2? NO decr 3 = 2? SI Error encontrado en la regla: sum2 x = div (x + (decr x)) 2 sqrTest [1,2] = False test (9,9,8) = False squares 3 = (9,9,8) listSum [1,2] = 3 listSum [2] = 2 squares1 3 = 9 squares2 3 = 9 squares3 3 = 8 listSum [] = 0 square 3 = 9 listSum [3,3,3] = 9 list 3 3 = [3,3,3] partialSums 3 = [6,2] listSum [6,2] = 8 listSum [3,3] = 6 list 3 2 = [3,3] listSum [2] = 2 sum1 3 = 6 sum2 3 = 2 decr 3 = 2 listSum [3] = 3 list 3 1 = [3] listSum [] = 0 incr 3 = 4 listSum [] = 0 list 3 0 = []

Contraejemplo 1 3 2 8 1 3 3 3 3 3 2 5 1 1 1 1 1 2 2 2 2 2 2 4 1 1 1 1 1 1 2 1 1 1 1 1 1 9 8

Contraejemplo 2 3 2 5 5 3 2 4 4 3 3 2 1 2 1 2 3 3 3 1 1 2 3 16 16

Limitaciones 6 6,5 6 6,5 3 2 3,5 2 3 2 3,5 2 1 1 1 1 2 2,5 2 2,5 1 1 1 1

Up y Down Up(n’) = Down(n’) |un’ – dn’| < |un’’- dn’’| 8 6 2 x/2 * x/2 4 1 1 0 * x d u 0 x x/2 2 1 1 Ecuación 1: wn = Up(n’) + Down(n’) + win’ Ecuación 2: wn’ = Down(n’) + win’

Ecuación

Ecuación 8 6 2 4 1 1 2 1 1

Camino 7 7 7 7 5 2 5 2 5 2 5 2 1 1 1 1 4 4 4 4 3 3 3 3 1 1 1 1 1 1 1 1 Caso 2 Caso 4 Caso 1 Caso 3

Algoritmo Candidate = root do Best = Candidate Children = {m | (Best→m) ∈E} if (Children =∅) thenreturn Best Candidate = n‘ | ∀n’’ with n’, n’’ ∈ Children, wn’ ≥ wn’’ while (wCandidate > wroot/2) if (M(Best) = Wrong) thenreturnCandidate if(wroot ≥ wBest + wCandidate – wiroot) thenreturnBest elsereturnCandidate

Algoritmo Candidate = root do Best = Candidate Children = {m | (Best→m) ∈E} if (Children =∅) thenreturn Best Candidate = n‘ | ∀n’’ with n’, n’’ ∈ Children, wn’ ≥ wn’’ while (wCandidate > wroot/2) if (M(Best) = Wrong) thenreturnCandidate if(wroot ≥ wBest + wCandidate – wiroot) thenreturnBest elsereturnCandidate 20 8 5 2 12 1 3 11 12 8 3 4 1 1 5 7 2 5 1 1 2 1 1 1 4 1 1 1

Algoritmo general Candidate = root do Best = Candidate Children = {m | (Best→m) ∈E} if (Children =∅) thenreturn Best Candidate = n′ |∀n′′ withn′ , n′′ ∈Children, wn’ ≥ wn′′ while (wCandidate− wiCandidate/2 > wroot/2) Candidate = n‘ ∈ Children | ∀n’’ ∈ Children, wn′ − win′/2 ≥ wn′′ − win′′/2 if (M(Best) = Wrong) thenreturnCandidate if (wroot ≥ wBest + wCandidate – wiBest/2 – wiCandidate/2) thenreturnBest elsereturnCandidate

Demostración 7 17 1 5 10 2 2 2 7 1 2 4 1 1 1 1 1 1

Conclusiones Adaptación de Divide & Query a nuevas situaciones Raíz marcada como Undefined Peso individual variable 6 6,5 6 6,5 Algoritmo para cada tipo de árbol Completitud 3 2 3,5 2 3 2 3,5 2 1 1 1 1 2 2,5 2 2,5 1 1 1 1

Conclusiones

Divide byQueries David Insa Cabrera

Contenido Introducción Depuración Algorítmica Divide & Query Limitaciones de Divide & Query Divide byQueries Conclusiones y trabajo futuro

Contraejemplo 1 9 9 3 2 4 4 4 4 4 5 3 3 1 1 3 1 1 1 3 1 4 2 3 4 3 3 4 5 2 2 4 3 1 1 3 3 31 30

Contraejemplo 2 16 3 8 6 1 4 7 3 2 1 1 1 1 1 4 1 4 7 5 6 4 4 4 3 1 2 1 70 4 4 4 16 5 1 4 8 6 1 5 6 5 2 1 1 1 1 1 4 1 4 6 4 5 3 4 5 2 1 2 1 70 4 4 4 1 4

Secuencia n1 [n2,n7,n10] 10 46 4 n2 [n3,n4,n5,n6] n7 [n8,n9] n10 5 3 1 19 6 6 5 8 5 3 5 1 4 1 n3 n8 n5 n4 4 n9 n6 1 1 1 1 1 1 2 4 5 1 1 5 1 6 1 4 3 3 1 1 1 1 5 4 1 3 1 2 4 4 5 6 5 3 +1 +2 +3 [n2,n7,n10] = (19 + 1 * 5) + (8 + 2 * 3) + (1 + 3 * 1) + (4) = (24) + (14) + (4) + (4) = 46 [n7,n2,n10] = (8 + 1 * 3) + (19 + 2 * 5) + (1 + 3 * 1) + (4) = (11) + (29) + (4) + (4) = 48 [n10,n2,n7] = (1 + 1 * 1) + (19 + 2 * 5) + (8 + 3 * 3) + (4) = (2) + (29) + (17) + (4) = 52

Algoritmos SPn = calcularSP(T, n) spOptima = spn∈SPn| ∀sp’n∈SPn, calcularQ(T, n, spn) ≤ calcularQ(T, n, sp’n) QOptima = calcularQ(T, n, spOptima) return (spOptima, QOptima) n1 [n3, n6, n2] [n2, n6,] 7 27 +3 n2 n6 [n3] [n7] 4 2 pregAcumuladas = 1 while ({n’ | (n → n’) ∈ E*} ≠ {n}) nodo = spn[indiceNodo] indiceNodo = indiceNodo + 1 preguntas = preguntas + (Qnodo + pregAcumuladas * wnodo) pregAcumuladas = pregAcumuladas + 1 T = ajustarNodosIntermedios(T, n, nodo) endwhile preguntas = preguntas + (pregAcumuladas) return preguntas +2 13 4 n3 n7 +1 [n4, n5] 3 1 8 1 n5 n4 1 1 1 1 O = {n’’ ∈ N | (n’ → n’’)∈ E*} N = N \ O n’ = n’’ | (n’’ → n’) ∈ E while (n’ ≠ n) (_, Qn’) = calcularSpOptima(T, n’) wn’ = wn’ - |O| n’ = n’’ | (n’’ → n’) ∈ E endwhile return T [n2,n6] = (13 + 1 * 4) + (4 + 2 * 2) + (3) = (17) + (8) + (3) = 28 [n3,n6,n2] = (8 + 1 * 3) + (4 + 2 * 2) + (1 + 3 * 1) + (4) = (11) + (8) + (4) + (4) = 27

Algoritmos SPn = calcularSP(T, n) spOptima = spn∈SPn| ∀sp’n∈SPn, calcularQ(T, n, spn) ≤ calcularQ(T, n, sp’n) QOptima = calcularQ(T, n, spOptima) return (spOptima, QOptima) n1 9 n2 n6 6|2 2 tiempoAcumulado = tin while ({n’ | (n → n’) ∈ E*} ≠ {n}) nodo = spn[indiceNodo] indiceNodo = indiceNodo + 1 preguntas = preguntas + (Qnodo + tiempoAcumulado * wnodo) tiempoAcumulado = tiempoAcumulado + tinodo T = ajustarNodosIntermedios(T, n, nodo) endwhile preguntas = preguntas + (tiempoAcumulado * win) return preguntas n3 n7 3 1 n5 n4 1 1 O = {n’’ ∈ N | (n’ → n’’)∈ E*} N = N \ O n’ = n’’ | (n’’ → n’) ∈ E while (n’ ≠ n) (_, Qn’) = calcularSpOptima(T, n’) wn’ = wn’ - |O| n’ = n’’ | (n’’ → n’) ∈ E endwhile return T

Conclusiones Demostración de que Divide & Query no es óptima Encontrar los nodos óptimos es un problema decidible Primera versión de una estrategia óptima Probabilidad de cada nodo de ser buggy Tiempo en contestar cada nodo Construcción composicional Trabajo futuro Buscar un método para reducir la cantidad de secuencias posibles Aproximar la probabilidad de que los nodos sean incorrectos Obtener un método para aproximar la dificultad de las preguntas

Optimal Divide & Query