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

¿Qué es un Árbol de Ejecución? 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 listSum [] = = = 3 listSum [1,2] = 4 listSum [2] = 3 Ejemplo: main = listSum [1,2] listSum [] = 1 listSum (x:xs) = x + (listSum xs)

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

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

(1) do (2) node = selectNode(T) (3) answer = askNode(node) (4) if (answer = NO) (5) then M(node) = Wrong (6) buggyNode = node (7) N = {n ∈ N | (node  n) ∈ E*} (8) else N = N \ {n ∈ N | (node  n) ∈ E*} (9) while ( ∃ n ∈ N, M(n) = Undefined) (10) return buggyNode

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

Estrategias 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 Single Stepping Hat Delta - More Wrongs Hat Delta - Less Rights Hat Delta - Best Division Top Down Hat Delta Divide & Query Single Stepping

Sesión de depuración main = sqrTest [1,2] sqrTest x = test (squares (listSum x)) test (x,y,z) = (x==y) && (y==z) listSum [] = 0 listSum (x:xs) = x + (listSum xs) 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 (partialSums x) partialSums x = [(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 con la búsqueda Top-Down - Left to Right. main = False sqrTest [1,2] = False test (9,9,8) = Falsesquares 3 = (9,9,8)listSum [1,2] = 3 squares1 3 = 9squares2 3 = 9squares3 3 = 8 listSum [2] = 2 listSum [] = 0 square 3 = 9listSum [3,3,3] = 9 listSum [3,3] = 6 listSum [3] = 3 listSum [] = 0 list 3 3 = [3,3,3] list 3 2 = [3,3] list 3 1 = [3] list 3 0 = [] listSum [6,2] = 8 listSum [2] = 2 listSum [] = 0 partialSums 3 = [6,2] sum1 3 = 6sum2 3 = 2 incr 3 = 4 decr 3 = 2 Empezando la sesión de depuración… 1)main = False? NO 2)sqrTest [1,2] = False? NO 3)test [9,9,8] = False? SI 4)squares 3 = [9,9,8]? NO 5)square1 3 = 9? SI 6)square2 3 = 9? SI 7)square3 3 = 8? NO 8)listSum [6,2] = 8? SI 9)partialSums 3 = [6,2]? NO 10) sum1 3 = 6? SI 11) sum2 3 = 2? NO 12) decr 3 = 2? SI Error encontrado en la regla: sum2 x = div (x + (decr x)) 2

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

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

,5 6, ,5 3,5 6, ,5

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

Ecuación 1: w n = Up(n’) + Down(n’) + wi n’ Ecuación 2: w n’ = Down(n’) + wi n’ x/2 x0 x/2 * x/2 0 * x Up(n’) = Down(n’) |u n’ – d n’ | < |u n’’ - d n’’ | du

(1) Candidate = root (2) do (3) Best = Candidate (4) Children = {m | (Best → m) ∈ E} (5) if (Children = ∅ ) then return Best (6) Candidate = n‘ | ∀ n’’ with n’, n’’ ∈ Children, w n’ ≥ w n’’ (7) while (w Candidate > w root /2) (8) if (M(Best) = Wrong) then return Candidate (9) if (w root ≥ w Best + w Candidate – wi root ) then return Best (10) else return Candidate

(1) Candidate = root (2) do (3) Best = Candidate (4) Children = {m | (Best → m) ∈ E} (5) if (Children = ∅ ) then return Best (6) Candidate = n‘ | ∀ n’’ with n’, n’’ ∈ Children, w n’ ≥ w n’’ (7) while (w Candidate > w root /2) (8) if (M(Best) = Wrong) then return Candidate (9) if (w root ≥ w Best + w Candidate – wi root ) then return Best (10) else return Candidate

(1) Candidate = root (2) do (3) Best = Candidate (4) Children = {m | (Best → m) ∈ E} (5) if (Children = ∅ ) then return Best (6) Candidate = n′ | ∀ n′′ with n′, n′′ ∈ Children, w n’ ≥ w n′′ (7) while ( w Candidate − wi Candidate /2 > w root /2) (8) Candidate = n‘ ∈ Children | ∀ n’’ ∈ Children, w n′ − wi n′ /2 ≥ w n′′ − wi n′′ /2 (9) if (M(Best) = Wrong) then return Candidate (10) if (w root ≥ w Best + w Candidate – wi Best /2 – wi Candidate /2) then return Best (11) else return Candidate

