Contexto…

Métodos Formais Sistemas cada vez maiores, mais

di/ceis. Mas não há melhora de
Rohit Gheyi métodos, na mesma taxa.

Métodos Formais História

•  Foco: melhorar este cenário Verificação de programas
Dijkstra Hoare
•  Toda a=vidade que conte com representações –  Hoare’s axioma=c method (1969)
–  Dijkstra’s weakest precondi=ons (1975)
matemá8cas do so@ware
–  Especificação formal
–  Análise formal
–  Prova de Teoremas
–  Verificação de modelos

3 4

Linguagem Especificação Formal Vantagens...

•  Sintaxe e semân=ca bem definida
•  Matemá=ca Análise de especificações
–  Teoria dos conjuntos Não tem Ambigüidade
–  Álgebra
Diminuir erros
–  Lógica

5 6
Limitações... Es=los de Especificação

Escalabilidade
Orientados a Propriedades ou Algébricas
Custo alto
Baseados em Modelos

7 8

Especificação Formal Algébrica Estrutura

•  Descreve •  Conjunto de nomes de =pos (sorts)
–  Operações e relacionamentos •  Descrição
•  Exemplos •  Conjunto de funções
–  Seqüencial: Larch, OBJ •  Conjunto de axiomas (semân=ca)
–  Concorrente: Lotos

9 10

•  Tipo: pilhaInt
Exemplo •  Descrição: Pilha de Inteiros Esp. Formal Baseada em Modelos
•  Funções
vazia: -> pilhaInt •  Construções matemá=cas
push: int pilhaInt -> pilhaInt –  Conjuntos e seqüências
pop: pilhaInt -> pilhaInt •  Operações são expressas como modificam o
top: pilhaInt -> int estado
eh_vazia: pilhaInt -> boolean •  Exemplo
•  Axiomas –  Seqüencial: Z, VDM, B, Alloy
pop (push (i, p)) = p –  Concorrente: CSP, Redes de Petri
top (push (i, p)) = i
eh_vazia (p) = (p = vazia)
11 12
Exemplo: Z Par=al
Schema

O que fazer com a

Func=on
Given Sets

especificação?
Operações

Estado Espec
Posterior

13 14

Verificação Formal Principais Estratégias...

•  Permite construção de produtos mais
complexos
–  Corte de custos de testes, manutenção Prova de Teoremas
•  Propósitos Model checking
–  Provar corretude em relação a especificações
–  Achar bugs em so@ware

15 16

Prova de Teoremas Ferramenta: Isabelle

•  Garante uma propriedade através da provas
de teoremas
–  Vantagens
–  Desvantagens

17 18
 Model Checking Exemplo: CSP
•  Evita provas completas, por automa=zação
–  enumeração de todos os estados possíveis do
sistema
Máquina =
–  algoritmos eficientes para explorar os estados
moeda50 -> agua -> Máquina |
possíveis
moeda1 -> suco -> Máquina)
•  Problema principal
–  Programas concorrentes possuem testes em geral
caríssimos e improdu=vos

19 20

Ferramenta: FDR Métodos Formais na Prá=ca

•  Praxis UK
–  espec formal + análise está=ca + ferramentas
–  menor taxa de defeitos na indústria
•  Microso@’s SLAM
–  model checking em device drivers do Windows
•  Amazon
–  Bugs de concorrência e tolerância a falhas
–  hup://blog.acolyer.org/2014/11/24/use-of-formal-
methods-at-amazon-web-services/
•  Alloy
–  Encontrar bugs em ferramentas de refatoramento
21 22

•  Linguagem de Especificação Formal

•  Provador de teoremas
•  Plugin emacs (linux, mac,...)

PVS

23 24
 Exemplo Checagem de Tipos
Linguagem fortemente =pada

25 26

Como provar o teorema? Prova... Sequent

Calculus

Comandos de prova:
skosimp, expand, assert,
grind, instan=ate, lemma,...

27 28

hup://pvs.csl.sri.com/

29 30
 Linguagem de especificação formal para Java
–  para especificar o comportamento
–  para registrar decisões de projeto e
implementação
Linguagem de anotações (asserções)
–  Pré-condição
–  Pós-condição
–  Invariantes
JML
31 32

Exemplo
Design by
Contract public class Conta {
private String numero;
private /*@ spec_public @*/ float saldo;
//@ invariant saldo >= 0
Pré-condição Anotações
Cliente deve sa=sfazer restrições antes da chamada do método //@ requires valor > 0
Pós-condição //@ ensures saldo = \old(saldo-valor)
Dado que a entrada sa=sfaça, o desenvolvedor deve garan=r public void debitar(float valor); …
condições ao término da chamada }
Invariante
Uma restrição que não varia ao longo da execução
33 34

