METODOLOGÍA DE LA PROGRAMACIÓN. Informática de Gestión

Transcripción

1 METODOLOGÍA DE LA PROGRAMACIÓN Iformática de Gestió Profesor: Borja Fdez. Gaua Despacho: Departameto de LSI s: Aputes y ejercicios: Tfo.:

2 ÍNDICE 0. INTRODUCCIÓN 1. ASERCIONES LÓGICAS 1.1 Defiicioes y otació 1.2 Lógica de Primer Orde (LPO) 2. ESPECIFICACIÓN 2.1 Especificació Pre-Post 3. VERIFICACIÓN 3.1 Verificació de correcció parcial y total 3.2 Cálculo de Hoare 3.3 Axioma de Asigació (AA) 3.4 Deduccioes lógicas 3.5 Regla de la Cosecuecia (RCN) 3.6 Regla de la Composició (RCP) 3.7 Regla Codicioal (RCD) 3.8 Descomposició de programas 3.9 Iteracioes Cocepto de Ivariate Regla del While (RWH) Termiació 3.10 Llamadas a fucioes o recursivas 3.11 Llamadas a fucioes recursivas Hipótesis de iducció Correcció parcial Validació 4. DERIVACIÓN 4.1 Derivació de fucioes recursivas 4.2 Derivació por imersió 2

3 0. INTRODUCCIÓN El desarrollo de software cosiste e, dado u problema, ecotrar u programa (o cojuto de programas) que lo resuelva de forma correcta y eficietemete. E geeral, el desarrollo de software tiee 4 fases: 1. Aálisis: Dado u problema, iicialmete se hace el aálisis del mismo, de maera que obtegamos ua especificació clara y cocisa de qué es lo que se quiere hacer. 2. Diseño: A partir de la especificació, se hace u diseño del programa que se va a hacer, después del cuál se obtedrá los algoritmos ecesarios para poder escribir el programa. 3. Codificació: Ua vez se tiee el diseño del programa, se procede a implemetarlo e el/los leguaje(s) de programació elegido(s). 4. Mateimieto: Cuado el software ya está implatado e el lugar de implatació, se hace seguimieto del fucioamieto del programa, así como se toma ota de los posibles errores detectados para ser corregidos e ua versió posterior. Desgraciadamete, todos erramos y, debido a errores humaos e el proceso, a meudo se hace ecesario volver a ua fase aterior. Por ejemplo, ua mala compresió del problema, puede hacer que, habiedo empezado a implemetar, se tega que volver a la fase de aálisis. Cuato más tarde se detecta u error, más caro (e térmios de tiempo y diero) resulta solucioarlo, por lo que se hace ecesaria ua metodología de trabajo para miimizar los errores humaos. E la asigatura vamos a ver diferetes coceptos y técicas que va a facilitar el proceso de desarrollar software: 1. Especificació formal: os permitirá defiir de maera clara que o permita iterpretacioes diferetes de qué es lo que se quiere hacer y qué requisitos se tedrá que cumplir para que el programa de los resultados deseados. 2. Verificació de programas: os ayudará a comprobar que u programa cumple co su especificació, de maera que podamos detectar errores. 3. Documetació de programas: permitirá que el código pueda ser revisado y modificado por persoas diferetes al autor si perder excesivo tiempo e la compresió del mismo. 4. Derivació formal de programas: sirve para escribir de maera razoada y casi 3

4 automática u programa a partir de las especificacioes que cumple. 5. Trasformació de programas: os permitirá trasformar de maera automática programas ieficietes (recursivos) e otros que, cumpliedo las especificacioes origiales, resulte más eficietes. 4

5 1. ASERCIONES LÓGICAS Departameto de L.S.I. 1.1 Defiicioes y otació Estado (de cómputo) de u programa: Descripció completa de los valores asociados a todas las variables del programa e u mometo determiado del cómputo. Por ejemplo, si u programa tiee e u mometo de su ejecució las variables X e Y co los valores 5 y -24 respectivamete, su estado de cómputo e ese mometo sería X=5, Y=-24}. Cómputo: Sucesió de estados de cómputo. Ejecució. Asercioes: So afirmacioes sobre el estado del programa, fórmulas o expresioes lógicas asociadas a u puto determiado de u programa, que os sirve para expresar propiedades de las variables del programa. Se suele icluir e el programa etre las líeas de código como cometarios (/* */). Ejemplo de asercioes asociadas al código de u programa (co u ejemplo posible de los estados de cómputo): Código + Asercioes x= 5; /*x=5*/ y= x+2; /*x=5 ^ y=x+2*/ z= x+y; /*x=5 ^ y=x+2 ^ z=x+y*/ Estado de cómputo x=5 } x=5, y=7 } x=5, y=7, z=12 } Mietras u estado de cómputo refleja u úico estado posible de las variables (u cojuto de valores), ua aserció es más geérica y puede ser cierta para diferetes estados de cómputo. Por ejemplo, la aserció /* x=y*2 */ puede ser cierta tato para el estado de cómputo x=12,y=6} como para x=26,y=13}. E este caso, la aserció represeta u úmero casiifiito de estados de cómputo posibles (o es ifiito porque e ua máquia los úmeros tiee ua resolució fiita). Cuado o se impoga igua precodició (ver el Tema 2) o o se coozca igua propiedad de las variables (por ejemplo al iicio de u programa), la aserció asociada será 5

6 /*true*/, ya que se cumplirá (el valor de verdad asociado será verdadero) para cualquier estado de cómputo posible. 6

7 1.2 Lógica de Primer Orde (LPO) A la hora de escribir asercioes, ecesitamos u leguaje (Lógica de Primer Orde) del que valeros para expresar las propiedades que cumple las variables, co su correspodiete alfabeto, sitaxis y semática. a) Alfabeto. b) Sitaxis. - Variables: cotiee valores modificables durate el cómputo. P.ej.: x, a, A[], - Costates: represeta valores cocretos y fijos. P.ej.: 1, 10, 'a', PI, - Fucioes: opera sobre valores devolviedo otro valor. P.ej.: +, -, %, /, Σ, П, - Predicados: fucioes que devuelve u valor booleao (true o false) P.ej.: <, =, >, par, impar, - Térmios: elemetos atómicos que combiados forma ua fórmula. P.ej.: x puede ser ua variable c puede ser ua costate f(t 1,...,t ) es ua llamada a la fució f -aria y t 1 t térmios - Fórmulas: cojució de térmios que se evalúa como true o false. átomos: p(t1,,t) co p predicado -ario y térmios compuestas: siedo ψ, Ф fórmulas, por ejemplo: coectivos: ψ, ψ^ф, ψ Ф, cuatificadores: x, x c) Semática. Asocia a cada fórmula u valor booleao depediedo del estado de cómputo de las variables. Diremos que ua fórmula está defiida o tiee valor si todas sus variables libres (variables del programa, o ligadas a u cuatificador) tiee u valor asociado e dicho estado. 7

8 1.2.1 Coectivos Ue fórmulas formado fórmulas compuestas. E la tabla siguiete está todos los coectivos; así como sus correspodietes valores de verdad, que utilizaremos este curso. ϕ ψ ϕ (ot) ϕ ψ (or) ϕ ψ (ad) ϕ ψ (si) ϕ ψ (sii) T T F T T T T T F F T F F F F T T T F T F F F T F F T T Cuatificadores Abreviatura para ua serie. Utilizaremos (para todo), (existe), Π(productorio), Σ (sumatorio) y Ν (cardial o recueto). Todos los cuatificadores tedrá ua variable ligada, que o tedrá sigificado fuera del ámbito del cuatificador. Servirá para expresar el alcace de ua propiedad y tedrá u domiio: u cojuto de valores que se le dará a la variable ligada a los que se referirá la propiedad Σ (sumatorio) Lo deotaremos D x f x dode D(x) es el domiio o cojuto de valores que tomará x (o cualquiera que sea la variable utilizada para defiir el domiio), siedo ésta ua variable ligada al sumatorio, que o existirá fuera del sumatorio. El sumatorio tiee asociada la suma (+). Si el domiio es vacío (dicho de otra maera, si o se le da valores a i), devolverá 0, elemeto eutro de la suma. Por ejemplo, 3 3 j=5 i 2 = =14 A i = A 1 A 2 A 3... A 2j 3 j 2 3j=0 5<=j<=3. E este último caso, el domiio es vacío por o haber igua j que cumpla 8