(1) Candidate = root (2) do (3) Best = Candidate (4) Children = {m | (Best → m) ∈ E} (5) if (Children = ∅ ) then return Best (6) Candidate = n′ | ∀ n′′ with n′, n′′ ∈ Children, w n’ ≥ w n′′ (7)while (w Candidate − wi Candidate /2 > w root /2) (8)Candidate = n‘ ∈ Children | ∀ n’’ ∈ Children, w n′ − wi n′ /2 ≥ w n′′ − wi n′′ /2 (7) if (M(Best) = Wrong) then return Candidate (8) if (w root ≥ w Best + w Candidate – wi Best /2 – wi Candidate /2) then return Best (9) else return Candidate

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

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

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

BenchmarkNodesD&QOD&QHD&QSDR&Q … Average NumReader12 28, ,36 29,59… 41,80 % Ordering46 12,04 12,0912,63 14,40… 19,88 % Factoricer 629,83 9,93 20,03… 16,94 % Sedgewich 1230,77 33,14 30,77… 38,46 % Clasifier2319,7920,3122,4021,88…28,47 % LegendGame718,87 8,9516,72…16,01 % Cues1831,5832,41 …37,60 % Romanic1236,4010,8411,2313,56…15,00 % FibRecursive4.6190,27 0,281,20…5,59 % Risk3316,78 18,0819,38…24,76 % FacTrans1983,89 3,936,22…10,06 % RndQuicksort728,73 11,41…15,19 % BinaryArrays1285,52 5,717,13…11,21 % FibFactAna3512,44 2,455,38…9,68 % NewtonPol739,06 43,7539,06…44,03 % RegresionTest1823,27 25,21 …30,45 % BoubleFib1714,404,414,5711,40…13,75 % ComplexNums6010,02 10,3211,31…16,53 % Integral544,44 47,2244,44…48,74 % TestMath4811,91 12,1612,99…20,46 % TestMath22283,51 9,73…14,57 % Figures1136,726,756,798,09…12,36 % FastCalc5910,1110,1410,4211,53…18,28 % SpaceLimits12712,9516,0719,1521,74…22,31 % Argparser12912,10 13,0820,48…18,04 % Cglib1.2161,93 2,332,12…8,12 % Kxml1.1722,86 3,013,56…9,00 % Javassist1.3574,34 5,444,49…9,59 % Average374,2113,3413,6614,5816,29…20,60 %

n1n1 n n2n2 Condiciones del árbol Condiciones del problema Prueba Condiciones generales

n1n1 n Condiciones del árbol Condiciones del problema Contradicción Condiciones generales n2n2

n1n1 n Condiciones del árbol Condiciones del problema Prueba Condiciones generales n2n2

Condiciones del árbol Condiciones del problema Prueba Condiciones generales n1n1 n n2n2 n3n3

Condiciones del árbol Condiciones del problema Prueba Condiciones generales n1n1 d n1 u n1 wi n1

Condiciones del árbol Condiciones del problema Prueba Condiciones generales n1n1 n2n2 d n1 u n1 wi n1 d n2 u n2 wi n2

Condiciones del árbol Condiciones del problema Prueba Condiciones generales n1n1 n2n2 d n1 u n1 wi n1 d n2 u n2 wi n2

Condiciones del árbol Condiciones del problema Contradicción Condiciones generales n1n1 n n2n2 d n1 u n1 wi n1 d n2 u n2 wi n2

Condiciones del árbol Condiciones del problema Contradicción Condiciones generales n1n1 n n2n2 d n1 u n1 wi n1 d n2 u n2 wi n2

Condiciones del árbol Condiciones del problema Prueba Condiciones generales n1n1 n n2n2 d n1 u n1 wi n1 d n2 u n2 wi n2