Anotações Invariantes
public class Conta {
•  Comentários em Java imediatamente seguidos private /*@ spec_public @*/ float saldo;
de `@’ não são comentários para JML, mas // invariant saldo >= 0
início de uma anotação
//@requires valor > 0
•  Marcadores de anotação //@ensures saldo = \old(saldo-valor)
–  //@ public void debitar(float valor) { …
–  /*@ e @*/ }
•  Obs: não pode haver espaço antes de `@’ São propriedades que devem ser preservadas
durante a execução, mesmo ao lançar exceções.

35 36
 Pré e Pós Condições Pós-condição: exceções
/*@
@ requires valor >= 0;
/*@
@ ensures true;
@ requires valor >= 0;
@ signals (SaldoInsuficienteExcep=on e)
@ ensures saldo == \old(saldo)-valor &&
@ valor > saldo &&
\result == saldo;
@ saldo == \old(saldo) &&
@*/
@ e.getMo=vo() == QUANTIA_ALTA;
public int debitar(int valor) {…}
@*/
public int debitar(int valor)
throws SaldoInsuficienteExcep=on {…}

37 38

Quan=ficadores
Documentação Warnings

(\forall T x; P; Q) = ∧{Q | x ∈ T ∧ P} JMLDoc /*@ ESC/Java

@ requires saldo >= 0;
@ assignable saldo …
@*/
(\exists T x; P; Q) = ∨{Q | x ∈ T ∧ P} JMLUnit
public int debitar(int valor)
JMLc

Teste de Unidade Classe Anotada

39 40

Run=me Asser=on Checking Código do JMLc

•  Asserções JML são traduzidas para checagens public void checkInv$Pessoa(String rac$msg) { …
em tempo de execução boolean rac$b = true;
try {
•  Caso alguma asserção seja violada, uma rac$b = (this.spec$altura$Pessoa() >= 0);
exceção será lançada } …
–  Pode ser problema no código if (!rac$b) {
–  Pode ser problema na especificação throw new JMLInvariantError("Pessoa", …);
}
•  Compilador jmlc }

41 42
 JMLObjectSet Verificação de Programas

Espec

Assegura consistência da implementação com

especificação, para todas entradas possíveis

Imple

hup://www.eecs.ucf.edu/~leavens/JML-release/javadocs/org/jmlspecs/models/JMLObjectSet.html
43 44

Exercício Problema
•  O programa está em conformidade com a Especificação
/*@ requires valor > 0;
especificação? @ ensures this.altura >= \old(this.altura);
public class Pessoa { @*/

private /*@ spec_public @*/ int altura; Exemplo
Pessoa p1 = new Pessoa();
/*@ requires valor > 0; p1.setAltura(2); // pré-condição: 2 > 0
@ ensures this.altura >= \old(this.altura); // pós-condição: 2 >= 0
@*/ p1.setAltura (1); // pré-condição: 1 > 0
public void setAltura(int valor) {
this.altura = valor; // pós-condição: 1 >= 2
}
}
45 46

Alloy

hup://www.eecs.ucf.edu/~leavens/JML/

47 48
Vantagens... Alloy
É uma linguagem de especificação formal
Análise de especificações •  Lógica
–  Lógica de 1a ordem
Ambigüidade
–  Cálculo Relacional
Falta/excesso de informação •  Linguagem
Diminuir erros –  Sintaxe
•  Análises
–  Exaus=va até um escopo, usando SAT Solvers
49 50

Exemplo Assinaturas e Relações

•  Uma assinatura declara um conjunto de objetos
module banco
•  Uma relação relaciona elementos entre
accs sig Banco {
Bank Account conjuntos. As relações são globais.
contas: set Conta
} sig A {
SavAcc ChAc c sig Conta {} r: set B,
sig ContaCorr extends Conta {} s: one C
sig ContaPoup extends Conta {} }
sig B, C {}

51 52

Herança Mul=plicidades
•  B herda as relações e fórmulas sobre a A sig A { sig A { sig A {
•  Em Alloy, A tem acesso as relações de B r: set B r: one B r: lone B
} } }
sig A { … } sig B {} sig B {} sig B {}
sig B extends A {
… r r r
}

B⊆A

53 54
 Exercício Exemplo: Fatos
module banco
•  Especifiquem o diagrama de classes a seguir sig Banco {
contas: set Conta
em Alloy. accs
Bank Account }
accs
sig Conta {}
Bank Account
sig ContaCorr extends Conta {}
SavAcc ChAc c
custs
owne r
sig ContaPoup extends Conta {}
1 fact AccPar==on {
Customer ChAcc SavAcc Conta = ContaCorr + ContaPoup
}
Toda conta ou é poupança ou é corrente

55 56

Fatos Cardinalidade
•  Declara um conjunto de invariantes do •  #
–  #exp = 10
modelo –  exp tem exatamente 10 elementos
•  one
fact nome { –  one exp
f1 –  exp resulta em um elemento
Conjunção •  some
f2 … f1 and f2 and ... –  some exp
} –  exp possui algum elemento
•  no
–  no exp
–  exp não possui elemento

57 58

Exercício 1 Operadores de Conjuntos