9 Π (productorio): Similarmete al sumatorio, lo deotaremos f x dode D(x) será el domiio o D x cojuto de valores que tomará x (o cualquiera que sea la variable utilizada para defiir el domiio), siedo ésta ua variable ligada al productorio. Tiee asociado el producto (*). Si el domiio es vacío (dicho de otra maera, si o se le da valores a i), devolverá 1, elemeto eutro del producto. Por ejemplo, 5 i=2 j k=i 0 i = =120 A k 2 = A i 2 A i 1 2 A i A j 2 i 2 (domiio vacío) Cuatificador uiversal: (para todo) Será de la forma x D x P x, dode x es la variable ligada, D(x) es el domiio de la variable ligada al cuatificador y P(x) la propiedad. Si la propiedad P(x) se cumple para todo el domiio de la variable ligada, el cuatificador se evaluará como true, y e caso cotrario como false. Tiee asociada la operació de implicació ( ), que se utilizará para uir domiio y propiedades. E caso de domiio vacío, se evaluará como true. Por ejemplo, x 10 x 20 x 2 0 =true (todos los úmeros eteros etre el 10 y el 20 elevados al cuadrado da u úmero positivo) x x 0 x mod 2=0 = false (o todos los úmeros so múltiplos de 2) i 15 i 10 A i =0 =true (domiio vacío) Cuatificador existecial: (existe) Tedrá la forma x D x P x, dode x es la variable ligada, D(x) es el domiio de la variable ligada al cuatificador y P(x) la propiedad. Si la propiedad P(x) se cumple para alguo de los valores del domiio de la variable ligada, el cuatificador se evaluará como true, y e caso cotrario como false. 9

10 Tiee asociada la operació lógica ad ( ). Si el domiio fuese vacío, se evaluaría como false. Por ejemplo, x 3 x 2 x 0 =true (el 1 está e el domiio y es positivo) x 1 i A[i] 0 (será cierto si el vector tiee algú úmero positivo) i 1 i 1 i x = false (domiio vacío) Cuatificador de recueto: N (cardial) Se expresará ℵ x D x P x, siedo D(x) el domiio de la variable ligada x y P(x) la propiedad. A diferecia de los dos cuatificadores ateriores, éste o se evalúa como u valor booleao, sio como u úmero atural: el úmero de elemetos del domiio que cumple la propiedad P(x). E caso de ser el domiio vacío, se evaluará como 0, ya que o habrá elemetos que cotar. Por ejemplo, vector A[1..]) ℵi 1 i 8 i mod 3=0 =2 (hay 2 múltiplos de 3 etre el 1 y el 8) ℵi 1 i A[i ]mod 2=0 (devolverá el úmero de elemetos pares del ℵ j 2 j 2 j 2 =20 =0 (domiio vacío) 10

11 1.2.3 Predicados A la hora de itetar represetar e LPO euciados de gra complejidad o logitud, es a veces deseable afrotar el problema dividiédolo e coceptos más pequeños. De similar maera a como defiimos fucioes cuado programamos para hacer más legible y reutilizable el código, podemos defiir predicados que os ayude a hacer más fácil de eteder la fórmula y poder, además, reutilizarlos e diferetes ejercicios. Siguiedo la aalogía co las fucioes a la hora de programar, defiiremos u predicado p t 1,...,t de igual maera que le damos u ombre a ua fució y defiimos cuáles será sus parámetros t 1,..., t. Auque geeralmete usaremos predicados por la aturaleza booleaa de las asercioes, puede que os iterese defiir ua fució e vez de u predicado. Recordemos que, e lo que a esta asigatura atañe, la diferecia etre ambos es que, mietras u predicado devuelve u valor booleao, ua fució devolverá u valor umérico. Ejemplos: - Expresar e LPO que todos los elemetos de A[1..] so primos: Primero podemos defiir el predicado esprimo(x) que os diga si u úmero cualquiera (x) es primo: esprimo x i 1 i x x mod i 0 Ua vez defiido resulta más fácil geeralizar para todo el vector: j 1 j esprimo A[ j] - Expresar e LPO que el vector A[1..] está ordeado de meor a mayor: Si está ordeado de meor a mayor, podemos defiir el predicado esmáximo(x,a,i,j) que os dirá si x es el máximo de A[i..j] para luego geeralizarlo al vector etero. esmaximo x, A, i, j k i k j A[k ] x Ahora geeralizamos a todo el vector: i 1 i esmaximo A[i], A,1,i 1 NOTA: Siempre que utilicemos u predicado o ua fució, habrá que defiirlo/a previamete, igual que ua fució tiee que haberse defiido ates de llamarla cuado estemos programado. 11

12 1.2.4 Operació de sustitució t Dada la fórmula, la variable x y el térmio t, defiiremos x como la fórmula resultate de sustituir todas las aparicioes libres de x por t e. Como aparició libre etedemos todas aquellas que o sea variables ligadas del mismo ombre. Si el térmio t tuviese algua variable que apareciese como ligada e φ, habrá que reombrarlas ates de hacer la sustitució. Esta es ua operació que utilizaremos ampliamete cuado veamos e el cálculo de Hoare el Axioma de Asigació (AA). Ejemplos: x 2 2x 17 y x y 2 2y 17 x 5 1 y 5 x 5 x x y 5 x 10 1 y 5 j k=i j i 1 A[k ] i A[k ] k =i Fórmulas débiles y fuertes Diremos que la fórmula ϕ es más fuerte que ψ (o que ψ es más débil que ϕ ) si y sólo si el cojuto de valores que hace cierto ϕ es u subcojuto de los que hace cierto ψ: ϕ más fuerte que ψ s s (ϕ)= true} s s (ψ)=true} Dicho más ituitivamete, la fórmula más fuerte es aquella que tiee u meor úmero de estados que hace cierta la fórmula. Por ejemplo, x>0 es más fuerte que x>=0 es cierto para x=0. - ya que la seguda, además de todos los valores que hace cierto x>0, - x 0 x 0 x=0 Ψ: x 0 ϕ: x > 0 12

13 Ejercicios LPO I Expresa los siguietes euciados e Lógica de Primer Orde: 1. x es positivo. 2. x es ulo. 3. x es atural. 4. x es múltiplo de y. Por ejemplo, 10 es múltiplo de x es divisor de y. Por ejemplo, 5 es divisor de x es múltiplo de 5, pero o lo es de x es potecia de x es u úmero primo. 9. z es la suma de los primeros úmeros aturales. 10. z es la suma de ua secuecia de úmeros aturales que comieza por E el vector A[1..] o hay igú elemeto egativo. 12. La suma de todos los elemetos de la secció A[i..j] es mayor que cada uo de los elemetos del vector. Nota: los elemetos puede ser egativos. 13. El vector B[1..] está ordeado de maera decreciete. 14. Hay u úico elemeto e A[1..] igual a su ídice. 15. max es el máximo de la secció A[i..j]. 16. E el vector B[1..] o se repite igú elemeto. 17. El vector A[1..] es capicúa. 18. La suma de los valores absolutos de todos los elemetos de A[1..] es x aparece e el vector A[1..] por primera vez e la posició i. 20. El vector A[1..] cotiee los primeros úmeros de la serie de Fiboacci ( 1, 1, 2, 3, 5, 8, 13, 21,... ) 21. E el vector A[1..] teemos represetados los dígitos del úmero atural x. 22. E los vectores A[1..] y B[1..m] teemos los dígitos de dos úmeros aturales que sumados da x. 13