Condiciones del árbol Condiciones del problema Prueba Condiciones generales n1n1 n n2n2 d n1 u n1 wi n1 d n2 u n2 wi n2

Condiciones del árbol Condiciones del problema Prueba Condiciones generales n1n1 n n2n2 d n1 u n1 wi n1 d n3 u n3 wi n3 n3n3

Condiciones del árbol Condiciones del problema Prueba Condiciones generales n1n1 n n2n2 d n1 u n1 wi n1 d n3 u n3 wi n3 n3n3

Condiciones del árbol Condiciones del problema Contradicción Condiciones generales n1n1 n n2n2 d n1 u n1 wi n1 d n3 u n3 wi n3 n3n3

Condiciones del árbol Condiciones del problema Contradicción Condiciones generales n1n1 n n2n2 d n1 u n1 wi n1 d n3 u n3 wi n3 n3n3

Condiciones del árbol Condiciones del problema Prueba Condiciones generales n1n1 n2n2 d n1 u n1 wi n1 d n2 u n2 wi n2

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

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

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

3 n3n n4n4 5 n5n5 16 n6n6 1 6 [ n 3,n 4,n 5,n 6 ] n2n n8n n9n9 5 [ n 8,n 9 ] n7n n 10 4 [ n 2,n 7,n 10 ] 46 n1n [n 2,n 7,n 10 ] =( * 5)(8 + 2 * 3)+(1 + 3 * 1)+(4)+=46(24) + (14) + (4) + (4)= [n 7,n 2,n 10 ] =(8 + 1 * 3)( * 5)+(1 + 3 * 1)+(4)+=48(11) + (29) + (4) + (4)= [n 10,n 2,n 7 ] =(1 + 1 * 1)( * 5)+(8 + 3 * 3)+(4)+=52(2) + (29) + (17) + (4)=

(1)SP n = calcularSP(T, n) (2)spOptima = sp n ∈ SP n | ∀ sp’ n ∈ SP n, calcularQ(T, n, sp n ) ≤ calcularQ(T, n, sp’ n ) (3)QOptima = calcularQ(T, n, spOptima) (4) return (spOptima, QOptima) (1) O = {n’’ ∈ N | (n’ → n’’) ∈ E*} (2) N = N \ O (3) n’ = n’’ | (n’’ → n’) ∈ E (4) while (n’ ≠ n) (5) (_, Q n’ ) = calcularSpOptima(T, n’) (6) w n’ = w n’ - |O| (7) n’ = n’’ | (n’’ → n’) ∈ E (8) end while (9) return T n4n4 1 n5n5 1 [ n 4, n 5 ] n3n3 8 [n3][n3] n2n2 13 n7n7 1 [n7][n7] n6n6 4 [ n 3, n 6, n 2 ] n1n [n 2,n 6 ] =( * 4)+ =(17) + (8) + (3) (4 + 2 * 2) =28 +(3) [n 3,n 6,n 2 ] =(8 + 1 * 3)+ =(11) + (8) + (4) + (4) (4 + 2 * 2)+(1 + 3 * 1) =27 +(4) [ n 2, n 6, ] (1) pregAcumuladas = 1 (2) while ({n’ | (n → n’) ∈ E*} ≠ {n}) (3) nodo = sp n [indiceNodo] (4) indiceNodo = indiceNodo + 1 (5) preguntas = preguntas + (Q nodo + pregAcumuladas * w nodo ) (6) pregAcumuladas = pregAcumuladas + 1 (7) T = ajustarNodosIntermedios(T, n, nodo) (8) end while (9) preguntas = preguntas + (pregAcumuladas) (10) return preguntas