•  Especifique os seguintes fatos sig A { •  União (U)
r: set B –  A+B
–  a relação r não possui relacionamentos. }
•  Interseção ( )
U
–  O conjunto A possui 10 elementos sig B {} –  A&B
–  O conjunto B possui algum elemento fact card { •  Diferença ( ⁄ )
no r –  A-B
r #A = 10 •  Subconjunto (⊆)
some B –  A in B
} •  Negação (!)
–  ! (A in B)

59 60
 Operadores Lógicos Quan=ficação
•  Conjunção (∧)
–  P and Q
•  Universal
–  P && Q –  all x:A | p(x)
•  Disjunção (∨) –  Para todos os objetos x do =po A, tal que p(x) é
–  P or Q verdade
–  P || Q •  Existencial
•  Implicação (⇒) –  some x:A | p(x)
–  P => Q
–  Existe um objeto x do =po A, tal que p(x) é
•  Biimplicação (ó) verdade
–  P <=> Q

61 62

Exercício Exemplo
•  Especifiquem os fatos:
module banco
–  Todos os bancos possuem pelo menos uma conta sig Banco {
–  Existe um banco que possui pelo menos uma contas: set Conta
conta }
sig Conta {}
fact Exemplo {
all b: Banco | some b.contas
some b:Banco | some b.contas
}

63 64

Operadores Exemplo
•  Join (.)
–  Composição relacional sig Pessoa {
–  (a,b).{(b,c), (d,e), (b,f)} = {(a,c), (a,f)} pais: set Pessoa
}
•  Transpose (~)
–  Reversa
–  Se r = {(b,c), (d,e)}, ~r = {(c,b), (e,d)}
•  Transi=ve Closure (* e ^) Como expressar
–  Aplicação de r uma ou mais vezes todos os ancestrais?
–  Relações binárias de =pos relacionados
–  *r e ^r

65 66
 Predicados Exemplo
•  Declara um conjunto de fórmulas •  O predicado a seguir adiciona uma conta c a
um banco b, resultando em um banco b’.
•  Podem ser usados em fatos, asserções,
predicados, funções module banco
sig Banco {
•  Ajuda a especificar operações contas: set Conta
}
pred nome[a:A] { sig Conta {}
// fórmulas pred adiciona[b,b’:Banco, c:Conta] {
} b’.contas = b.contas + c
}

67 68

Exercício
•  Faça um predicado que represente a remoção
de uma conta de um banco.

module banco Qual o grande

sig Banco {
contas: set Conta diferencial de Alloy?
}
sig Conta {}
pred remove[b,b’:Banco, c:Conta] {
b’.contas = b.contas - c
}

69 70

Ferramenta Análises
•  Run
–  Encontra uma instância válida para o predicado ou
função
–  Sa=sfaz aos invariantes do modelo e as fórmulas
do predicado ou função
•  Check
–  Checa em um dado escopo se as fórmulas de um
asserção são válidas a par=r da especificação
(todos os casos)

71 72
 Exemplo run Exemplo check
•  O escopo 2 indica no máximo 2 elementos para
todas as assinaturas
•  Checa uma propriedade no escopo
•  Encontre uma instância válida para adicionar Átomo
•  Todos os bancos possuem uma conta?
module banco module banco
sig Banco { sig Banco {
contas: set Conta contas: set Conta
} }
sig Conta {} sig Conta {}
pred adiciona[b,b’:Banco, c:Conta] { assert todoBancoTemConta {
b’.contas = b.contas + c all b:Banco | some b.contas
} }
run adiciona for 2 Alloy Analyzer check todoBancoTemConta for 2

73 74

Exercício 1 Exercício 2
•  Considerem o modelo a seguir e façam •  Especifique parte do meta-modelo de Java em
análise. Quantas instâncias válidas tem no Alloy.
dado escopo?
–  O obje=vo é entender que a análise é exaus=va
em um dado escopo.

sig A {}
pred show[] {}
run show for 5

75 76

Exercício 3
•  O que o modelo a seguir representa?

module x Se uma especificação

sig A {
r: one B es=ver inconsistente,
}
sig B {} o que fazer?
fact {
some a:A | no a.r
}

77 78
 Core Unsat Exemplo
Tem alguns solvers que ajudam
module inconsistente
sig A {
r: one B
}
sig B {}
fact {
some a:A | no a.r
}
pred show[] {}
run show

79 80

SAT Solvers Constraint Solvers

•  A and B •  x>0 and y<10
•  Exemplo •  Exemplo
–  Berkmin –  CVC3
–  Mini SAT •  Aplicações
•  Compe=ções –  Execução Simbólica
–  SAT compe==on

81 82

Instalação Exercício
•  Home Page •  Façam a especificação em Alloy do projeto.
–  hup://alloy.mit.edu
•  Requer JRE
•  Rodar
–  java –jar alloy.jar
•  API
–  hup://alloy.mit.edu/alloy4/api.html

83 84
 Referências

Capítulo 10

85