1 Refinamento de Ações

Transcrição

1 Renamento de Ações
Para provar que o renamento é correto, devemos provar que a ação principal do processo abstrato é renada pela ação principal do processo concreto.
Intuitavamente, ao provar o renamento das ações principais, provamos que o
sistema têm o seu comportamento renado.
Init1 ; (µ X • (
(tick → (VerificarVolumeTanque1
; X ))
;
(DinamicaExecucao1
;
PassoExecucao1 )))
v
((PocosInit ; (µ X • RunPocos ; X ))
|[{indexPocoTeste, pocos1 } | PocoSync | {modo1 , valvulaEntrada, valvulaDrenagem,
dutos1 , indexTeste, alturaFluido, arqueamento, tc1 , te1 ,
altA1 , altB1 , altC1 , altD1 , altE1 , abertA1 , abertB1 ,
abertC1 , abertD1 , abertE1 , abertF1 }]|
(SistemaInit ; (µ X • RunSistema ; X ))) \ PocoSync
O primeiro passo do renamento é quebrar a operação
composta por
PocosInit
e
SistemaInit
Init1
na sequência
utilizando a lei B.6. Esta lei opera sobre
um esquema S que contém duas partições disjuntas, transformando-o numa
sequência de operações que atuam nestas partições. Por concisão, não iremos
mostrar as obrigações de provas geradas, apesar das mesmas serem provadas
trivialmente.
≡
[B.6]
PocosInt
;
SistemaInit
;
(µ X • (
;
;
(DinamicaExecucao1
;
PassoExecucao1 )))
X ))
No passo seguinte, devemos quebrar a recursão principal em duas recursões
paralelas. Essa transformação é realizada a partir da aplicação da lei B.31. Essa
lei quebra a recursão única em duas recursões, uma responsável pelo comportamento do conjunto de poços e a outra, pelo resto do sistema.
v
[B.31]
PocosInt
;
SistemaInit
(µ X • RunPocos
;
;
(
X)
|[{indexPocoTeste, pocos1 } | PocoSync | {modo1 , valvulaEntrada, valvulaDrenagem,
dutos1 , indexTeste, alturaFluido, arqueamento, tc1 , te1 ,
altA1 , altB1 , altC1 , altD1 , altE1 , abertA1 , abertB1 ,
abertC1 , abertD1 , abertE1 , abertF1 }]|
(µ X • RunSistema
;
X)
) \ PocoSync
1
Note que a aplicação da lei, é validadada mediante a prova do lema 2.1, dada
na sessão 2. No intuito de tonar as aplicações de leis mais claras, não iremos
mostrar nas futuras aplicações, os conjuntos em que cada partição atua e o
canal de comunicação,
k
PocoSync .
Ao invés, será apresentando apenas o símbolo
para indicar a paralelização.
O próximos passos terão o objetivo de mover as inicializações e as par-
tições na ação paralela, de forma que cada inicialização opere sobre uma partição especíca.
de
PocoSync
Além disso, primeiramente, devemos mover a ocultabilidade
de forma que a mesma atue sobre toda a expressão.
Como as
inicializações não possuem nenhum canal, a OP gerada durante a aplicação é
trivialmente descartada.
v
[B.20, B.22]
(PocosInt
;
SistemaInit
(µ X • RunPocos
;
;
X)
k
;
X)
) \ PocoSync
Após a expansão, como último passo do renamento, devemos mover as
operações de inicialização para o lado das recursões das partições. Como cada
operação de inicialização opera apenas nas respectivas variáveis das partições, a
lei B.24, pode ser aplicada. Esta lei é aplicada duas vezes, removendo
e
SistemaInit
PocosInit
da ação sequêncial e inserindo-as na ação paralela.
≡
[B.24]
(
(PocosInit
;
(µ X • RunPocos
;
X ))
k
(SistemaInit
;
;
X ))
) \ PocoSync
O renamento é concluído com sucesso. No entanto, o lema 2.1 ainda não foi
provado. Na próxima sessão, apresentamos a prova do lema, sendo esta, parte
fundamental do processo de renamento.
2 Provando o lema 2.1
Partimos do termo inicial do renamento. Observando o lema 2.1, percebemos
que as ações recursivas de
RunPocos
e
RunMin
aparecem nos dois lados do re-
namento, assim devemos deixar a primeira expressão na forma da composição
paralela dessas ações. Assim, o plano de prova consiste em provar individualmente o renamento de cada ação que foi paralelizada entre as partições de
poços e o sistema, substituindo na expressão inicial, o resultado desses renamentos.
2
Lemma 2.1
(tick → (VerificarVolumeTanque1 ; (DinamicaExecucao1 ; PassoExecucao1 )))
;
((µ X • RunPocos ; X )
k
(µ X • RunSistema ; X )
)
v
((µ X • RunPocos ; X )
k
(µ X • RunSistema ; X )
) \ PocoSync
Em seguida, distribuiremos as ações nas respectivas partições da composição
paralela. O resultado deixará a primeira expressão como as chamadas recursivas das ações
RunPocos e RunSistema . Ao mesmo tempo, iremos expandir o
PocoSync sobre toda a ação. Finalizaremos a prova com a lei
ocultamento de
de desdobramento de recursão. No caso, iremos dobrar a recursão.
Alinhamento1
vA
(Alinhar
|[α(SistemaSt) | PocoSync | α(PocosSt)]|
TratarAlinhamento
) \ PocoSync
A primeira ação a ser renada é
Alinhamento1 .
Partiremos do schema da
operação. Note que o schema faz referência ao estado de
State1 .
No renamento,
desejamos quebrar esse conjunto de componentes, nas partições de
SistemaSt .
PocosSt
e
Assim, temos o seguinte termo:
[i ? : N; ∆State1 | i ? ∈ dom pocos1
{i ?} −
C pocos1 = {i ?} −
C pocos10 ∧ (pocos1 (i ?)).status = PRODUZINDO
0
indexTeste1 = i ? ∧ indexPocoTeste 0 = i ? ∧ (pocos 0 (i ?)).status = TESTANDO
θState1 \ (pocos, indexTeste) = θ(State1 )0 \ (pocos, indexTeste)]
Utilizando Cálculo de schemas de Z que inclui transformação de predicados
e normalização, dividimos as declarações do schema e seus predicados em duas
partições.
predicado
Parar quebrar o alinhamento em ações independentes, incluímos o
i ? ∈ dom dutos1
uma vez que
dutos1
e
pocos1
compartilham o mesmo
domínio. Após essas transformações, obtemos o seguinte termo.
[i ? : N; ∆PocosSt; ∆SistemaSt |
i ? ∈ dom pocos1
(pocos1 (i ?)).status = PRODUZINDO
indexPocoTeste 0 = i ? ∧ (pocos 0 (i ?)).status = TESTANDO
{i ?} −
C pocos1 = {i ?} −
C pocos10
i ? ∈ dom dutos1 ∧ indexTeste10 = i ?
θSistemaSt \ (indexTeste) = θ(SistemaSt)0 \ (indexTeste)]
3
A partir desse termo, podemos aplicar a lei
B.5 quebrando a operação
Alinhamento1 em uma sequência de duas operações: uma responsável por alterar
os componentes em PocosSt e a outra, pelos componentes em SistemaSt . As
OPs são facilmente descartadas uma vez que as partições alteram apenas seus
próprios componentes.
vA
[B.5]
[i ? : N; ∆SistemaSt; ΞPocosSt | i ? ∈ dom dutos1
indexTeste10 = i ?
θSistemaSt \ (indexTeste) = θ(SistemaSt)0 \ (indexTeste)]
;
[i ? : N; ∆PocosSt; ΞSistemaSt | i ? ∈ dom pocos1
− pocos1 = {index ?} −
{index ?} C
C pocos10
(pocos1 (index ?)).status = PRODUZINDO
(pocos 0 (index ?)).status = TESTANDO
indexPocoTeste 0 = index ?]
Agora devemos introduzir o paralelismo entre as ações.
alizado mediante a aplicação da lei B.8.
parâmetro e a expressão
index
Esse passo é re-
Passamos o canal indicePoco como
como a nova expressão da segunda ação da com-
posição paralela (TratarAlinhamento ).
≡
(
[B.8]
[i ? : N; ∆SistemaSt; ΞPocosSt | i ? ∈ dom dutos1
indexTeste10 = i ?
θSistemaSt \ (indexTeste) = θ(SistemaSt)0 \ (indexTeste)] ; indicePoco !i → Skip
|[α(SistemaSt) | {indicePoco} | α(PocosSt)]|
indicePoco ?index → [index ? : N; ∆PocosSt; ΞSistemaSt | index ? ∈ dom pocos1
− pocos1 = {index ?} −
{index ?} C
C pocos10
(pocos1 (index ?)).status = PRODUZINDO
(pocos 0 (index ?)).status = TESTANDO
indexPocoTeste 0 = index ?]
) \ {indicePoco}
Aplicando as denições dos parágrafos
mos o seguinte termo.
A função
α(S )
Alinhar
e
TratarAlinhamento , obteS , retorna o
aplicada à um esquema
conjunto de todos os nomes dos componentes do schema.
≡
(
[Denições]
Alinhar
|[α(SistemaSt) | {indicePoco} | α(PocosSt)]|
TratarAlinhamento
4
) \ {indicePoco}
Finalmente, devemos expandir o conjunto de canais de sincronização da composição paralela. Aplicamos a Lei B.9 para adicionar os canais remanescentes
do conjunto
PocoSync .
Como os canais não são utilizados pelas partes da com-
posição paralela, a lei pode ser aplicada. Para concluir o renamento da ação,
aplicamos a lei B.28. Analogamente a aplicação anterior, a OP gerada é facilmente descartada.
≡
[B.9 e B.28]
(
Alinhar
TratarAlinhamento
) \ PocoSync
Concluímos o renamento de
de
Alinhamento1 .
Partiremos para o renamento
IniciarEnchimento1 .
IniciarEnchimento1
vA
(Encher
TratarAbrirValvula
) \ PocoSync
Para tal, iniciamos pegando a denição da operação e realizamos cálculos
de schemas de Z semelhante ao que zemos com a operação de
Alinhamento1 .
O termo resultante divide seus predicados nas duas partições já conhecidas,
PocosSt
e
SistemaSt .
[∆PocosSt; ∆SistemaSt |
valvulaDrenagem 0 .status = FECHADA
valvulaEntrada 0 .status 6= FECHADA ∧ modo10 = ENCHIMENTO
θSistemaSt \ (modo1 , valvulaEntrada, valvulaDrenagem) =
θ(SistemaSt)0 \ (modo1 , valvulaEntrada, valvulaDrenagem)
(pocos10 (indexPocoTeste)).valvula.status 6= FECHADA
C pocos1
{indexPocoTeste} −
C pocos10 = {indexPocoTeste} −
indexPocoTeste 0 = indexPocoTeste]
Mais uma vez iremos quebrar esta operação em uma sequência de operações
que atuam sobre partições disjuntas. Utilizaremos novamente a lei B.5 para esse
propósito.
vA
[B.5]
0
[∆SistemaSt; ΞPocosSt | valvulaDrenagem .status = FECHADA
valvulaEntrada 0 .status 6= FECHADA ∧ modo10 = ENCHIMENTO
5
θSistemaSt \ (modo1 , valvulaEntrada, valvulaDrenagem) =
θ(SistemaSt)0 \ (modo1 , valvulaEntrada, valvulaDrenagem)]
;
[∆PocosSt; ΞSistemaSt |
(pocos10 (indexPocoTeste)).valvula.status 6= FECHADA
C
pocos1
indexPocoTeste 0 = indexPocoTeste]
Aplicando as denições dos parágrafos
Encher
e
IniciarEnchimentoPocos .
≡
[Denições]
IniciarEnchimentoSistema
Devemos introduzir o canal
IniciarEnchimentoPocos
;
abrirValvula
na segunda parte da sequência das
operações. A lei B.18 é utilizada e como as operações não utilizam canal algum,
a OP gerada pela aplicação é facilmente descartada.
≡
[B.18]
(abrirValvula → IniciarEnchimentoPocos) \ {abrirValvula}
;
Iremos agora, expandir o ocultamento do canal
abrirValvula
para toda a
expressão semelhante o que zemos no renamento original.
≡
[B.20, B.22]
(IniciarEnchimentoSistema
;
abrirValvula → IniciarEnchimentoPocos) \ {abrirValvula}
Em seguida, devemos introduzir o paralelismo sobre o canol
abrirValvula .
Aplicamos a lei B.25.
≡
[B.25, B.22]
(
(IniciarEnchimentoSistema)
;
(abrirValvula → IniciarEnchimentoPocos
|[α(PocosSt) | {abrirValvula} | α(SistemaSt)]|
abrirValvula → Skip)
) \ {abrirValvula}
Mudaremos agora a ordem das partes da composição paralela, aplicando a
propriedade da comutatuvidade.
≡
[B.7]
(
(IniciarEnchimentoSistema)
6
;
(abrirValvula → Skip
|[α(SistemaSt) | {abrirValvula} | α(PocosSt)]|
abrirValvula → IniciarEnchimentoPocos)
) \ {abrirValvula}
Finalmente aplicamos a lei B.11 para passar a operação
para dentro da composição paralela. As OPs relacionadas a funções sintáticas
são facilmente descartadas, no entanto a OP relacionada a propriedade de divergência necessita de um vericador de modelos para vericação.
≡
[B.11]
(
((IniciarEnchimentoSistema)
;
(abrirValvula → Skip)
|[α(SistemaSt) | {abrirValvula} | α(PocosSt)]|
) \ {abrirValvula}
Analogamente ao renamento da operação
Alinhamento1 , devemos expandir
o conjunto de canais de sincronização da composição paralela. Mais uma vez,
PocoSync
TratarAbrirValvula , concluíre-
aplicamos a Lei B.9 para adicionar os canais remanescentes do conjunto
Encher
IniciarEnchimento1
e a lei B.28. Aplicando as denições de
mos o renamento de
e
≡
[B.9 e B.28]
(
((IniciarEnchimentoSistema)
;
(abrirValvula → Skip)
) \ PocoSync
≡
[Denições]
(
(Encher )
TratarAbrirValvula)
) \ PocoSync
O próximo renamento será o da operação
FinalizarTeste1 .
Devemos provar
que essa operação é renada pela composição paralela das ações
TratarFinalizar .
7
Finalizar
e
FinalizarTeste1
vA
(Finalizar
TratarFinalizar
) \ PocoSync
Não iremos apresentar detalhamente esse renamento, pois ele apresenta
IniciarEnchimento1 . ResumidaFinalizarTesteSistema e FinalizarPocos .
Em seguida iremos inserir o canal finalize na parte referente a partição dos poços.
Iremos expandir o ocultação sobre o canal finalize . Adiante, é introduzido a paralelização sobre o lado direito da sequência de operações. A operação Finalizar
os mesmos passos do renamento da operação
mente,iremos quebrar a operação em
é incorporada a composição paralela. Finalmente, adiciona-se os canais que faltam para completar o conjunto
PocoSync
dentro dos canais de sincronização da
composição paralela.
PocoDuto . Conseguimos provar com base no
Producao1 é igual a ProducaoPocos . Intuitivamente,
A última ação a ser renada é a
cálculo de schemas de Z que
as operações de produção fazem uso apenas do conjunto de poços. As outras
operações contidas na ação
PassoExecucao
não são alteradas, com exceção de
PocoDuto, pois as mesmas referenciam apenas os elementos que fazem parte do
SistemaSt .
PocoDuto1
vA
( (fluidoTeste !v → (retorno ?r → PocoDutoPocos))
|[α(PocosSt) | PocoSync | α(SistemaSt)]|
(fluidoTeste ?f 2 → (PocoDutoSistema ; (retorno !r 2 → Skip )))
) \ PocoSync
Partimos da denição da operação
PocoDuto1 .
O objetivo é quebrar em duas
operações, uma sendo responsável por alterar a sequência de poços e a outra,
possível de alterar a sequência de dutos e o resto do sistema.
[∆State1 ; vazaoTeste, volumePacote : real ; comprimento : N |
comprimento = (dutos1 (indexTeste1 )).comprimento
vazaoTeste = min{(pocos1 (indexPocoTeste)).valvula.vazao, (pocos1 (indexPocoTeste)).volume}
volumePacote = min{vazaoTeste, (dutos1 (indexTeste1 )).capacidade}
(dutos10 (indexTeste1 )).capacidade = (dutos1 (indexTeste1 )).capacidade − volumePacote
(pocos10 (indexPocoTeste)).volume = (pocos1 (indexPocoTeste)).volume − volumePacote
(dutos10 (indexTeste1 )).pacotesOleo = (dutos1 (indexTeste1 )).pacotesOleo⊕
{(comprimento 7→ (volumePacote + (dutos1 (indexTeste1 )).pacotesOleo(comprimento)))}
C pocos10
{indexTeste1 } −
C dutos1 = {indexTeste1 } −
C dutos10
0
θState1 \ (pocos1 , dutos1 ) = θ(State1 ) \ (pocos1 , dutos1 )]
Deverá haver canais de comunicação, já que os dutos necessitam acessar o
valor de uido que chega neles, enquanto que os poços devem saber se houve
8
alguma retenção de uido de modo que ele não tenha entrada no correspondente
duto e tenha retornado. Assim, introduzimos a idéia de uido e retorno no novo
esquema a partir de uma transformação no predicado do esquema original. Ao
nal desse cálculo de Z obtemos o seguinte termo.
[∆PocosSt; ∆SistemaSt; f 2, r 2 : real |
f 2 = (pocos1 (indexPocoTeste)).valvula.vazao
r 2 = max{f ! − (dutos1 (indexTeste1 )).capacidade, 0}
(pocos10 (indexPocoTeste)).volume = (pocos1 (indexPocoTeste)).volume − f 2 + r 2
C pocos10
0
indexPocoTeste = indexPocoTeste
∃ volumePacote : real ; comp : N |
volumePacote = min{f 2, (dutos1 (indexTeste1 )).capacidade}
comprimento = (dutos1 (indexTeste1 )).comprimento •
(dutos10 (indexTeste1 )).capacidade = (dutos1 (indexTeste1 )).capacidade − volumePacote
(dutos10 (indexTeste1 )).pacotesOleo = (dutos1 (indexTeste1 )).pacotesOleo⊕
{(comprimento 7→ (volumePacote! + (dutos1 (indexTeste1 )).pacotesOleo(comprimento)))}
{indexTeste1 } −
C dutos1 = {indexTeste1 } −
C dutos10
θSistemaSt \ (dutos1 ) = θ(SistemaSt)0 \ (dutos1 )]
A partir desse schema, quebramos essa operação em duas:
PocoDutoSistema ,
PocoDutoPocos
e
através da aplicação da lei B.5. Note que as operações aces-
sam valores de outras partições, esses valores serão transmitidos via comunicação
interna, no entanto, as mesmas só modicam os componentes pertecentes a suas
respectivas partições.
≡
[B.5 e Denições]
(PocoDutoSistema(f , r 2))
;
(PocoDutoPocos(f , r 2))
Mais uma vez, aplicaremos a lei B.8 para introduzir o paralelismo das ações.
≡
[B.8]
( (PocoDutoSistema(f , r 2) ; (retorno !r 2 → Skip))
|[α(SistemaSt) | {retorno} | α(PocosSt)]|
(retorno !r → PocoDutoPocos(f , r ))
) \ {retorno}
Iremos aplicar a propriedade da comutatividade, alterando a ordem em que
as ações aparecem na composição paralela.
≡
[B.7]
( (retorno !r → PocoDutoPocos(f , r ))
|[α(PocosSt) | {retorno} | α(SistemaSt)]|
(PocoDutoSistema(f , r 2)
;
(retorno !r 2 → Skip))
) \ {retorno}
9
Em seguida, adicionamos mais um canal na comunicação das partes que
fazem a composição paralela.
O objetivo é que os poços enviem o valor do
uído de teste através do canal de comunicação
fluidoTeste
para o duto.
≡
[B.10]
(
(
fluidoTeste !f → (retorno !r → PocoDutoPocos(f , r ))
|[α(PocosSt) | {retorno} ∪ {fluidoTeste} | α
(SistemaSt)]|
(fluidoTeste ?f 2 → (PocoDutoSistema(f 2, r 2)
;
(retorno !r 2 → Skip)))
) \ {retorno}
) \ {fluidoTeste}
Para terminar o renamento, fazemos às seguintes operações: Aplicamos a
lei B.27 para unir os canais que estão ocultos na composição paralela; as leis B.28
e B.9 para que a comunicação presenta na composição paralela seja realizada via
o conjunto de canais PocoSync; utilizamos as denições das ações
TratarEnvioFluido . Finalmente,
namento de PocoDuto .
e
EnviarFluido
obtemos o seguinte termo, concluindo o re-
( (EnviarFluido)
|[α(PocosSt) | PocoSync | α(SistemaSt)]|
(TratarEnvioFluido)
) \ PocoSync
Ao nal do renamento de
PocoDuto ,
a operação
PassoExecucao
terá suas
operações denidas em termos das partições, tendo o seguinte termo resultante.
Mais uma vez, utilizaremos o símbolo
k
para ocultar os componentes da par-
alelização.
(ProducaoPocos ; (producao !volProd → Skip))
; ((TanqueDreno1 ; (dreno !volDren → Skip)) ; (DutoTanque1
(TratarEnvioFluido
k
EnviarFluido
) \ PocoSync))
;
O objetivo consiste em alterar esse termo de forma que se torne a composição paralela das ações
PassoExecucaoSistema
tanto, nosso primeiro passo será trazer a operação
e PassoExecucaoPocos . PorDutoTanque1 para dentro da
composição paralela através da aplicação da lei B.11.
≡
[B.11]
(ProducaoPocos
;
;
(producao !volProd → Skip))
((TanqueDreno1
(DutoTanque1
;
;
(dreno !volDren → Skip)) ; (
TratarEnvioFluido
10
k
EnviarFluido
) \ PocoSync))
Iremos realizar uma estratégia parecida com o que zemos com
na operação
TanqueDreno ,
DuntoTanque1
realizando também a expansão do ocultamento de
PocoSync .
≡
[B.11, B.20, B.22]
((ProducaoPocos
;
;
(
((TanqueDreno1
(dreno !volDren → Skip)) ; DutoTanque1
;
;
TratarEnvioFluido
k
EnviarFluido
))) \ PocoSync
Observe que a primeira parte da composição paralela é igual a denição da
ação
PassoExecucaoSistema .
nome
Substituímos essa primeira parte pela chamada ao
e em seguida aplicamos a comutatividade para in-
serir a ação que falta para completarmos a denição da ação
≡
PassoExecucaoPocos
[B.7]
((ProducaoPocos
;
;
(
EnviarFluido
k
)) \ PocoSync
Para concluir, devemos: aplicar novamente a lei B.11, introduzindo a parte de
produção na partição de poços; aplicar comutatividade e nalmente, substituir
a denição da ação pelo nome
PassoExecucaoPocos
≡
[B.11 B.7]
(PassoExecucaoSistema
k
PassoExecucaoPocos
) \ PocoSync
Nesse momento, iremos substituir o que obtemos com relação ao renamento
de
PassoExecucao
na prova do lema. Substituímos a respectiva operação, pela
composição paralela das operações
PassoExecucaoPocos
11
e
PassoExecucaoPocos .
Aplicamos também a propriedade da associatividade sobre operações em sequência.
≡
[B.16]
(tick → (VerificarVolumeTanque1 )) ; DinamicaExecucao1
;
(
k
PassoExecucaoPocos) \ PocoSync
)
;
(
(µ X • RunPocos
;
X)
k
;
X)
)
PocoSync para
RunPocos e RunSistema . Além disso,
introduzimos Skip nas operações PassoExecucaoPocos e PassoExecucaoSistema .
Aplicando as leis B.20 e B.22 expandimos o ocultamento de
incluir também as chamadas recursivas de
≡
[B.20, B.22, B.26,]
;
(
; Skip
k
PassoExecucaoPocos
; Skip
;
(
(µ X • RunPocos
;
X)
k
;
X)
)) \ PocoSync
Agora iremos trazer
PassoExecucaoSistema para dentro da partição da comRunSistema . Para isso, inicialmente iremos retirar
PassoExecucaoSistema de suas composições paralelas.
posição paralela que contém
PassoExecucaoPocos
e
≡
[B.11]
;
;
PassoExecucaoPocos
;
Skip
k
Skip
12
;
(
(µ X • RunPocos
;
X)
k
;
X)
)) \ PocoSync
Eliminaremos a composição paralela do Skip. Primeiramente, transformamos
essa composição em Skip e depois aplicamos a lei B.26 para eliminar completamente a ação Skip.
≡
;
;
[B.26, B.12]
PassoExecucaoPocos
;
(
(µ X • RunPocos
;
X)
k
;
X)
)) \ PocoSync
Finalmente moveremos cada um dos
PassosExecucao
para dentro da com-
posição paralela. Note que devemos aplicar comutatividade da composição paralela para inserir o
na partição correta.
≡
[B.11, B.7]
;
((
(PassoExecucaoPocos
;
(µ X • RunPocos
;
X ))
k
;
;
X ))
)) \ PocoSync
PassoExecucaoPocos e PassoExecucaoSistema .
DinamicaExecucao1
pode ser renada pela composição paralela TratarRequisicaoPocos e DinamicaExecucaoSistema .
Vamos então coletar a denição de DinamicaExecucao1 substituindo algumas
ações pelo o termo resultante dos renamentos anteriores (Alinhamento1 , IniciarEnchimento1
e FinalizarTeste1 ).
Concluímos o renamento das ações
Na continuação da prova do lema, devemos provar que a ação
13
(hmodo1 = SEM TESTE i & indexP ?i → (
(Alinhar
TratarAlinhamento
) \ PocoSync))
2 (hmodo1 = CONDICIONAMENTOi & (
(htc1 6= 0i & DecrementarTc1 )
2 (htc1 = 0 ∧ alturaFluido = 0i &
(Encher
TratarAbrirValvula
) \ PocoSync)
2 (htc1 = 0 ∧ alturaFluido 6= 0i & IniciarEsvaziamento1 ))
)
2 (hmodo1 = ESVAZIAMENTOi & (
(halturaFluido = 0i &
(Encher
TratarAbrirValvula
) \ PocoSync)
2 (halturaFluido 6= 0i & Skip))
)
2 (hmodo1 = ENCHIMENTOi & (
(hte1 6= 0i & DecrementarTe1 )
2 (hte1 = 0i & IniciarDecantacao1 )
)
)
2 (hmodo = DECANTAMENTOi & Skip)
2 (fimDecant → IniciarDrenagem)
2 (hmodo1 = ABORTAGEM i & (
Finalizar |[ α(SistemaSt) | PocoSync | α(PocosSt) ]| TratarFinalizar ) \ PocoSync)
2 (hmodo1 = DRENAGEM i & (
(halturaFluido > altA1 i & AbertA1 )
2 (halturaFluido > altB1 ∧ alturaFluido ≤ altA1 i & AbertB1 )
2 (halturaFluido > altC1 ∧ alturaFluido ≤ altB1 i & AbertC1 )
2 (halturaFluido > altD1 ∧ alturaFluido ≤ altC1 i & AbertD1 )
2 (halturaFluido > altE1 ∧ alturaFluido ≤ altD1 i & AbertE1 )
2 (halturaFluido ≤ altE1 i & AbertF1 )
2 (sensorInterface → ((Coletar1 ; (saida !altOleo → Skip))
;
(Finalizar
TratarFinalizar
) \ PocoSync))
)
)
2 (abort → (
(Finalizar
14
TratarFinalizar
) \ PocoSync))
Dado o tamanho da ação, iremos renar partes da mesma, de forma a facilitar
a compreensão do processo. Depois de ter realizado os renamentos das partes,
iremos apresentar o estado atual da ação. Partiremos do renamento da seguinte
ação.
(hmodo1 = SEM TESTE i
(Alinhar
k
TratarAlinhamento
) \ PocoSync))
&
indexP ?i → (
O primeiro passo será expandir o ocultamento de
PocoSync
sobre toda a
expressão.
≡
[B.3, B.26, B.20, B.22]
&
indexP ?i → (
(Alinhar
k
TratarAlinhamento
))) \ PocoSync
Nesse momento, vamos introduzir a guarda e a comunicação do canal
sobre a ação
Alinhar
indexP
da composição paralela. Para tal, iremos incluir a ação
primitiva Skip e organizar os termos de forma que se estabeleça uma ação que
precede sequencialmente a composição paralela.
≡
[B.26, B.3, B.16]
(
;
&
indexP ?i → Skip)
(
(Alinhar
k
TratarAlinhamento)
)
) \ PocoSync
Para nalizar esse renamento, temos que incorporar a dada ação na composição paralela e em seguida, remover o Skip. Para eleminar o Skip, primeiro,
alteramos a estrutura do prex na composição sequencial (associatividade).
≡
[B.11, B.16, B.26]
((hmodo1 = SEM TESTE i
&
(indexP ?i → Alinhar ))
k
(TratarAlinhamento)
15
) \ PocoSync
Agora, vamos apresentar o renamento do comportamento do sistema quando
o mesmo está em fase de condicionamento.
(hmodo1 = CONDICIONAMENTOi & (
(htc1 6= 0i & DecrementarTc1 )
2 (htc1 = 0 ∧ alturaFluido = 0i &
(Encher
k
TratarAbrirValvula
) \ PocoSync)
2 (htc1 = 0 ∧ alturaFluido 6= 0i & IniciarEsvaziamento1 ))
)
Primeiramente, iremos distribuir a guarda que diz respeito ao modo do sistema sobre as escolhas externas.
≡
[B.4, B.2]
(hmodo1 = CONDICIONAMENTO ∧ tc1 6= 0i
&
DecrementarTc1 )
2 (hmodo1 = CONDICIONAMENTO ∧ tc1 = 0 ∧ alturaFluido = 0i
&
(Encher
k
TratarAbrirValvula
) \ PocoSync)
2 (hmodo1 = CONDICIONAMENTO ∧ tc1 = 0 ∧ alturaFluido 6= 0i
Em seguida, expandimos mais uma vez, o ocultamento de
PocoSync
&
IniciarEsvaziamento1 )
sobre
todo a expressão.
≡
[B.20, B.26, B.3, B.23]
((hmodo1 = CONDICIONAMENTO ∧ tc1 6= 0i
&
DecrementarTc1 )
&
(Encher
k
TratarAbrirValvula
))
&
) \ PocoSync
Por m, devemos introduzir a guarda na composição paralela. Esse renamento que já foi utilizado anteriormente, consiste em introduzir o Skip, utilizar a
16
propriedade da associatividade na guarda, introduzir na paralelização e realizar
o inverso dos passos iniciais para remover o Skip.
≡
[B.26, B.3, B.11, B.3, B.26]
((hmodo1 = CONDICIONAMENTO ∧ tc1 6= 0i
&
DecrementarTc1 )
2 ((hmodo1 = CONDICIONAMENTO ∧ tc1 = 0 ∧ alturaFluido = 0i
&
Encher )
k
TratarAbrirValvula
)
&
) \ PocoSync
A parte da ação
DinamicaExecucao
responsável pelo comportamento do sis-
tema na fase de esvaziamento têm no seu renamento as mesmas aplicações de
leis que o renamento anterior. Para facilitar a compreensão, não iremos nos
ater a repetição desses passos, apresentaremos apenas o termo resultante.
(
((hmodo1 = ESVAZIAMENTO ∧ alturaFluido = 0i & Encher )
k
TratarAbrirValvula)
2 (hmodo1 = ESVAZIAMENTO ∧ alturaFluido 6= 0i & Skip)
) \ PocoSync
Para renar a parte da ação
DinamicaExecucao
responsável pelo comporta-
mento do sistema em fase de abortagem, devemos: introduzir o Skip na guarda;
expandir o ocultamento de PocoSync sobre toda a expressão; aplicar a propriedade de associatividade na guarda e na operação com o Skip; Incorporar a
guarda na partição do
Sistema
na composição paralela.
≡
[B.26, B.3, B.20, B.22, B.11, B.3, B.26]
(hmodo1 = ABORTAGEM i
&
Finalizar
k
TratarFinalizar ) \ PocoSync
De forma bastante semelhante ao renamento que continha a ação paralela
responsável pelo alinhamento, realizamos o renamento sobre a nalização do
teste na fase de drenagem. Seguimos a mesma idéia: distribuição das guardas;
combinação das guardas; expansão do ocultamento de
PocoSync ;
introdução do
Skip rearranjo das guardas; introdução na composição paralela; eleminação do
Skip.
17
(
(hmodo1 = DRENAGEM ∧ alturaFluido > altA1 i & AbertA1 )
2 (hmodo1 = DRENAGEM ∧ alturaFluido > altB1 ∧ alturaFluido ≤ altA1 i & AbertB1 )
2 (hmodo1 = DRENAGEM ∧ alturaFluido > altC1 ∧ alturaFluido ≤ altB1 i & AbertC1 )
2 (hmodo1 = DRENAGEM ∧ alturaFluido > altD1 ∧ alturaFluido ≤ altC1 i & AbertD1 )
2 (hmodo1 = DRENAGEM ∧ alturaFluido > altE1 ∧ alturaFluido ≤ altD1 i & AbertE1 )
2 (hmodo1 = DRENAGEM ∧ alturaFluido ≤ altE1 i & AbertF1 )
2 ((lcircguardmodo1 = DRENAGEM i &
sensorInterface → (Coletar1 ; (saida !altOleo → Skip)) ; Finalizar )
k
TratarFinalizar )
) \ PocoSync
O renamento simples do comportamento do sistema ao receber o sinal de
aborte
resulta no seguinte termo.
(abort → Finalizar
k
TratarFinalizar
) \ PocoSync)
Mediante todos esses renamentos iremos expandir o hiding sobre toda a
ação
DinamicaExecucao
através das leis B.20 e leis B.23.
≡
[B.20, B.23]
(
((hmodo1 = SEM TESTE i
&
k
(TratarAlinhamento)
)
2 ((hmodo1 = CONDICIONAMENTO ∧ tc1 6= 0i
&
DecrementarTc1 )
2 ((hmodo1 = CONDICIONAMENTO ∧ tc1 = 0 ∧ alturaFluido = 0i
&
Encher )
k
TratarAbrirValvula)
)
2(
((hmodo1 = ESVAZIAMENTO ∧ alturaFluido = 0i
&
Encher )
k
TratarAbrirValvula)
2 (hmodo1 = ESVAZIAMENTO ∧ alturaFluido 6= 0i
)
2 (hmodo1 = ENCHIMENTOi
&
(
18
& Skip)
&
(hte1 6= 0i
&
2 (hte1 = 0i
DecrementarTe1 )
&
IniciarDecantacao1 )
))
2 (hmodo = DECANTAMENTOi
& Skip)
2 ((hmodo1 = ABORTAGEM i & Finalizar )
k
TratarFinalizar )
2(
(hmodo1 = DRENAGEM ∧ alturaFluido > altA1 i
&
AbertA1 )
2 (hmodo1 = DRENAGEM ∧ alturaFluido > altB1 ∧ alturaFluido ≤ altA1 i
&
AbertB1 )
2 (hmodo1 = DRENAGEM ∧ alturaFluido > altC1 ∧ alturaFluido ≤ altB1 i
&
AbertC1 )
2 (hmodo1 = DRENAGEM ∧ alturaFluido > altD1 ∧ alturaFluido ≤ altC1 i
&
AbertD1 )
2 (hmodo1 = DRENAGEM ∧ alturaFluido > altE1 ∧ alturaFluido ≤ altD1 i
&
AbertE1 )
2 (hmodo1 = DRENAGEM ∧ alturaFluido ≤ altE1 i
2 ((lcircguardmodo1 = DRENAGEM i
sensorInterface → (Coletar1
;
&
AbertF1 )
&
(saida !altOleo → Skip)) ; Finalizar )
k
TratarFinalizar )
)
2 (abort → Finalizar
k
TratarFinalizar
)
) \ PocoSync
Observe que as partes paralelas atuam sobre as mesmas partições e sobre o mesmo conjunto de canais de sincronização. Assim, os próximos passos
terão a nalidade de organizar as ações sobre essa comum composição paralela.
Primeiramente, vamos unir as ações que atuam na nalização do teste através
da aplicação da lei B.15.
≡
[B.14]
((hmodo1 = DRENAGEM i
&
;
2 (abort → Finalizar )
2 (hmodo1 = ABORTAGEM i
&
Finalizar )
k
TratarFinalizar )
Realizamos a mesma operação sobre a ação
19
TratarAbrirValvula .
≡
[B.14]
((hmodo1 = ESVAZIAMENTO ∧ alturaFluido = 0i
&
Encher )
&
Encher )
k
TratarAbrirValvula)
Após essas últimas transformações, a ação
DinamicaExecucao terá o seguinte
corpo.
(
((hmodo1 = SEM TESTE i & (indexP ?i → Alinhar ))
k
(TratarAlinhamento)
)
2(
(hmodo1 = ESVAZIAMENTO ∧ alturaFluido = 0i & Encher )
2 (hmodo1 = CONDICIONAMENTO ∧ tc1 = 0 ∧ alturaFluido = 0i & Encher )
k
TratarAbrirValvula)
2(
(hmodo1 = DRENAGEM i & sensorInterface → (Coletar1 ; (saida !altOleo → Skip)) ; Finalizar )
2 (hmodo1 = ABORTAGEM i & Finalizar )
k
TratarFinalizar ) 2 (hmodo1 = CONDICIONAMENTO ∧ tc1 6= 0i & DecrementarTc1 )
2 (hmodo1 = CONDICIONAMENTO ∧ tc1 = 0 ∧ alturaFluido 6= 0i & IniciarEsvaziamento1 )
2 (hmodo1 = ESVAZIAMENTO ∧ alturaFluido 6= 0i & Skip)
2 (hmodo1 = ENCHIMENTOi & (
(hte1 6= 0i & DecrementarTe1 )
2 (hte1 = 0i & IniciarDecantacao1 )
))
2 (hmodo = DECANTAMENTOi & Skip)
2 (hmodo1 = DRENAGEM ∧ alturaFluido > altA1 i & AbertA1 )
2 (hmodo1 = DRENAGEM ∧ alturaFluido > altB1 ∧ alturaFluido ≤ altA1 i & AbertB1 )
2 (hmodo1 = DRENAGEM ∧ alturaFluido > altC1 ∧ alturaFluido ≤ altB1 i & AbertC1 )
2 (hmodo1 = DRENAGEM ∧ alturaFluido > altD1 ∧ alturaFluido ≤ altC1 i & AbertD1 )
2 (hmodo1 = DRENAGEM ∧ alturaFluido > altE1 ∧ alturaFluido ≤ altD1 i & AbertE1 )
2 (hmodo1 = DRENAGEM ∧ alturaFluido ≤ altE1 i & AbertF1 )
) \ PocoSync
Intuitavamente, dividimos o conjunto dessas escolhas externas em dois grupos. O primeiro compreende as ações que já apresentam paralelismo e devemos
apenas juntar as ações sobre o mesma composição paralela, através da aplicação
da lei B.13
20
≡
[B.20, B.23]
&
2 (hmodo1 = ESVAZIAMENTO ∧ alturaFluido = 0i
&
Encher )
2 (hmodo1 = DRENAGEM i
&
;
&
Encher )
2 (hmodo1 = ABORTAGEM i
&
Finalizar )
k
(TratarAlinhamento
2 TratarAbrirValvula
2 TratarFinalizar )
O segundo grupo ainda não presenta elementos de paralelização. Eles deverão ser inseridos. Apresentaremos o renamento que insere a seguinte ação na
paralelização.
notações
A1
e
Para facilitar a compreenssão de todo processo utilizaremos as
A2
para referir as partes das ações paralelas.
(A1 k A2 ) 2 (hmodo1 = DRENAGEM ∧ alturaFluido > altA1 i
&
AbertA1 )
Os mesmos passos são utilizados para inserir os demais elementos do segundo
grupo. No processo, é adiciona um novo canal, chamado
jump
que é utilizada
para sincronização. O objetivo é que cada ação que não apresenta nenhum ele-
Sistema , deve enviar um sinal através do
Pocos para que o mesmo não que
parado esperando requisições e perca a sincronização com o canal tick . Assim,
ao receber um sinal do canal jump a partição não realiza nenhuma ação (Skip)
e continua sua execução (executará PassoExecucaoPocos ). O primeiro passo é
justamente a adição do canal jump .
mento de paralelização, na partição do
jump
que deverá ser tratada pela partição de
≡
[B.26, B
(A1 k A2 ) 2 ((hmodo1 = DRENAGEM ∧ alturaFluido > altA1 i
&
AbertA1 ) ; (jump → Skip) circhide{jum
jump , como o mesmo pertence ao
PocoSync , este está implícito dentro do ocultamento de PocoSync uma
vez que podemos reduzi-lo através da lei B.27, uma vez que PocoSync∪{jump} =
PocoSync .
Expandimos o ocultamento sobre o canal
conjunto
≡
[B.20, B.22, B.27]
&
AbertA1 ) ; (jump → Skip))
Iremos transformar a ação Skip na composição paralela das ações Skip sobre
as mesmas partições e sobre o mesmo conjunto de canais. Em seguida, introduz-
jump para dentro dessa composição
PocoSync ∪ {jump} = PocoSync no conjunto
imos o canal
paralela. Mais uma vez, note
que
de canais de sincronização.
21
≡
[B.12, B
&
AbertA1 ) ; (jump → Skip k jump → Sk
Continuando o renamento, inserimos a ação dentro do composição paralela,
através da lei B.11.
≡
[B.12, B.19]
&
k
jump → Skip))
Juntamos as ações sobre a mesma composição paralela. Note que realizarmos
esses passos com as outras ações, teremos várioas repetições de escolhas externas
de
jump → Skip.
Para removermos essas repetições, aplicaremos a lei B.29.
≡
[B.13]
(A1
2 ((hmodo1 = DRENAGEM ∧ alturaFluido > altA1 i
&
k
A2
2 jump → Skip)
Utilizamos esses mesmos passos nas ações restantes.
Ao nal do processo
teremos o comportamento da atual operação em função das ações em paralelo:
DinamicaExecucaoSistema
e
TratarRequisicaoPocos .
(DinamicaExecucaoSistema k TratarRequisicaoPocos) \ PocoSyncS
Diante da transformação da operação original
DinamicaExecucao ,
voltemos
a prova do lema inicial.
(tick → (VerificarVolumeTanque1 )) ;
(DinamicaExecucaoSistema k TratarRequisicaoPocos) \ PocoSync
;
(PassoExecucaoPocos ; (µ X • RunPocos ; X ))
k
(PassoExecucaoSistema ; (µ X • RunSistema ; X ))
)) \ PocoSync
((
Expandiremos o ocultamento de
PocoSync
sobre toda a expressão e iremos
aos poucos retirar as ações da primeira composição paralela, para depois inserir
na composição paralela das recursões.
≡
[B.26]
((tick → (VerificarVolumeTanque1 ))
22
;
(DinamicaExecucaoSistema
; Skip
k TratarRequisicaoPocos
; Skip)
;
(
(PassoExecucaoPocos
;
(µ X • RunPocos
X ))
;
k
)) \ PocoSync
;
;
X ))
Iremos retirar as ações da primeira composição paralela de forma a se forma
uma sequência que será inserida na composição das recursões.
Além disso,
retiramos o Skip.
≡
[B.11, B.7, B.11, B.12, B.26]
;
;
TratarRequisicaoPocos)
;
(
(PassoExecucaoPocos
;
(µ X • RunPocos
X ))
;
k
;
;
X ))
)) \ PocoSync
Inserimos as operações
e
TratarRequisicaoPocos
na composição paralela das recursõess.
≡
[B.11, B.7, B.11, B.7]
(
(TratarRequisicaoPocos
;
;
PassoExecucaoPocos
;
(µ X • RunPocos
;
X ))
k
;
;
;
X ))
)) \ PocoSync
Iremos mais um vez introduzir Skip, precedendo a operação de
VerificarVolumeTanque1
partição Sistema .
O objetivo é introduzir a operação de
posição paralela responsável pela
≡
VerificarVolumeTanque1 .
na parte da com-
[B.26, B.16, B.7, B.11]
(
(tick → (
(TratarRequisicaoPocos
;
PassoExecucaoPocos
(µ X • RunPocos
;
X ))
;
k
(VerificarVolumeTanque1
;
23
;
;
;
X ))
)) \ PocoSync
tick
Como último passo, distribuímos de
bre que
tick
já faz parte de
sobre as composição paralela. Lem-
PocoSync .
≡
[B.19]
(
(tick → (TratarRequisicaoPocos
(µ X • RunPocos
;
;
PassoExecucaoPocos)
;
X ))
k
;
;
;
PassoExecucaoSistema)
X ))
) \ PocoSync
Utilizando as denições de
RunPocos
e
RunSistema .
≡
[Denições]
(
(RunPocos
;
(µ X • RunPocos
;
X ))
k
(RunSistema
;
;
X ))
) \ PocoSync
Como último passo da prova, aplicamos a duas vezes a lei 30 que dobrará
cada recursão, obtendo o lado direto do lema 2.1. Com o término desse lema,
terminamos o renamento de ação no qual obtivemos uma estrutura ainda que
centralizada (apenas um processo), mas contendo duas partições que modicam
apenas seus próprios elementos, ou seja, temos uma estrutura eminente para
o renamento de processos o qual nos fornecerá uma estrutura distribuída de
processos.
≡
[B.30]
(
(µ X • RunPocos
;
X)
k
;
X)
) \ PocoSync
24
;
A Leis de Renamento
B Leis de Renamento
Law 1 (Schema expressions)
ASExp CSExp
provided
• ∀ P1 .State; P2 .State; L • R ∧ pre ASExp ⇒ pre CSExp
• ∀ P1 .State; P2 .State; P2 .State 0 ; L • R ∧ pre ASExp ∧ CSExp ⇒
(∃ P1 .State 0 ; L0 • R 0 ∧ ASExp)
Law 2 (Guard combination)
g1 & (g2 & A) = (g1 ∧ g2 ) & A
Law 3 (Guard/Sequenceassociativity)
(g & A1 ); A2 = g & (A1 ; A2 )
Law 4 (Guard/External choicedistribution)
g & (A1 2 A2 ) = (g & A1 ) 2 (g & A2 )
Law 5 (Schema expression/Sequenceintroduction)
[∆S1 ; ∆S2 ; i ? : T | preS1 ∧ preS2 ∧ CS1 ∧ CS2 ]
vA
[∆S1 ; ΞS2 ; i ? : T | preS1 ∧ CS1 ]; [ΞS1 ; ∆S2 ; i ? : T | preS2 ∧ CS2 ]
provided
• α(S1 ) ∩ α(S2 ) = ∅
• FV (preS1 ) ⊆ α(S1 ) ∪ {i ?}
• FV (preS2 ) ⊆ α(S2 ) ∪ {i ?}
• DFV (CS1 ) ⊆ α(S10 )
• DFV (CS2 ) ⊆ α(S20 )
• UDFV (CS2 ) ∩ DFV (CS1 ) = ∅
Law 6 (Initialisation schema/Sequenceintroduction )
∗
25
[ S10 ; S20 | CS1 ∧ CS2 ]
=
[ S10 | CS1 ]; [ S20 | CS2 ]
provided
• α(S1 ) ∩ α(S2 ) = ∅
• DFV (CS1 ) ⊆ α(S10 )
• DFV (CS2 ) ⊆ α(S20 )
Law 7 (Parallelism composition commutativity )
∗
A1 |[ ns1 | cs | ns2 ]| A2 = A2 |[ ns2 | cs | ns1 ]| A1
Law 8 (Sequence/Parallelism compositionintroduction 1)
A1 ; A2 (e)
=
((A1 ; c!e → Skip) |[ wrtV (A2 ) | {|c|} | wrtV (A2 ) ]| c?y → A2 (y)) \ {|c|}
provided
• c∈
/ usedC (A1 ) ∪ usedC (A2 )
• y∈
/ FV (A2 )
• wrtV (A1 ) ∩ usedV (A2 ) = ∅
• FV (e) ∩ wrtV (A2 before e) = ∅
Law 9 (Channel extension 1)
A1 |[ ns1 | cs | ns2 ]| A2 = A1 |[ ns1 | cs ∪ {|c|} | ns2 ]| A2
provided c ∈/ usedC (A ) ∪ usedC (A )
Law 10 (Channel extension 2)
1
2
A1 |[ ns1 | cs | ns2 ]| A2 (e)
=
(c!e → A1 |[ ns1 | cs ∪ {|c|} | ns2 ]| c?x → A2 (x )) \ {|c|}
provided
• c∈
/ usedC (A1 ) ∪ usedC (A2 )
• x∈
/ FV (A2 )
• FV (e) ∩ wrtV (A2 before e) = ∅
26
Law 11 (Parallelism composition/Sequencestep )
∗
(A1 ; A2 ) |[ ns1 | cs | ns2 ]| A3 = A1 ; (A2 |[ ns1 | cs | ns2 ]| A3 )
provided
• initials(A3 ) ⊆ cs
• cs ∩ usedC (A1 ) = ∅
• wrtV (A1 ) ∩ usedV (A3 ) = ∅
• A3
is divergence-free
• wrtV (A1 ) ⊆ ns1
Law 12 (Parallelism composition unit )
∗
Skip |[ ns1 | cs | ns2 ]| Skip = Skip
Law 13 (Parallelism composition/External choiceexchange)
(A1 |[ ns1 | cs | ns2 ]| A2 ) 2 (B1 |[ ns1 | cs | ns2 ]| B2 )
=
(A1 2 B1 ) |[ ns1 | cs | ns2 ]| (A2 2 B2 )
provided A |[ ns | cs | ns ]| B = A |[ ns | cs | ns ]| B = Stop
Law 14 (Parallelism composition/External choicedistribution )
1
1
2
2
2
1
2
1
∗
2 i • (Ai |[ ns1 | cs | ns2 ]| A) = (2 i • Ai ) |[ ns1 | cs | ns2 ]| A
provided
• initials(A) ⊆ cs
• A
is deterministic
Law 15 (Parallelism composition/External choiceexpansion )
∗
(2 i • ai → Ai ) |[ ns1 | cs | ns2 ]| (2 j • bj → Bj )
=
(2 i • ai → Ai ) |[ ns1 | cs | ns2 ]| ((2 j • bj → Bj ) 2 (c → C ))
provided
•
S
i {ai }
⊆ cs
• c ∈ cs
S
• c∈
/ i {ai }
S
• c∈
/ j {bj }
27
Law 16 (Prex/Sequential compositionassociativity)
c → (A1 ; A2 ) = (c → A1 ); A2
c.e → (A1 ; A2 ) = (c.e → A1 ); A2
provided FV (A ) ∩ α(c) = ∅
Law 17 (Prex/Hiding )
2
∗
(c → Skip) \ {c} = Skip
(c.e → Skip) \ {c} = Skip
Law 18 (Prex introduction )
∗
A = (c → A) \ {| c |}
provided c ∈/ usedC (A)
Law 19 (Prex/Parallelism compositiondistribution)
c → (A1 |[ ns1 | cs | ns2 ]| A2 ) = (c → A1 ) |[ ns1 | cs ∪ {|c|} | ns2 ]| (c → A2 )
c.e → (A1 |[ ns1 | cs | ns2 ]| A2 ) = (c.e → A1 ) |[ ns1 | cs ∪ {|c|} | ns2 ]| (c.e → A2 )
provided c ∈/ usedC (A ) ∪ usedC (A )
Law 20 (Hiding Identity )
1
2
or
c ∈ cs
∗
A \ cs = A
provided cs ∩ usedC (A) = ∅
Law 21 (Hiding combination)
(A \ cs1 ) \ cs2 = A \ (cs1 ∪ cs2 )
Law 22 (Hiding/Sequencedistribution )
∗
(A1 ; A2 ) \ cs = (A1 \ cs); (A2 \ cs)
Law 23 (Hiding/External choicedistribution )
∗
(A1 2 A2 ) \ cs = (A1 \ cs) 2 (A2 \ cs)
provided
(initials(A1 ) ∪ initials(A2 )) ∩ cs = ∅
28
Law 24 (Schemas/Parallelism compositiondistribution )
∗
SExp ; (A1 |[ ns1 | cs | ns2 ]| A2 )
=
(SExp ; A1 ) |[ ns1 | cs | ns2 ]| A2
provided
• wrtV (SExp) ⊆ ns1
• wrtV (SExp) ∩ usedV (A2 ) = ∅
Law 25 (Parallelism composition introduction 1 )
∗
c → A = (c → A |[ ns1 | {| c |} | ns2 ]| c → Skip)
c.e → A = (c.e → A |[ ns1 | {| c |} | ns2 ]| c.e → Skip)
provided
• c∈
/ usedC (A)
• wrtV (A) ⊆ ns1
Law 26 (Sequence unit)
(A)Skip; A
(B )A = A; Skip
Law 27 (Hiding combination)
(A \ cs1 ) \ cs2 = A \ (cs1 ∪ cs2 )
Law 28 (Hiding expansion 2 )
∗
A \ cs = A \ cs ∪ {c}
provided c ∈/ usedC (A)
Law 29 (External choice elimination )
∗
A2A=A
Law 30 (Recursion unfold)
µ X • F (X ) = F (µ X • F (X ))
Law 31 (Recursionleast xed-point)
F (Y ) vA Y ⇒ µ X • F (X ) vA Y
29
Law 32qd(Process
splitting)
rd
stand for the declarations of the processes Q and R , deterQ.State , Q.PPar , and Q.Act , and R.State , R.PPar , and R.Act ,
respectively, and pd stand for the process declaration.
Let
and
mined by
process P =
b begin state State =
b Q.State ∧ R.State
Q.PPar ∧Ξ R.State
R.PPar ∧Ξ Q.State
• F (Q.Act, R.Act)
end
Then
pd = (qd rd process P =
b F (Q, R) )
provided
Q.PPar
and
R.PPar
are disjoint with respect to
Q.State .
30
R.State
and

1 Refinamento de Ações

Transcrição

Documentos relacionados

é bom sujar-se!

resultado - ps gp 2016.2 - prova: 08/07

LEIA MAIS - WordPress.com

GUSTAVO PEREIRA LEITE RIBEIRO CONTORNOS

COLÉGIO NOSSA SENHORA DE LOURDES

informacoes (srv-convisao)

EXPRESS detalhes

n6 Felix ProgrefTo d€ feus Annos. Que fe por hua

1º Ano A e B - Escola Berço de Belém

civilistica.com