14 Ejercicios LPO II Decide si las siguietes implicacioes so correctas o o: 1. x 7 x 9 2. x 7 x 6 3. x 1 y x y 1 4. j i 0 j i i 6 i 2 i 5 6. x 7 x i 1 i 8. 1 i 1 i sum= sum= A [i ] sum= A [i ] sum A[ ]= A[ i ] A [] A[i ] 14

15 Solucioes propuestas ejercicios LPO I 1. positivo x x 0 2. ulo x x=0 3. atural x x 0 x 0 x=0 positivo x ulo x 4. multiplo x, y x mod y=0 z z 1 x=y z 5. divisor x, y y mod x=0 z z 1 y=x z multiplo y, x 6. imparm5 x x mod 5=0 x mod 10 0 multiplo x, 5 multiplo x,10 7. pot2 x y y 1 x=2 y 8. primo x x 1 i 1 i x x mod i 0 9. essuma z, z= i 10. esusuma z 1 z= i 11. igunegativo A, i 1 i A[i ] 0 i 1 i A[i ] 0 j 12. sumasecció A,i, j k =i A[k ] susemacael A,i, j k 1 k sumasecció A,1, A[k] 13. decreciete B, i 1 i B [i ] B [i 1] i 1 i B[i] B[i 1] 14. uoigualidice A, ℵi 1 i A[i ]=i =1 15. maxes max, A,i, j k i k j A[k ]=max k i k j A[k ] max 16. aparicioes x, A, ℵk 1 k A[k ]= x distitos A, i 1 i aparicioes A[i], A, =1 17. capicúa A, i 1 i /2 A[i]= A[ i 1] 18. sumavalabsnula A, A[i ] =0 i 1 i A[i]=0 19. primerai x,i, A, k 1 k i A[k]!= x A[i]= x 1 i 20. fiboa A, A[1]=1 A[2]=1 i 2 i A[i]=A[i 1] A[i 2] 21. dig A, k 1 k 0 A[k ] 10 umdig A, A[i ] 10 i vectorde A,, x dig A, x=umdig A, 15

16 22. suma A,, B, m, x dig A, dig B, m x=dig A, Dig B, m 16

17 Solucioes propuestas ejercicios LPO II 1. x 7 x 9 Cierto 2. x 7 x 6 Cierto 3. x 1 y x y 1 Cierto 4. j i 0 j i Cierto 5. i 6 i 2 i 5 Falso 6. x 7 x 1 7 Cierto 7. 1 i 1 i Cierto 8. 1 i 1 i 1 Falso 1 9. sum= sum= A [i ] sum= A [i ] sum A[ ]= A[ i ] A [i ] Falso A[i ] Cierto 17

18 2. ESPECIFICACIÓN Ua de los pricipales motivos para volver a ua fase aterior e el ciclo de desarrollo de software (co el cosiguiete coste tiempo-diero) suele ser ua icorrecta compresió del problema que se quiere solucioar. Esto geeralmete está causado por la imprecisió y falta de rigurosidad a la hora de especificar el objetivo del programa. Para evitar, e la medida de lo posible, este tipo de problemas, utilizaremos la especificació formal: así defiiremos de forma clara y cocisa qué se tiee que cumplir ates de llamar a u programa y qué es lo que devolverá el programa (o fució). 2.1 Especificació Pre-Post Llamaremos especificació Pre-Post a aquella que defia cuál es la precodició y cuál es la postcodició de u trozo de código, defiiedo como precodició la fórmula que defie qué se tiee que cumplir ates de ejecutar el código para que al fializar se cumpla la postcodició, que es la fórmula que describe la relació etre los datos de etrada y los resultados: lo que se cumplirá al fializar el programa. E térmios más secillos, ua especificació Pre-Post determia qué tiee que garatizar quie llame al código ates de llamarlo (precodició) para que el programa pueda cumplir su cometido (postcodició). E geeral, escribiremos /* ϕ */ P /* ψ */ para idicar que el programa P tiee la precodició ϕ y la postcodició ψ. Por ejemplo: i /*1 i suma= A[ j ]*/ j =1 i=i 1; suma=suma A [i]; /*1 i suma= j =1 i A[ j ]*/ E este ejemplo, siempre que al pricipio del programa se cumpla que i esté detro del rago del array A (si ser la última posició) y que tegamos e la variable suma la suma de los primeros i elemetos (precodició: φ), después de ejecutarse el código siempre se cumplirá que i seguirá estado detro del rago del array y que e la variable suma tedremos la suma de los primeros i elemetos (postcodició: ψ), habiedo sumado +1 a i. 18

19 Nos iteresará además que la precodició sea lo más débil posible (lo meos exigete posible) y que la postcodició sea lo más fuerte posible (que describa la relació etre datos de etrada y resultado de la maera más exacta y cocisa posible). i Así, e el ejemplo aterior, /*1 i suma= A[ j ] suma 0*/ sería ua j =1 precodició demasiado fuerte, ya que o es ecesario que suma sea mayor que 0 para que después de las 2 istruccioes se cumpla la postcodició. De igual maera, /*1 i */ sería ua postcodició demasiado débil, ya que o expresa la relació etre la variable suma y los elemetos del vector. A modo de resume, la precodició debe establecer las codicioes míimas que se debe cumplir para que al fial del programa se llegue a la postcodició, que deberá expresar todas las propiedades coocidas etre los datos de etrada y los resultados. 19

20 3. VERIFICACIÓN La verificació es la técica que vamos a ver más e profudidad y la que ocupará la mayoría del tiempo de clase. Nos permitirá demostrar formalmete (verificar) que u programa es correcto. La correcció es u térmio subjetivo y ambiguo e el mudo real, pero e cuato a esta asigatura atañe, diremos que u programa es correcto si respeta su especificació formal. 3.1 Verificació de correcció parcial y total Diremos que u programa es parcialmete correcto si, siempre que al iicio del programa se cumpla la precodició, e caso de que el programa acabe, siempre acabará satisfaciedo la postcodició. Escribiremos /* */ P /* */ para decir que el programa P es parcialmete correcto respecto a la especificació formada por φ (precodició) y ψ (postcodició). Diremos que u programa es totalmete correcto si, siempre que al iicio de la ejecució se respete la precodició, el programa acabará satisfaciedo la postcodició. Respecto a la correcció parcial se añade además la garatía de que el programa siempre acabará. Deotaremos /* */ [ P ] /* */ la correcció total del programa P respecto a su especificació Pre-post. Si defiimos Term, P como el predicado que os dice si toda ejecució de P que cumpla iicialmete la precodició φ va a acabar e u úmero fiito de pasos, podemos afirmar que /* */ [ P ] /* */ /* */ P /* */ Term, P. 20

21 3.2 Cálculo de Hoare Para verificar la correcció total o parcial de u programa utilizaremos el cálculo de Hoare, que utilizará axiomas (por ejemplo, el Axioma de Asigació) y reglas de iferecia (RCN, RCP etc...). A la hora de verificar la correcció de u programa, el proceso a seguir es, a partir de la precodició, ir deduciedo, mediate axiomas y reglas de iferecia, las propiedades etre variables que se matedrá e los diferetes putos del programa. El objetivo fial siempre será demostrar que al fial del programa se cumplirá la postcodició. Los axiomas será propiedades básicas idemostrables de la forma /* */ P /* */, dode P podría ser, por ejemplo, ua asigació. Si e algú paso aterior se hubiese demostrado que ates de P se cumplía φ, quedará demostrado que después de la asigació se cumplirá ψ. /*...*/ P 1 /*...*/, /*...*/ P 2 /*...*/,... Las reglas de iferecia tedrá la forma /*...*/ P 1 P 2 /*...*/ habiedo sido previamete demostradas las propiedades /*...*/ P 1 /*...*/, /*...*/ P 2 /*...*/,... la regla de iferecia demostrará que se verificará /*...*/ P 1 P 2 /*...*/., y, 21

