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

Presentación del tema: "Introducción Depuración Algorítmica Divide & Query Limitaciones de Divide & Query Optimal Divide & Query Demostración DDJ Conclusiones."— Transcripción de la presentación:

1

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

3 ¿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 [] = 1 1+3 = 4 2+1 = 3 listSum [1,2] = 4 listSum [2] = 3 Ejemplo: main = listSum [1,2] listSum [] = 1 listSum (x:xs) = x + (listSum xs)

4 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 [] = 1 1+3 = 4 2+1 = 3 listSum [1,2] = 4 listSum [2] = 3

5 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 [] = 0 1+3+1 = 5 2+0+1 = 3 listSum [1,2] = 5 listSum [2] = 3

6 (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

7 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

8 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

9 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

10 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

11 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

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

13 2 3 1 2 3 1 2 3 1 2 3 1 4 1 8 11 5 11 1 2 3 2 2 2 32 98 1 11 1 1 1 11

14 4 21 5 1 2 23 3 3 3 4 21 5 1 3 33 3 2 2 16

15 3 6 2 1 1 2 3 6 2 1 1 2 3,5 6,5 2 1 1 2,5 3,5 6,5 2 1 1 2,5

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

17 8 62 141 21 1 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

18

19 8 62 141 21 1

20 5 7 2 1 3 11 4 5 7 2 1 3 11 4 5 7 2 1 3 11 4 5 7 2 1 3 11 4

21 (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

22 (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 2 2 8 8 5 5 1 1 12 3 3 20 5 5 4 4 1 1 1 1 2 2 1 1 1 1 4 4 1 1 1 1 1 1 2 2 1 1 7 12 1 5 11 8 1 3

23 (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

24 6.5 14 6.6 20 6 6 1 1 2 2 2 2 5 5 1 1 1 1 2 2 1.5 6 6 3 3 2 2 1 1 1 1 1 1 6.5 13.5 0 6 13.4 0.6 13.1 6 0.9 (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 77.4 7.1

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

26 7 7 10 2 2 17 4 4 2 2 1 1 5 5 2 2 2 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 7 7

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

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

29 BenchmarkNodesD&QOD&QHD&QSDR&Q … Average NumReader12 28,99 28.9931,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 %

30

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

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

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

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

35

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

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

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

39 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

40 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

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

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

43 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

44 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

45 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

46 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

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

48

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

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

51 3 3 3 3 3 45 5 2 1 1 1 1 1 1 4 4 9 9 4 4 3 3 2 2 1 1 31 3 4 4 3 2 34 4 3 1 1 1 1 1 1 4 4 9 9 4 4 3 3 2 2 1 1 30

52 4 4 4 4 44 4 4 3 4 5 73 3 6 7 1 1 1 1 1 1 6 6 16 8 8 4 4 2 2 1 1 1 1 2 2 1 1 1 1 1 1 1 1 1 1 4 4 4 4 45 5 4 2 3 4 65 5 5 6 1 1 1 1 1 1 6 6 8 8 4 4 2 2 1 1 1 1 2 2 1 1 1 1 1 1 1 1 1 1 70

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

54 3 n3n3 1 4 1 n4n4 5 n5n5 16 n6n6 1 6 [ n 3,n 4,n 5,n 6 ] n2n2 19 4 n8n8 1 5 1 n9n9 5 [ n 8,n 9 ] n7n7 8 4 1 n 10 4 [ n 2,n 7,n 10 ] 46 n1n1 1 1 1 1 1 1 1 1 5 5 1 1 1 1 3 3 1 1 10 1 111 5 3 45 6 6 4 2 5 3 35 1 4 [n 2,n 7,n 10 ] =(19 + 1 * 5)(8 + 2 * 3)+(1 + 3 * 1)+(4)+=46(24) + (14) + (4) + (4)= [n 7,n 2,n 10 ] =(8 + 1 * 3)(19 + 2 * 5)+(1 + 3 * 1)+(4)+=48(11) + (29) + (4) + (4)= [n 10,n 2,n 7 ] =(1 + 1 * 1)(19 + 2 * 5)+(8 + 3 * 3)+(4)+=52(2) + (29) + (17) + (4)= 2 3 45

55 (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 ] n1n1 27 1 1 1 1 3 3 4 4 1 1 2 2 7 7 [n 2,n 6 ] =(13 + 1 * 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

56

57 (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 n1n1 1 1 1 1 3 3 4 4 1 1 2 2 7 7 (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)

58 (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 n1n1 1 1 1 1 3 3 4,5 1 1 2 2 7,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)

59 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 ] n1n1 29 1 1 1 1 3 3 4,5 1 1 2 2 7,5 [n 2,n 6 ] =(14 + 1 * 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

60

61 (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 n1n1 1 1 1 1 3 3 4|2 1 1 2 2 7 7 (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)

62 (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 n1n1 1 1 1 1 3 3 4|2 1 1 2 2 7 7 [n 3 ] = (8 + 2 * 3)+ =(14) + (3) (3) =17 [n 4,n 3 ] =(1 + 2 * 1)+ =(3) + (10) + (4) (4 + 3 * 2)+ =17 (4)

63 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 ] n1n1 29 1 1 1 1 3 3 4|2 1 1 2 2 7 7 [n 2,n 6 ] =(17 + 1 * 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

64

65 (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 n1n1 1 1 1 1 3 3 6|2 1 1 2 2 9 9 (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)

66 (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 n1n1 1 1 1 1 3 3 6|2 1 1 2 2 9 9 [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)

67 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 ] n1n1 39 1 1 1 1 3 3 6|2 1 1 2 2 9 9 [n 2,n 6 ] =(23 + 1 * 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

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

69 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