(1) O = {n’’ ∈ N | (n’ → n’’) ∈ E*} (2) N = N \ O (3) n’ = n’’ | (n’’ → n’) ∈ E (4) while (n’ ≠ n) (5) (_, Q n’ ) = calcularSpOptima(T, n’) (6) w n’ = w n’ - |O| (7) n’ = n’’ | (n’’ → n’) ∈ E (8) end while (9) return T n4n4 n5n5 n3n3 n2n2 n7n7 n6n6 n1n (1) pregAcumuladas = 1 (2) while ({n’ | (n → n’) ∈ E*} ≠ {n}) (3) nodo = sp n [indiceNodo] (4) indiceNodo = indiceNodo + 1 (5) preguntas = preguntas + (Q nodo + pregAcumuladas * w nodo ) (6) pregAcumuladas = pregAcumuladas + 1 (7) T = ajustarNodosIntermedios(T, n, nodo) (8) end while (9) preguntas = preguntas + (pregAcumuladas * wi n ) (10) return preguntas (1)SP n = calcularSP(T, n) (2)spOptima = sp n ∈ SP n | ∀ sp’ n ∈ SP n, calcularQ(T, n, sp n ) ≤ calcularQ(T, n, sp’ n ) (3)QOptima = calcularQ(T, n, spOptima) (4) return (spOptima, QOptima)

(1) pregAcumuladas = 1 (2) while ({n’ | (n → n’) ∈ E*} ≠ {n}) (3) nodo = sp n [indiceNodo] (4) indiceNodo = indiceNodo + 1 (5) preguntas = preguntas + (Q nodo + pregAcumuladas * w nodo ) (6) pregAcumuladas = pregAcumuladas + 1 (7) T = ajustarNodosIntermedios(T, n, nodo) (8) end while (9) preguntas = preguntas + (pregAcumuladas * wi n ) (10) return preguntas (1) O = {n’’ ∈ N | (n’ → n’’) ∈ E*} (2) N = N \ O (3) n’ = n’’ | (n’’ → n’) ∈ E (4) while (n’ ≠ n) (5) (_, Q n’ ) = calcularSpOptima(T, n’) (6) w n’ = w n’ - |O| (7) n’ = n’’ | (n’’ → n’) ∈ E (8) end while (9) return T n4n4 1 n5n5 1 [ n 4, n 5 ] n3n3 8 [n3][n3] n2n2 14 n7n7 n6n6 n1n , ,5 [n 3 ] = (8 + 1 * 3)+ =(11) + (3) (2 * 1,5) =14 [n 4,n 3 ] =(1 + 1 * 1)+ =(2) + (8) + (4,5) (4 + 2 * 2)+ =14,5 (3 * 1,5)

n4n4 1 n5n5 1 [ n 4, n 5 ] n3n3 8 [n3][n3] n2n2 14 n7n7 1 [n7][n7] n6n6 4 [ n 3, n 6, n 2 ] n1n , ,5 [n 2,n 6 ] =( * 4,5)+ =(18,5) + (8) + (3) (4 + 2 * 2) =29,5 +(3 * 1) [n 3,n 6,n 2 ] =(8 + 1 * 3)+ =(11) + (8) + (6) + (4) (4 + 2 * 2)+(1,5 + 3 * 1,5) =29 +(4 * 1) [ n 2, n 6, ] (1) O = {n’’ ∈ N | (n’ → n’’) ∈ E*} (2) N = N \ O (3) n’ = n’’ | (n’’ → n’) ∈ E (4) while (n’ ≠ n) (5) (_, Q n’ ) = calcularSpOptima(T, n’) (6) w n’ = w n’ - |O| (7) n’ = n’’ | (n’’ → n’) ∈ E (8) end while (9) return T (1) pregAcumuladas = 1 (2) while ({n’ | (n → n’) ∈ E*} ≠ {n}) (3) nodo = sp n [indiceNodo] (4) indiceNodo = indiceNodo + 1 (5) preguntas = preguntas + (Q nodo + pregAcumuladas * w nodo ) (6) pregAcumuladas = pregAcumuladas + 1 (7) T = ajustarNodosIntermedios(T, n, nodo) (8) end while (9) preguntas = preguntas + (pregAcumuladas * wi n ) (10) return preguntas