22 3.3 Axioma de Asigació (AA) El primer axioma que estudiaremos será el de asigació. Este axioma os permitirá iferir las propiedades que se cumplirá después de ua asigació. E ua asigació distiguiremos dos partes: la variable x dode se almaceará el valor (parte izquierda de la asigació) y el térmio t de la parte derecha que se evaluará como u valor (geeralmete umérico). x=t ; Ates de realizar ua asigació cooceremos ua serie de propiedades sobre las variables que forma parte del térmio t. Todo aquellas propiedades del térmio t que se coozca ates de la asigació, las cumplirá la variable x después de la asigació. Así, e el siguiete ejemplo: =/* z mod 2=0 */ x =z ; =/* x mod 2=0 z mod 2=0 */ Sabiedo que z es u úmero par ates de la asigació, después de ella siempre se cumplirá que x será u úmero par. Además, seguiremos sabiedo lo mismo de z que ates de la asigació, puesto que i la variable z i igua variable libre de φ ha sido modificada e la asigació. E este otro ejemplo, e cambio: /* x 2 0*/ x =x 2 ; /* x 0 x 2 0*/ Después de la asigació, o podemos afirmar que x-2>0 se siga cumpliedo, ya que la variable libre x (que aparece e el térmio t) ha cambiado por ser además la variable dode se guardará el resultado. Euciaremos el Axioma de Asigació de la siguiete maera: dode: /*def(t) x t */ x=t ; /* */ AA def(t) es ua fórmula que afirma que la evaluació del térmio t o produce error y está defiido. Si cotuviese a la variable x, o se podría afirmar después de la asigació y 22

23 puede o estar presete (o lo que es lo mismo, ser true). Ω será ua fórmula dode o aparecerá la variable libre x pero sí podrá aparecer el térmio t. Al ser idepediete de la variable x, o cambiará después de la asigació. será aquella fórmula que expresará las propiedades del térmio t ates de la asigació. E ella aparecerá todas las variables libres del térmio t y podrá aparecer la variable x. Después de la asigació se cumplirá las mismas propiedades que se cumplía ates de la asigació para el térmio t para la variable x ( ). x t A cotiuació veremos uos cuatos ejemplos dode aplicaremos el AA para los distitos casos: Ejemplo 1: /* y 0 z/ y=2 v=12*/ z=z / y ; /* y 0 z=2 v=12*/ E este ejemplo, el térmio t será la expresió z/y y la variable será z, que tambié aparecerá e el térmio t. def(t) y 0 ya que os asegura que la divisió o os dará u resultado idefiido y, como la variable y o ha cambiado e la asigació, se seguirá cumpliedo después. Igualmete, x t z / y =2 y z=2. Describe la úica propiedad coocida del térmio z/y ates de la asigació, que después pasará a ser la propiedad que cumplirá la variable z. Fialmete, v=12, ya que la fórmula o cotiee la variable libre z i el térmio t. Ejemplo 2: /* y 0 y/2=16*/ z=y /2; /* y 0 z=16 y/2=16*/ E este ejemplo o existe def(t), ya que la divisió etre 2 uca dará error.. t x y/2=16 y z=16. E este caso, como la variable z o aparece e t x y/2=16, se cumplirá tambié que y/2=16 y se seguirá cumpliedo después de la asigació. 23

24 3.4 Deduccioes lógicas Desgraciadamete, el Axioma de Asigació o es suficiete para iferir propiedades t después de ua asigació, ya que x o siempre estará expresada ta claramete e fució del térmio t como e los ejemplos ateriores. E el siguiete ejemplo: /* x=y /2*/ z=2x ; /*??? */ No podemos iferir igua propiedad ya que e la aserció icial o aparece el térmio 2x. Si embargo, utilizado deduccioes lógicas, podríamos resolver parte de este tipo de problemas, ya que si sabemos que x=y/2, podremos deducir que 2*x=y, co la que ya podríamos aplicar el Axioma de Asigació. Veamos pues alguas de las deduccioes lógicas (trasformacioes que o cambia el valor de verdad de la fórmula origial) que utilizaremos e adelate: - A B A (Simplificació) - A A B (Adició) - A B A B (Modus Poes) - A B B A (Modus Tolles) - A B B A (Silogismo disyutivo) - A B B A (Trasitividad) - A B B A (Falacia: INCORRECTA) Adicioalmete, a meudo utilizaremos equivalecias tautológicas (o lógicas) como las siguietes: - A A - A B A B 24

25 - A B A B - A B A B A - x 5 x i 1 0 i 1 i 1 1 i i 1 Ahora que ya coocemos cuáles será las herramietas que utilizaremos para trasformar las fórmulas volveremos al ejemplo del pricipio: /* x=y /2*/ z=2x ; /*??? */ Como decíamos, o podemos aplicar directamete el Axioma de Asigació, ya que la aserció aterior a la asigació o está e fució de 2x. Pero ahora que hemos visto cómo trasformar las fórmulas podemos decir: 1. x= y/ 2 2x= y Y ahora sí podemos aplicar AA: 2. /*2x=y */ z=2x; /* z= y */ AA Para acabar verificado la correcció del ejemplo sólo os hará falta ua regla de iferecia que os permita uir ambos pasos: la Regla de la Cosecuecia (RCN). 25

26 3.5 Regla de la Cosecuecia (RCN) Esta regla os permitirá uir deduccioes lógicas co las asercioes iferidas (resultados de las reglas de iferecia). 1, /* 1 */ P /* 1 */, 1 /* */ P /* /* RCN Depediedo de si ecesitamos hacer deduccioes sólo ates o después de aplicar la regla de iferecia correspodiete, podremos utilizar las siguietes dos variates: a) b) 1, /* 1 */ P /* 1 */ /* */ P /* 1 /* /* */ P /* 1 */, 1 /* */ P /* /* RCN RCN Gracias a la RCN podemos trasformar asercioes y lo que verifiquemos para las asercioes trasformadas quedará verificado para las origiales, por lo que ya podemos retomar el ejemplo co el que empezamos y acabar verificado su correcció: 1. x= y/ 2 2x= y 2. /*2x=y */ z=2x; /*z= y */ AA 3. /* x= y/2*/ z=2x; /* z= y */ 1,2 RCN De esta maera, e el tercer paso hemos verificado que, siempre que icialmete se cumpla x=y/2, después de la asigació siempre se verificará z=y. Geeralmete, cuado tegamos ua asigació, podremos la aserció aterior a ella e fució de la parte derecha de la asigació (térmio t del AA) para poder aplicar AA, y luego uiremos ambos pasos co la RCN. Ejemplo completo de cálculo de Hoare: i /* suma= A[ j ] i */ j=1 i=i 1; i 1 /* suma= j=1 A[ j ] i */ Primero poemos la aserció iicial e fució de i+1 (térmio t): 26

27 i 1. suma= j=1 Departameto de L.S.I. i 1 1 A[ j] i suma= A[ j ] i 1 j =1 Ahora podemos aplicar AA sustituyedo i+1 (térmio t) por i (variable x): i /* suma= j=1 i 1 A[ j] i 1 */ i=i 1 ; /* suma= A[ j] i */ AA j=1 Fialmete, uimos los dos pasos co la RCN idicado qué propiedades hemos utilizado para aplicarla (e este caso las propiedades demostradas e los pasos 1 y 2): i 3. /* suma= j=1 i 1 A[ j ] i */ i=i 1; /* suma= A[ j] i */ 1,2 RCN j=1 27

28 Ejercicios Verificació (I) Verifica los siguietes programas: /* y=5*/ x =y y y ; /* x=30*/ /* x= y 5*/ z=x 5; /* x=y 5 z= y 10 */ i /* suma= A[ j]*/ j =1 i=i 1 ; i 1 /* suma= j=1 A[ j ]*/ /*1 i 1 j=5*/ j=i 1; /*1 j */ /* z x= y*/ z=z x ; /* z=2x y */ i /*1 i suma= A[ j]*/ j=1 suma=suma A [i 1]; i 1 /*1 i 1 suma= j=1 /* par x */ x =x 1; /*impar x */ /* x=2 y */ x =x 2; /* x=2 y 1 */ A[ j]*/ 28

29 Solucioes propuestas Verificació (I) Departameto de L.S.I. 1. /* y=5*/ x =y y y ; /* x=30*/ 1. y=5 y y y=30 2. /* y y y=30*/ x=y y y ; /* x=30 */ AA 3. /* y=5*/ x=y y y ; /* x=30*/ RCN 1,2 2. /* x= y 5*/ z=x 5; /* x=y 5 z= y 10 */ 1. x= y 5 x 5= y 5 5 x 5= y /* x 5= y 10*/ z=x 5; /* z= y 10 x 5= y 10*/ AA 3. z= y 10 x 5= y 10 x= y 5 z= y /* x= y 5*/ z=x 5; /* x= y 5 z= y 10 */ RCN 1,2,3 3. i /* suma= A[ j]*/ j =1 i=i 1 ; i 1 /* suma= j=1 i 1. suma= j=1 A[ j ]*/ i /* suma= j=1 i 3. /* suma= j=1 i 1 1 A[ j ] suma= A[ j] j=1 i 1 A[ j]*/ i=i 1; /* suma= A[ j]*/ AA j=1 i 1 A[ j ]*/ i=i 1; /* suma= A[ j]*/ RCN 1,2 j=1 4. /*1 i 1 j=5*/ j=i 1; /*1 j */ 1. 1 i 1 j=5 1 i 1 2. /*1 i 1 */ j=i 1; /*1 j */ AA 29

30 3. /*1 i 1 j=5*/ j=i 1; /*1 j */ RCN 1,2 5. /* z x= y*/ z=z x ; /* z=2x y */ 1. z x= y z x 2x= y 2x z x= y 2x 2. /* z x= y 2x*/ z=z x ; /* z= y 2x */ AA 3. z= y 2x z=2x y 4. /* z x= y*/ z=z x ; /* z=2x y*/ RCN 1,2, i /*1 i suma= A[ j]*/ j=1 suma=suma A [i 1]; i 1 /*1 i 1 suma= j=1 i 1 i suma= j=1 A[ j]*/ i 1 A[ j] 1 i suma A[i 1]= A[ j] i 1 1 i 1 suma A[i 1]= A[ j] j =1 i 1 1 i 1 suma A[i 1]= j =1 A[ j] i 1 /*1 i 1 suma A[i 1]= A[ j]*/ suma=suma A [i 1]; j=1 i 1 /*1 i 1 suma= j=1 A[ j]*/ AA i /*1 i suma= A[ j ]*/ suma=suma A [i 1]; j =1 i 1 /*1 i 1 suma= j =1 A[ j]*/ RCN 1,2 j=1 7. /* par x */ x =x 1; /*impar x */ 1. par x impar x 1 2. /*impar x 1 */ x=x 1; /*impar x */ AA 30

31 3. /* par x */ x =x 1 ; /*impar x */ RCN 1,2 8. /* x=2 y */ x =x 2; /* x=2 y 1 */ 1. x=2 y x 2=2 y 2 x 2=2 y 1 2. /*x 2=2 y 1 */ x =x 2; /* x=2 y 1 */ AA 3. /* x=2 y */ x=x 2; /* x=2 y 1 */ 1,2 RCN 31

32 3.6 Regla de la composició (RCP) Co lo visto hasta el mometo, sólo podemos verificar asigacioes sueltas. Si e vez de ua úica tuviésemos dos seguidas, os haría falta algua otra herramieta para hacerlo. Ése es el objetivo de la Regla de la Composició (RCP): uir partes simples del cálculo de Hoare para poder verificar programas compuestos por varias líeas. /* */ P 1 /* 1 */, /* 1 */ P 2 /* */ /* */ P 1, P 2 /* */ RCP Esta regla os permite uir partes de u programa ya verificadas siempre que tega ua aserció itermedia comú (e el euciado de la regla 1 ) Veamos co u ejemplo cómo se utiliza la RCP: i /* suma= A[ j ] i */ /* */ j=1 i=i 1; P 1 /* 1 */ suma=suma A [i]; P 2 i /* suma= A[ j ] i */ /* */ j=1 El programa está formado por dos istruccioes P 1 y P 2, etre las cuales se cumplirá uas propiedades ( 1 ) que a priori descooceremos. El procedimieto e estos casos es aplicar el AA para la primera asigació (si hace falta trasformar algua aserció, tedremos que aplicar la RCN), co lo que podremos saber qué se cumple e 1. Itetaremos aplicar el AA sobre la seguda istrucció y posteriormete aplicaremos la RCP para uir las dos partes. Por lo tato, el objetivo fial es verificar que se cumple a /* */ P 1 /* 1 */ y b /* 1 */ P 2 /* */ para poder aplicar la RCP. Primero, trataremos de verificar a /* */ P 1 /* 1 */. Para ello, primero formularemos e fució de i+1, luego aplicaremos AA y fialmete RCN: i 1. suma= j=1 i /* suma= j =1 i 1 1 A[ j] i suma= A[ j ] i 1 j =1 i 1 A[ j] i 1 */ i=i 1; /* suma= A[ j] i AA j =1 32

33 i 3. /* suma= j=1 Departameto de L.S.I. i 1 A[ j ] i */ i=i 1; /* suma= A[ j] i */ 1,2 RCN j=1 Llegados a este puto, ya habremos verificado la primera parte (a), y sabremos que la i 1 aserció itermedia será 1 /* suma= A[ j] i */. Partiremos de ésta para itetar j=1 llegar a verificar b /* 1 */ P 2 /* */. Empezaremos poiedo 1 e fució de suma + A[i]. Igual que para la primera parte, luego aplicaremos AA y fialmete RCN: i 1 4. suma= j= i /* suma A[i]= j =1 i 1 /* suma= j=1 i A[ j ] i suma A[i]= A[ j] i j=1 i A[ j ] i */ suma=suma A [i]; /* suma= A[ j] i */ AA j=1 i A[ j ] i */ suma=suma A [i]; /* suma= A[ j] i */ 4,5 RCN j =1 Ahora que ya teemos verificados a /* */ P 1 /* 1 */ y b /* 1 */ P 2 /* */ los pasos 3 y 6, respectivamete, del cálculo, podemos aplicar la RCP sobre ambas propiedades: e 7. i /*suma= A[ j ] i */ j=1 i=i 1; /* suma= j=1 suma=suma A[i ] ; i A[ j ] i */ 3,6 RCP 33

34 Ejercicios Verificació (II) Verifica los siguietes programas: /* x=a y=b*/ x =x y ; y =x y ; x =x y ; /* x=b y=a */ /* z= p k */ k=k 1; z=z p ; /* z= p k */ /* x=a y=b*/ x =x y ; y =x x ; /* x=a b y= a b 2 */ 34

35 Solucioes propuestas Verificació (II) 1. /* x=a y=b*/ x =x y ; A 1 /* 1 */ y =x y ; A 2 /* 2 */ x =x y ; A 3 /* x=b y=a*/ /* */ A 1 ; /* 1 */ 1. x=a y=b x y=a b y=b 2. /* x y=a b y=b*/ x =x y ; /* x=a b y=b */ /* 1 */ AA 3. /* x=a y=b*/ x =x y ; /* x=a b y=b*/ RCN 1,2 /* 1 */ A 2 ; /* 2 */ 4. x=a b y=b x=a b x y= a b b x=a b x y=a 5. /* x=a b x y=a*/ y =x y ; /* x=a b y=a */ /* 2 */ AA 6. /* x=a b y=b */ y =y x ; /* x=a b y=a */ RCN 4,5 /* 2 */ A 3 ; /* */ 7. x=a b y=a x y= a b a y=a x y=b y=a 8. /*x y=b y=a */ x=x y ; /* x=b y=a */ /* */ AA 9. /*x=a b y=a */ x=x y ; /* x=b y=a */ RCN 7,8 10. /* */ A 1 ;A 2 ; A 3 ; /* */ RCP 3,6,9 2. /* z= p k */ k=k 1; A 1 ; /* 1 */ z=z p ; A 2 ; /* z= p k */ /* */ A 1 ; /* 1 */ 1. z= p k k 1 z p= p 2. /*z p= p k 1 */ k=k 1; /* z p= p k */ /* 1 */ AA 3. /* z= p k */ k=k 1 ; /* z p= p k */ RCN 1,2 /* 1 */ A 2 ; /* */ 35