(1) tiempoAcumulado = ti n (2) while ({n’ | (n → n’) ∈ E*} ≠ {n}) (3) nodo = sp n [indiceNodo] (4) indiceNodo = indiceNodo + 1 (5) preguntas = preguntas + (Q nodo + tiempoAcumulado * w nodo ) (6) tiempoAcumulado = tiempoAcumulado + ti nodo (7) T = ajustarNodosIntermedios(T, n, nodo) (8) end while (9) preguntas = preguntas + (tiempoAcumulado) (10) return preguntas (1) O = {n’’ ∈ N | (n’ → n’’) ∈ E*} (2) N = N \ O (3) n’ = n’’ | (n’’ → n’) ∈ E (4) while (n’ ≠ n) (5) (_, Q n’ ) = calcularSpOptima(T, n’) (6) w n’ = w n’ - |O| (7) n’ = n’’ | (n’’ → n’) ∈ E (8) end while (9) return T n4n4 n5n5 n3n3 n2n2 n7n7 n6n6 n1n | (1)SP n = calcularSP(T, n) (2)spOptima = sp n ∈ SP n | ∀ sp’ n ∈ SP n, calcularQ(T, n, sp n ) ≤ calcularQ(T, n, sp’ n ) (3)QOptima = calcularQ(T, n, spOptima) (4) return (spOptima, QOptima)

(1) tiempoAcumulado = ti n (2) while ({n’ | (n → n’) ∈ E*} ≠ {n}) (3) nodo = sp n [indiceNodo] (4) indiceNodo = indiceNodo + 1 (5) preguntas = preguntas + (Q nodo + tiempoAcumulado * w nodo ) (6) tiempoAcumulado = tiempoAcumulado + ti nodo (7) T = ajustarNodosIntermedios(T, n, nodo) (8) end while (9) preguntas = preguntas + (tiempoAcumulado) (10) return preguntas (1) O = {n’’ ∈ N | (n’ → n’’) ∈ E*} (2) N = N \ O (3) n’ = n’’ | (n’’ → n’) ∈ E (4) while (n’ ≠ n) (5) (_, Q n’ ) = calcularSpOptima(T, n’) (6) w n’ = w n’ - |O| (7) n’ = n’’ | (n’’ → n’) ∈ E (8) end while (9) return T n4n4 1 n5n5 1 [ n 4, n 5 ] n3n3 8 [n3][n3] n2n2 17 n7n7 n6n6 n1n | [n 3 ] = (8 + 2 * 3)+ =(14) + (3) (3) =17 [n 4,n 3 ] =(1 + 2 * 1)+ =(3) + (10) + (4) (4 + 3 * 2)+ =17 (4)

n4n4 1 n5n5 1 [ n 4, n 5 ] n3n3 8 [n3][n3] n2n2 17 n7n7 1 [n7][n7] n6n6 4 [ n 3, n 6, n 2 ] n1n | [n 2,n 6 ] =( * 4)+ =(21) + (10) + (4) (4 + 3 * 2) =35 +(4) [n 3,n 6,n 2 ] =(8 + 1 * 3)+ =(11) + (8) + (5) + (5) (4 + 2 * 2)+(2 + 3 * 1) =29 +(5) [ n 2, n 6, ] (1) O = {n’’ ∈ N | (n’ → n’’) ∈ E*} (2) N = N \ O (3) n’ = n’’ | (n’’ → n’) ∈ E (4) while (n’ ≠ n) (5) (_, Q n’ ) = calcularSpOptima(T, n’) (6) w n’ = w n’ - |O| (7) n’ = n’’ | (n’’ → n’) ∈ E (8) end while (9) return T (1) tiempoAcumulado = ti n (2) while ({n’ | (n → n’) ∈ E*} ≠ {n}) (3) nodo = sp n [indiceNodo] (4) indiceNodo = indiceNodo + 1 (5) preguntas = preguntas + (Q nodo + tiempoAcumulado * w nodo ) (6) tiempoAcumulado = tiempoAcumulado + ti nodo (7) T = ajustarNodosIntermedios(T, n, nodo) (8) end while (9) preguntas = preguntas + (tiempoAcumulado) (10) return preguntas