36 4. /* z p= p k */ z=z p ; /* z= p k */ AA 5. /* */ A 1 ; A 2 ; /* */ RCP 3,4 3. /* x=a y=b*/ x =x y ; A 1 /* 1 */ y =x x ; A 2 /* x=a b y= a b 2 */ /* */ A 1 ; /* 1 */ 1. x=a y=b x y=a b y=b 2. /*x y=a b y=b */ x =x y ; /* x=a b y=b */ /* 1 */ AA 3. /* x=a y=b*/ x =x y ; /* x=a b y=b*/ RCN 1,2 /* 1 */ A 2 ; /* */ 4. x=a b y=b x=a b x x= a b /* x=a b x x= a b 2 */ y =x x ; /* x=a b y= a b 2 */ /* */ AA /* x=a b y=b*/ y =x x ; /* x=a b y= a b 2 */ RCN 4,5 7. /* */ A 1 ; A 2 ; /* */ RCP 3,6 36

37 3.7 Regla Codicioal (RCD) Co las reglas ateriores podemos verificar programas compuestos sólo por asigacioes. Otras istruccioes ecesarias para poder verificar programas completos so las codicioales. Para verificar u programa como el siguiete: /* */ if B P if ; else P else ; /* */ Utilizaremos la Regla Codicioal (RCD), que se eucia de dos maeras diferetes depediedo de si hay ua rama else o o: a) Cuado haya else: def(b), /* B */ P if /* */, /* B*/ P else /* */ /* */ if(b) P if else P else /* */ RCD b) Cuado o lo haya: def(b), /* B */ P if /* */, B /* */ if(b) P if /* */ RCD Ates de ver co u ejemplo cómo aplicar la RCD, itetaremos eteder ituitivamete el porqué de cada ua de las propiedades a demostrar para verificar u if: def(b) : La codició a evaluar tiee que estar defiida por la aserció aterior, es decir, tedremos que verificar que la evaluació de la codició B uca dará u resultado idetermiado o error. /* B*/ P if /* */, : Cuado ates del if se cumpla y la codició B, es decir, cuado etremos e el the, tedremos que verificar que después de ejecutar P if siempre se verificará. /* B */ P else /* */ : E caso de haber else, tedremos que verificar que después de ejecutar P else (ates siempre se cumplirá B ). B : Cuado o haya else, habrá que verificar que B (lo que 37

38 sabremos que se cumplirá ya que habremos etrado e el else) implica directamete. Cabe destacar que la diferecia etre u if co o si else estriba e que, mietras e el primer caso se ejecutará código ( P else ), e el segudo o, por lo que se tedrá que poder deducir de las propiedades que se cumplirá e el else: B. Ejemplo 1 (si else): Pasemos a ver co u ejemplo e cómo se aplica la RCD. Veamos el cálculo de Hoare asociado a la verificació del programa: /* true */ /* */ if x 0 x = x ; /* x 0*/ /* */ E este caso, true y B x 0. Sólo teemos u if, por lo que el objetivo fial del cálculo será aplicar la RCD (si else). Primero tedremos que verificar cada ua de las 3 propiedades ecesarias para poderla aplicar: (A) def B, (B)/* B*/ P if /* */ y C B :. A def B : x<0 o puede dar u resultado idetermiado o error, por lo que: 1. true def x 0 (B)/* B*/ P if /* */: : Teemos ua asigació, por lo que trasformaremos B para poder aplicar AA, lo aplicaremos, volveremos a trasformar el resultado obteido y fialmete uiremos los 3 pasos gracias a la RCN. 2. true x 0 x 0 x 0 3. /* x 0*/ x = x ; /* x 0*/ AA 4. x 0 x 0 5. /*true x 0*/ x = x ; */ x 0*/ RCN 2,3,4 C B : E este último paso deberemos demostrar que auque o etremos e el the, siempre se acabará satisfaciedo la post-codició. 6. true x 0 x 0 x 0 Ahora sólo os falta aplicar RCD: 38

39 7. /* true */ if x 0 x = x ; /* x 0 */ RCD1,5,6 39

40 Ejemplo 2 (co else): El ejemplo aterior era u if si rama else, veamos ahora el cálculo de Hoare para uo que sí la tiee: i 1 /* 1 i sumaabs= A[ j ] */ /* */ j=1 if A [i] 0 sumaabs=sumaabs A [i]; else sumaabs=sumaabs A [i]; /* 1 i sumaabs= A[ j ] */ /* */ Como e este programa sí teemos u else, para aplicar la RCD habrá que demostrar: (A) def B, (B)/* B*/ P if /* */ y C /* B */ P else /* */ :. (A) def B : Sabemos por que 1 i, por lo que el acceso al array estará detro de su rago y o se producirá error: i i sumaabs= A[ j] def A[i] 0 j=1 i j=1 (B)/* B*/ P if /* */ : demostraremos que etrado e el the, después del if siempre se verificará. 2. i 1 1 i sumaabs= A[ j] A[i] 0 j=1 1 i sumaabs A[i]= A[ j ] i j= i /*1 i sumaabs A[i]= A[ j] */ sumaabs=sumaabs A [i]; j=1 /* 1 i sumaabs= A[ j] */ AA i 1 /* 1 i sumaabs= A[ j ] A[i] 0 */ sumaabs=sumaabs A [i]; j=1 i j=1 /* 1 i sumaabs= A[ j] */ RCN 2,3 i j=1 40

41 C /* B */ P else /* */ : : Ahora comprobaremos que etrado e el else se acaba verificado i 1 1 i sumaabs= A[ j] A[i] 0 j=1 i 1 1 i sumaabs= A[ j] A[i ] 0 j =1 1 i sumaabs A[i] = A[ j] i j=1 i 1 i sumaabs A[i ]= A[ j] i j=1 /*1 i sumaabs A[i]= A[ j] */ sumaabs=sumaabs A [i]; j=1 /* 1 i sumaabs= A[ j ] */ AA i 1 i j=1 /*1 i sumaabs= A[ j] A[i ] 0 */sumaabs=sumaabs A [i]; j=1 /* 1 i sumaabs= A[ j ] */ RCN 5,6 i j=1 Fialmete, aplicamos la RCD a las propiedades 1, 4 y i 1 /*1 i sumaabs= A[ j] */ j =1 if A [i] 0 sumaabs=sumaabs A [i]; else sumaabs=sumaabs A [i]; i /*1 i sumaabs= A[ j] */ RCD1,4,7 j =1 41

42 3.8 Descomposició de programas Cuado trabajamos co programas de logitud y complejidad cosiderable, resulta difícil realizar directamete el cálculo de Hoare, porque cuatas más istruccioes tiee u programa, mayor úmero de líeas tedrá el cálculo de Hoare correspodiete. Por ello, se recomieda hacer ua descomposició del programa previa a su verificació, por lo meos, mietras o se domie la verificació perfectamete. Así, lo primero que haremos será escribir el programa e forma esquemática, dado ombres a cada ua de las istruccioes, expresioes y asercioes. Por ejemplo, e el siguiete programa: /* x=a y*/ if y 0 x =x a ; y =y 1; } else x =x a ; y =y 1; } /* x=a y*/ Lo escribiremos de forma esquemática (e esta fase sólo os importará la estructura del programa) dado ombres a cada ua de las partes del mismo. Auque o es relevate de qué maera los ombremos, utilizaremos la siguiete omeclatura para facilitar la lectura del esquema: Φ (phi) para la precodició, Ψ (psi) para la postcodició, i para las asercioes itermedias, B i para las expresioes codicioales y A i para las asigacioes. Siguiedo co el ejemplo, su forma esquemática sería: 42

43 /* */ if B A 1 ; /* 1 */ A 2 ; } else A 3 ; /* 2 */ A 4 ; } /* */ Como el programa está compuesto por u úico if, la última regla de iferecia que utilizaremos será la RCD, por lo que tedremos que verificar A def B, B /* B */ A 1, A 2 /* */ y C /* B */ A 3, A 4 /* */. De estas dos propiedades, dos (B y C) se puede descompoer e otras dos porque está compuestas por dos asigacioes, co lo que para verificar B, tedremos que verificar primero B.1 /* B*/ A 1 ;/* 1 */ y B.2 /* 1 */ A 2 ;/* */. Para verificar C, a su vez, tedremos que verificar primeramete C.1 /* B */ A 3 ; /* 2 */ y C.2 /* 2 */ A 4 ; /* */. La descomposició del programa será etoces la siguiete: A def B B /* B */ A 1 ; A 2 ; /* */ B.1 /* B */ A 1 ; /* 1 */ B.2 /* 1 */ A 2 ; /* */ C /* B */ A 3 ;A 4 ; /* */ C.1 /* B */ A 3 ; /* 2 */ C.2 /* 2 */ A 4 ; /* */ Ua vez tegamos el programa descompuesto e partes simples (verificacioes de ua sola asigació o implicacioes lógicas), empezaremos por las hojas del árbol de arriba a abajo. E el ejemplo, primero verificaríamos A, luego B.1 y B.2 para poderlas uir mediate la RCP y verificar B, y luego C.1 y C.2 que uiríamos mediate la RCP. Fialmete aplicaríamos la RCD sobre A, B y C. 43

44 Ejercicios Verificació (III) Verifica los siguietes programas: /*true */ if! par x x =x 1 ; /* par x */ /* x=a y */ if y 0 x =x a ; y =y 1; } else x =x a ; y =y 1; } /* x=a y */ /* umpares=ℵi 1 i k i mod 2=0 */ if k % 2==0 umpares=umpares 1 ; k=k 1; /* umpares=ℵi 1 i k i mod 2=0 */ 44

45 Descompó los siguietes programas: Departameto de L.S.I /* */ if B A 1 ; else A 2 ; A 3 ; } /* */ /* */ A 1 ; if B A 2 ; A 3 ; /* */ 45

46 Solucioes propuestas Verificació (III) 1. /*true */ /* */ if! par x B x =x 1 ; A 1 /* par x */ /* */ A def B true def! par x 1. true! par x B /* B*/ A 1 /* */ /*true! par x */ x=x 1 ; /* */ 2. true! par x par x 1 3. /* par x 1 */ x =x 1; /* par x */ AA 4. /*true! par x */ x=x 1; /* par x */ RCN 2,3 B B true par x par x 5. true par x par x 6. /* */ if B A 1 ; /* */ RCD 1,4,5 2. /* x=a y */ if y 0 x =x a ; y =y 1; } else x =x a ; y =y 1; } /* x=a y */ La descomposició del programa será la siguiete: A def B B /* B */ A 1 ; A 2 ; /* */ B.1 /* B */ A 1 ; /* 1 */ B.2 /* 1 */ A 2 ; /* */ C /* B */ A 3 ;A 4 ; /* */ C.1 /* B */ A 3 ; /* 2 */ C.2 /* 2 */ A 4 ; /* */ 46

47 A def B 1. x=a y def y 0 B.1 /* B */ A 1 ; /* 1 */ Departameto de L.S.I. 2. x=a y y 0 x a= a y a x a=a y 1 3. /* x a=a y 1 */ x =x a; /* x=a y 1 */ 1 AA 4. /* B*/ A 1 ; /* 1 */ RCN 2,3 B.2 /* 1 */ A 2 ; /* */ 5. /*x=a y 1 */ y =y 1 ; /* x=a y */ AA B /* B*/ A 1 ; A 2 ; /* */ 6. /* B*/ A 1 ; A 2 ; /* */ RCP 4,5 C.1 /* B */ A 3 ; /* 2 */ 7. x=a y y 0 x a= a y a x a=a y 1 8. /* x a=a y 1 */ x =x a; /* x=a y 1 */ 2 AA 9. /* B */ A 3 ; /* 2 */ RCN 7,8 C.2 /* 2 */ A 4 ; /* */ 10. /* x=a y 1 */ y =y 1 ; /* x=a y */ AA C /* B */ A 3 ; A 4 ; /* */ 11. /* B */ A 3 ; A 4 ; /* */ RCP 9, /* */ if B A 1 ; A 2 ; }else A 3 ; A 4 ;} /* */ RCD1,6,11 3. /* umpares=ℵi 1 i k i mod 2=0 */ if k % 2==0 umpares=umpares 1 ; A 1 k=k 1; A 2 /* umpares=ℵi 1 i k i mod 2=0 */ La descomposició del programa será la siguiete: A.1 def B A /* */ if B A 1 ; /* 1 */ A.1 def B A.2 /* B */ A 1 ; /* 1 */ A.3 B 1 B /* 1 */ A 2 ; /* */ 1. umpares=ℵi 1 i k i mod 2=0 def k mod 2=0 47

48 A.2 /* B */ A 1 ; /* 1 */ umpares=ℵi 1 i k i mod 2=0 k mod 2=0 umpares 1=ℵi 1 i k i mod 2=0 /*umpares 1=ℵi 1 i k i mod 2=0 */ umpares=umpares 1; /*umpares=ℵi 1 i k i mod 2=0 */ 1 AA /*umpares=ℵi 1 i k i mod 2=0 k mod 2=0 */ umpares=umpares 1; /*umpares=ℵi 1 i k i mod 2=0 */ RCN 2,3 5. A.3 B 1 umpares=ℵi 1 i k i mod 2=0 k mod 2=0 umpares=ℵi 1 i k i mod 2=0 A /* */ if B A 1 ; /* 1 */ 6. /* */ if B A 1 ; /* 1 */ RCD 1,4, B /* 1 */ A 2 ; /* */ umpares=ℵi 1 i k i mod 2=0 umpares=ℵi 1 i k 1 i mod 2=0 /*umpares=ℵi 1 i k 1 i mod 2=0 */ k=k 1 ; /*umpares=ℵi 1 i k i mod 2=0 */ AA /*umpares=ℵi 1 i k i mod 2=0 */ k=k 1; /*umpares=ℵi 1 i k i mod 2=0 */ RCN 7,8 A /* */ if B A 1 ; A 2 ; /* */ 10. /* */ if B A 1 ; A 2 ; /* */ RCP 6,9 4. /* */ if B A 1 ; else A 2 ; A 3 ; } /* */ 48

49 A def B B /* B */ A 1 ; /* */ C /* B */ A 2 ;A 3 ; /* */ C.1 /* B */ A 2 ; /* 1 */ C.2 /* 1 */ A 3 ; /* */ 5. /* */ A 1 ; if B A 2 ; A 3 ; /* */ A /* */ A 1 ; /* 1 */ B /* 1 */ if B A 2 ; /* 2 */ B.1 1 def B B.2 /* 1 B*/ A 2 ; /* 2 */ B.3 1 B 2 C /* 2 */ A 3 ; /* */ 49

50 3.9 Iteracioes Ua iteració realiza ua labor a base de repetir u cojuto de istruccioes que: Modifica el valor de las variables Coserva algua relació etre ellas, ua propiedad ésta: Ates de euciar la regla de iferecia que os permitirá verificar iteracioes como /* */ while B I ; /* */ Veremos cuáles so esas propiedades que se matiee e todas las iteracioes, el ivariate Cocepto de Ivariate U ivariate es ua propiedad, u predicado que o cambia, que se cumple ates (y al fial) de cada ejecució de ua iteració. No se trata de cualquier propiedad que se coserve sio de aquélla que caracterice y establezca la semática del bucle y su efecto. Ua vez deducido el ivariate (INV), las asercioes itermedias será las siguietes: /* */ /* INV */ while B /* INV B */ I ; /* INV */ } /* INV B */ /* */ El ivariate, como se puede ver e la figura superior, se cumplirá ates del bucle, al iicio de cada iteració (dode además se cumplirá la codició B), al fial de cada iteració y después del bucle (dode además se cumplirá la egació de B). Veamos ahora uos ejemplos de bucles y sus respectivos ivariates. 50