(1) tiempoAcumulado = ti n (2) while ({n’ | (n → n’) ∈ E*} ≠ {n}) (3) nodo = sp n [indiceNodo] (4) indiceNodo = indiceNodo + 1 (5) preguntas = preguntas + (Q nodo + tiempoAcumulado * w nodo ) (6) tiempoAcumulado = tiempoAcumulado + ti nodo (7) T = ajustarNodosIntermedios(T, n, nodo) (8) end while (9) preguntas = preguntas + (tiempoAcumulado * wi n ) (10) return preguntas (1) O = {n’’ ∈ N | (n’ → n’’) ∈ E*} (2) N = N \ O (3) n’ = n’’ | (n’’ → n’) ∈ E (4) while (n’ ≠ n) (5) (_, Q n’ ) = calcularSpOptima(T, n’) (6) w n’ = w n’ - |O| (7) n’ = n’’ | (n’’ → n’) ∈ E (8) end while (9) return T n4n4 n5n5 n3n3 n2n2 n7n7 n6n6 n1n | (1)SP n = calcularSP(T, n) (2)spOptima = sp n ∈ SP n | ∀ sp’ n ∈ SP n, calcularQ(T, n, sp n ) ≤ calcularQ(T, n, sp’ n ) (3)QOptima = calcularQ(T, n, spOptima) (4) return (spOptima, QOptima)

(1) tiempoAcumulado = ti n (2) while ({n’ | (n → n’) ∈ E*} ≠ {n}) (3) nodo = sp n [indiceNodo] (4) indiceNodo = indiceNodo + 1 (5) preguntas = preguntas + (Q nodo + tiempoAcumulado * w nodo ) (6) tiempoAcumulado = tiempoAcumulado + ti nodo (7) T = ajustarNodosIntermedios(T, n, nodo) (8) end while (9) preguntas = preguntas + (tiempoAcumulado * wi n ) (10) return preguntas (1) O = {n’’ ∈ N | (n’ → n’’) ∈ E*} (2) N = N \ O (3) n’ = n’’ | (n’’ → n’) ∈ E (4) while (n’ ≠ n) (5) (_, Q n’ ) = calcularSpOptima(T, n’) (6) w n’ = w n’ - |O| (7) n’ = n’’ | (n’’ → n’) ∈ E (8) end while (9) return T n4n4 1 n5n5 1 [ n 4, n 5 ] n3n3 8 [n3][n3] n2n2 23 n7n7 n6n6 n1n | [n 3 ] = (8 + 2 * 3)+ =(14) + (9) (3 * 3) =23 [n 4,n 3 ] =(1 + 2 * 1)+ =(3) + (10) + (12) (4 + 3 * 2)+ =25 (4 * 3)

n4n4 1 n5n5 1 [ n 4, n 5 ] n3n3 8 [n3][n3] n2n2 23 n7n7 1 [n7][n7] n6n6 4 [ n 3, n 6, n 2 ] n1n | [n 2,n 6 ] =( * 6)+ =(29) + (10) + (4) (4 + 3 * 2) =43 +(4 * 1) [n 3,n 6,n 2 ] =(8 + 1 * 3)+ =(11) + (8) + (15) + (5) (4 + 2 * 2)+(6 + 3 * 3) =39 +(5 * 1) [ n 2, n 6, ] (1) O = {n’’ ∈ N | (n’ → n’’) ∈ E*} (2) N = N \ O (3) n’ = n’’ | (n’’ → n’) ∈ E (4) while (n’ ≠ n) (5) (_, Q n’ ) = calcularSpOptima(T, n’) (6) w n’ = w n’ - |O| (7) n’ = n’’ | (n’’ → n’) ∈ E (8) end while (9) return T (1) tiempoAcumulado = ti n (2) while ({n’ | (n → n’) ∈ E*} ≠ {n}) (3) nodo = sp n [indiceNodo] (4) indiceNodo = indiceNodo + 1 (5) preguntas = preguntas + (Q nodo + tiempoAcumulado * w nodo ) (6) tiempoAcumulado = tiempoAcumulado + ti nodo (7) T = ajustarNodosIntermedios(T, n, nodo) (8) end while (9) preguntas = preguntas + (tiempoAcumulado * wi n ) (10) return preguntas

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

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