51 Ejemplo 1: Examiado el siguiete programa: /* x=a y=b 0*/ /* */ while y!=0 x =x 1; y =y 1; /* x=a b*/ /* */ Podemos deducir que la pricipal propiedad que se matiee e todas las iteracioes será que la suma de x e y será costate, ya que e el bucle icremetaremos e uo x y decremetaremos e uo y, es decir, le sumamos a ua variable lo que le restamos a la otra. Por lo tato, siempre se cumplirá x y=a b. Además, podremos saber cuál será el rago de valores que tomará y. Iicialmete, tedrá u valor b positivo. E cada iteració se decremetará e uo, y se seguirá iterado hasta que y valga 0. Gracias a esto, podremos afirmar que siempre se cumplirá y 0. y 0 o sería suficiete, ya que el ivariate tambié se tiee que cumplir cuado salgamos del bucle, y se saldrá cuado y valga 0. Podríamos itetar delimitar el rago de valores de x, pero sólo os iteresará el de y, ya que es quie os ayudará (por aparecer e la codició B) a deducir si el bucle termiará e u úmero fiito de pasos (termiació, lo veremos más adelate). Por lo tato, el ivariate será el siguiete: /* INV */ /* x y=a b b y 0*/ Aplicádolo al esquema ateriormete presetado, sabremos que siempre se cumplirá: /* x=a y=b 0*/ /* */ /* x y=a b y 0*/ /* INV */ while(y!=0) /* x y=a b y 0 y 0 */ /* INV B*/ x =x 1; y =y 1; /* x y=a b y 0*/ /* INV */ } /* x y=a b y 0 y=0*/ /* INV B*/ /* x=a b*/ /* */ 51

52 Ejemplo 2: Examiado el siguiete programa: /* suma=0 k=1*/ /* */ while k suma=suma A [k]; k=k 1; /* suma= A[i]*/ /* */ Por ua parte, podremos deducir que e suma tedremos siempre la suma de los k primeros elemetos del vector. Como, detro del bucle, primero se suma el k-ésimo elemeto y después se icremeta k, al iicio del bucle tedremos la suma hasta k-1. Siempre se k 1 cumplirá por lo tato suma= A[i ]. Es importate aseguraros que la propiedad tambié se cumpla ates de etrar e el bucle. Como k es 1 iicialmete, si sustituímos k por su valor iicial e el ivariate, el sumatorio tedrá domiio vacío (desde 1 hasta 0) por lo que suma deberá ser 0, y eso lo sabemos por la precodició. Por otra, os iteresará otra vez aseguraros de que se saldrá del bucle e u úmero fiito de pasos, por lo que trataremos de delimitar el rago de k, que será la variable que determiará si seguimos o o iterado. Iicialmete, k valdrá 1, cada vuelta se icremetará e uo, y se saldrá cuado k sea mayor que ( cuado valga +1). Por lo tato, el rago de valores que tomará k será [1..+1], que expresado e LPO será 1 k 1. El ivariate será pues: k 1 /* INV */ /* suma= A[i] 1 k 1*/ 52

53 Ejemplo 3: Cambiado el orde e que se hace las sumas, tedremos éste otro programa: /* suma=0 k=0 */ /* */ while k k=k 1; suma=suma A [k]; /* suma= i =1 A[i]*/ /* */ E este otro ejemplo, como primero se icremeta el ídice y luego se suma, tedremos e la variable suma, al iicio de cada iteració, la suma de los k primeros elemetos, por lo que siempre se cumplirá suma= A[i ]. Igual que e el caso aterior, comprobaremos que tambié se cumpla ates de etrar e el bucle. E este caso, k será 0, por lo que el sumatorio (desde 1 hasta k) tedrá domiio vacío, y como suma será 0, se cumplirá el ivariate. Respecto al rago de k, podremos afirmar que siempre estará e [0..], ya que iicialmete es 0, cada vuelta se icremeta e uo y cuado se salga del bucle valdrá, por lo que 0 k. El ivariate será por lo tato: k /* INV */ /* suma= k A[i ] 0 k */ 53

54 3.9.2 Regla del While (RWH) Para verificar la correcció parcial de u programa co iteracioes como la siguiete: /* */ while B I ; /* */ Utilizaremos la Regla del While (RWH), que se eucia de la siguiete maera: INV, INV def(b), /* INV B */ I /* INV */, INV B /* */ while (B) I ;/* */ RWH Al igual que co la RCD, trataremos de eteder ituitivamete qué sigifica cada ua de las propiedades ecesarias para aplicar la RWH: INV : Como hemos dicho, el ivariate se cumplirá ates de etrar e el bucle por primera vez, por lo que la aserció aterior al bucle tiee que implicar que se cumpla. INV def B : Ates de evaluar la codició (ates de etrar e el bucle y al fial de cada iteració) siempre se cumplirá el ivariate, por lo que tiee que defiir B, tiee que garatizar que la evaluació de B o pueda dar u resultado iesperado o error. /* INV B */ I /* INV */ : Ates de cada iteració se cumplirá tato el ivariate como la codició B, por lo que tedremos que verificar que después de ejecutar el cuerpo del bucle (I), siempre se verifique el ivariate al fial del mismo. INV B : Cuado la evaluació de la codició B dé falso, se tedrá que verificar. Al evaluar la codició siempre se cumplirá el ivariate y, la última vez que se evalúe, retorará falso. Sabiedo esto, teemos que deducir que siempre se satisfará la post. Veamos ahora uos ejemplos de cómo aplicar la RWH. 54

55 Ejemplo 1: Para el siguiete programa: /* x 1 y=1*/ while y y x y =y 1; } /* k 1 k y k k x */ Primero trataremos de determiar cuál es el ivariate. Si estudiamos el programa veremos que se irá icremetado la variable y e uo hasta que y*y sea igual a x. Es decir, al fial del bucle tedremos e y el meor úmero que cumplirá y y x. Por ua parte, sabremos que si seguimos e el bucle, siempre se cumplirá que iguo de los valores que haya teido y cumplirá y y x, porque de otra maera, ya habríamos salido del bucle. Por lo tato, siempre se cumplirá k 1 k y k k x, desde la primera hasta la última vuelta. E este caso, a diferecia de los ejemplos sobre ivariates, o os resultará ecesario icluir iformació sobre el rago de y (la variable que determiará el fial del bucle) ya que la codició o puede dar u resultado idetermiado. Por lo tato, el ivariate será el siguiete: /* INV */ k 1 k y k k x Ahora cooceremos alguas de las asercioes itermedias del programa: /* */ /* x 1 y=1 */ /* INV */ /* k 1 k y k k x */ while y y x /* INV B */ /* k 1 k y k k x y y x */ y =y 1; /* INV */ /* k 1 k y 1 k k x */ } /* INV B */ /* k 1 k y k k x y y x */ /* */ /* k 1 k y k k x */ Al ser el programa u úico while, ates de aplicar la RWH, deberemos verificar úicamete las cuatro propiedades ecesarias: A INV, B INV def B, C /* INV B */ I /* INV */ y D INV B. 55

56 A INV 1. x 1 y=1 k 1 k y k k x ya que el domiio 1 k 1 es vacío. B INV def B 2. k 1 k y k k x def y y x C /* INV B */ A 1 ; /* INV */ k 1 k y k k x y y x k 1 k y k k x k 1 k y 1 k k x /* k 1 k y 1 k k x */ y =y 1; /* k 1 k y k k x */ /* */ AA /* k 1 k y k k x y y x*/ y =y 1; /* k 1 k y k k x */ /* */ RCN 3,4 D INV B 6. k 1 k y k k x y y x k 1 k y k k x y y x /* PSI */ Fialmete, aplicamos la RWH sobre las cuatro propiedades: 7. /* */[while B A 1 ;]/* */ RWH 1,2,5,6 56