clp – (constraint logic programs) programação lógica com restrições
Post on 16-Mar-2016
43 Views
Preview:
DESCRIPTION
TRANSCRIPT
CLP – (Constraint Logic Programs)Programação Lógica com Restrições
Ruben Carlo Benante Doutorando em Ciência da
Computação peloCIn – UFPE, Recife-PE
Mestre em Filosofia pela UNESP, Marília-SP
Bacharel em Ciência da Computação pela UNESP, S.J.Rio Preto-SP
rcb@cin.ufpe.br Disciplina de MCI Prof. Jacques Robin Baseado nas transparências
disponibilizadas na internet por Marriott & Stuckey
Capítulo 4: Programação Lógica com Restrições Restrições Definidas pelo Usuário Programando com Regras Avaliação Árvores de Derivação e Falhas
Finitas Avaliação de Objetivos Árvores de Derivação Simplificadas O esquema CLP
Capítulo 5: Modelos Simples Modelando Modelando Escolhas Otimização
Capítulo 7: Controle de Busca Estimando a eficiência de um
programa CLP Ordenando as Regras Ordenando os Literais Adicionando Restrições Redundantes Minimização
Capítulo 8: Modelos com Domínios Finitos Domínios e Rótulos Restrições Complexas Rotulando (Labelling) Modelando Problemas Diferentes
Capítulo 4: Restrições Definidas pelo Usuário (RDU) Muitos exemplos de modelagem podem
ser particionados em duas partes: Uma descrição geral do objeto ou processo Uma informação específica sobre uma
situação real O programador deve ser capaz de definir
suas próprias restrições específicas ao problema
As Regras permitem isso
Regras
II1
I2
V+
--3_--
--
VR1 R2
Uma RDU para definir o modelo de circuito elétrico:parallel_resistors(V,I,R1,R2)
parallel_resistors(V,I,R1,R2) :-
V = I1 * R1, V = I2 * R2, I1 + I2 = I.
E uma regra definindo-a:
Usando Regrasparallel_resistors(V,I,R1,R2) :-
V = I1 * R1, V = I2 * R2, I1 + I2 = I.
Comportamento com resistores de 10 e 5 Ohmsparallel_resistors( , , , )V I R R R R1 2 1 10 2 5
Comportamento com bateria de 10V, com resistores iguaisparallel_resistors( , , , )10 I R R
Isso representa a restrição: (substituição macro)10 1 10 2 1 2 I R I R I I I
Restrições Definidas pelo Usuário (RDU) RDU: p(t1,...,tn) onde p é um predicado
n-ário e t1,...,tn são expressões literal: uma restrição primária ou RDU objetivo (goal): uma seqüência de
literais L1,...,Lm regra: A :- B onde A é RDU e B é um
objetivo programa: uma seqüência de regras
Renomeação (Renamings) Uma renomeação r é um mapa bijetivo de
variáveis em variáveis Um objeto sintático é uma restrição, um
RDU, um objetivo ou uma regra Aplicar uma renomeação em um objeto
sintático nos dá um objeto com cada variável x substituída por r(x)
variante o’ de um objeto o tem sua renomeação como r(o’)=o
Não é substituição de macros
Reescrita de RDU objetivo G da forma (ou vazio m=0 [])
L1, ..., Li-1, Li, Li+1, ..., Lm Li é da forma p(t1,...,tn) R é da forma p(s1,...,sn) :- B r é a renomeação das variáveis em r(R) e
não em G A reescrita de G com Li por R usando a
renomeação r é L1,...,Li-1,t1=r(s1),...,tn=r(sn),r(B),Li+1,...,Lm
Programando com Regras
Considere a função fatorial. Como poderemos escrever regras para o predicado fac(N,F) onde(F = N!) ?
NN
N N N!
( )!
1 01 1
if if
(R1) fac(0,1).(R2) fac(N,N*F) :- N >= 1, fac(N-1, F).
Note que a definição é recursiva (em termos dela mesma) e imita a definição matemática
Programando com Regras
(R1) fac(0,1).(R2) fac(N,N*F) :- N >= 1, fac(N-1, F).
Reescrevendo o objetivo fac(2,X) (i.e. o que é 2!)fac X( , )2fac X
RN X N F N fac N F
( , )
, , , ( , )
2
22 1 1
fac X
RN X N F N fac N F
RN X N F N N N F N F N fac N F
( , )
, , , ( , )
, , , ' , ' ' , ' , ( ' , ' )
2
22 1 1
22 1 1 1 1
fac X
RN X N F N fac N F
RN X N F N N N F N F N fac N F
RN X N F N N N F N F N N F
( , )
, , , ( , )
, , , ' , ' ' , ' , ( ' , ' )
, , , ' , ' ' , ' , ' , '
2
22 1 1
22 1 1 1 1
12 1 1 1 1 0 1
Simplificado na variável X, a resposta é X = 2
Avaliação (Evaluation) Em cada passo da reescrita, deveremos
checar se a conjunção de restrições primitivas pode ser satisfeita
A derivação faz isso Em cada passo, os literais…
Restrição primitiva: são adicionados ao lado direito (das restrições)
RDU: são reescritos
Avaliação estado: <G1| C1> onde G1 é um objetivo
e C1 é uma restrição Passo de derivação: G1 é L1, L2, ..., Lm
L1 é uma restrição primitiva, C2 is C1 /\ L1•Se solv(C /\ L1) = false então G2 = [] •Senão G2 = L2, ..., Lm
L1 é uma RDU, C2 é C1 e G2 é a reescrita de G1 com L1 usando alguma regra e a renomeação
Avaliação derivação de <G0 | C0>:
Onde cada <Gi | Ci> até <Gi+1 | Ci+1> é um passo de derivação
derivação de G é a derivação do estado <G | true>
G C G C G C0 0 1 1 2 2| | |
Derivação de fac(1,Y)fac Y true( , )|1fac Y true
R
N Y N F N fac N F true
( , )|
, , , ( , )|
1
2
1 1 1
fac Y trueR
N Y N F N fac N F true
Y N F N fac N F N
( , )|
, , , ( , )|
, , ( , )|
12
1 1 1
1 1 1
fac Y trueR
N Y N F N fac N F true
Y N F N fac N F N
N fac N F N Y N F
( , )|
, , , ( , )|
, , ( , )|
, ( , )|
12
1 1 1
1 1 1
1 1 1
fac Y trueR
N Y N F N fac N F true
Y N F N fac N F N
N fac N F N Y N F
fac N F N Y N F N
( , )|
, , , ( , )|
, , ( , )|
, ( , )|
( , )|
12
1 1 1
1 1 1
1 1 1
1 1 1
fac Y trueR
N Y N F N fac N F true
Y N F N fac N F N
N fac N F N Y N F
fac N F N Y N F NR
N F N Y N F N
( , )|
, , , ( , )|
, , ( , )|
, ( , )|
( , )|
, |
12
1 1 1
1 1 1
1 1 1
1 1 11
1 0 11 1
fac Y trueR
N Y N F N fac N F true
Y N F N fac N F N
N fac N F N Y N F
fac N F N Y N F NR
N F N Y N F N
F N Y N F N N
( , )|
, , , ( , )|
, , ( , )|
, ( , )|
( , )|
, |
|
12
1 1 1
1 1 1
1 1 1
1 1 11
1 0 11 1
11 1 1 0
fac Y trueR
N Y N F N fac N F true
Y N F N fac N F N
N fac N F N Y N F
fac N F N Y N F NR
N F N Y N F N
F N Y N F N N
( , )|
, , , ( , )|
, , ( , )|
, ( , )|
( , )|
, |
|
[]|
12
1 1 1
1 1 1
1 1 1
1 1 11
1 0 11 1
11 1 1 0
1
N Y N F N N F1 1 0 1
Resposta simplificada em Y é Y = 1
Derivações Para a derivação iniciando em <G0 | C0> Estado de sucesso: <[] | C> onde solv(C) !
= false Derivação de sucesso: o último estado é
de sucesso resposta: simpl(C, vars(<G0 | C0>)) Estado de falha: <[] | C> onde solv(C) =
false Derivação falha: o último estado é de falha
Árvores de derivação Árvore de derivação para o objetivo G
Raíz é < G | true > Os filhos de cada estado são estados
alcançáveis em um passo de derivação Codifica todas as possíveis derivações Quando o literal mais à esquerda é uma
restrição primitiva, somente há um filho Caso contrário, os filhos estão ordenados
conforme a ordem das regras
Exemplo de Árvores de Derivação fac Y true
R RY true N Y N F N fac N F true
Y N F N fac N F C N
N fac N F C C Y N F
fac N F C C NR R
N F C N N F N F N
( , )|
, | , , , ( , )|
[]| , , ( , )|
, ( , )|
( , )|
, | ' , ' ' ,
11 2
1 0 1 1 1 1
1 0 1 1 1 1
1 1 2 1
1 3 2 11 2
1 0 1 3 1
' , ( ' , ' )|
| ' ' , ' , ( ' , ' )| '
[]| ' , ( ' , ' )| ' '
[]| '
1 1 3
1 4 3 1 0 1 1 6 3 1
5 4 1 1 1 7 6
8 7 1
fac N F C
F C C N F N F N fac N F C C N N
C C F N fac N F C C F N F
C C N
Derivação falhou
Derivação falhou
resposta: Y = 1
Árvore de Derivação O exemplo anterior mostrou três
derivações, 2 falharam e uma foi bem sucedida
Falha finita: Se a árvore de derivação é finita e todas as derivações falham
Árvore de Derivação Infinita: algumas derivações são infinitas
Exemplo de árvore de derivação infinita(S1) stupid(X) :- stupid(X).(S2) stupid(1).
stupid X trueS S
X X stupid X true X true
stupid X X X XS S
X X stupid X X X X X X
stupid X X X X X X X XS S
( )|
' , ( ' )| |
( ' )| ' []|
' ' ' , ( ' ' )| ' ' | '
( ' ' )| ' ' ' ' []| ' '
1 21
11 2
1
11 2
Resposta: X=1
Resposta: X=1
Derivação Infinita
Avaliação de Objetivos A Avaliação de um objetivo realiza uma busca
em profundidade, e na direção da esquerda para a direita
Quando encontra um estado de sucesso, o sistema retorna a resposta
O usuário pode perguntar por outras respostas, o que faz a busca continuar
A execução pára quando o usuário não pede mais respostas ou a árvore inteira é explorada
A execução entra em laço infinito se a árvore é infinita e não apresenta resposta
Árvores de Derivação Simplificadas As árvores de derivação são muito
grandes Uma forma simplificada tem a
informação considerada mais útil Restrições na forma simplificada
(variáveis na forma do objetivo inicial, e como parte dos estados do objetivo)
Remoção de estados sem interesse
Estados Simplificados Estado simplificado: <G0 | C0> na
derivação de G substitua C0 por C1=simpl(C0, vars(G,G0)) se x=t em C1 substitua x por t em G0 levando
à G1 substitua C1 por C2=simpl(C1, vars(G,G1))
Exemplo fac N F N Y N F N N N F FY N F
fac N F N Y FN
fac F Y F
( ' , ' )| ' 'vars { , ' , '}
( ' , ' )| ' ''
( , ' )| '
1 1 1 1
1 0
1
replace by 0 and simplify again
Derivação Simplificada Um estado é critico se ele é o primeiro
ou o último estado de uma derivação, ou se o primeiro literal é uma RDU
Uma derivação simplificada para o objetivo G contém todos os estados críticos na forma simplificada
Similarmente para uma árvore de derivação simplificada
Exemplo de Árvore Simplificada
fac Y trueR R
false fac F Y FR R
Y false
( , )|
[]| ( , )|
[]| []|
11 2
01 2
1
Nota: estados de falha são <[] | false> e estados de sucesso contém as respostas
O Esquema CLP O esquema define uma família de
linguagens de programação Uma linguagem CLP(X) é definida por
Domínio de restrição X Resolvedor para o domínio de restrição X Simplificador para o domínio de restrição X
Nos exemplos usamos CLP(Real) Outro exemplo seria o CLP(Tree)
CLP(R)
Os elementos são árvores contendo constantes reais
Restrições são para árvores e para aritimética
{ , }
{ , , , , }
Capítulo 5: Modelando Escolha as variáveis que serão
usadas para representar os parâmetros do problema (isto pode ser trivial ou difícil)
Modele as relações idealizadas entre estas variáveis usando as restrições primitivas disponíveis no domínio
Exemplo de Modelagem
W
P
Uma viajante deseja atravessar o rio infestado de tubarões tão rápido quanto possível. A rota mais rápida é atravessar o rio nadando em linha reta, deixando que a correnteza faça a parte dela livremente. Ela deseja saber onde (P) ela vai parar após essa tarefa?
Largura do rio: WVelocidade do rio: SPosição da nadadora: PVelocidade da nadadora: R
R
S
Exemplo de ModelagemRaciocínio: enquanto a nadadora atravessa o rio na sua largura, gastando um tempo T, ela segue junto com a correnteza para o rio abaixo uma distância P dada pela velocidade do rio, com o mesmo tempo T. Daí o modelo:river(W, S, R, P) :- T = W/R, P = S*T.
Supondo que ela nade a R=1.5m/s, a velocidade do rio é de S=1m/s e seu comprimento é de W=24m.
river(24, 1, 1.5, P).
A única resposta é P = 16 Largura do rio: WVelocidade do rio: SPosição da nadadora: PVelocidade da nadadora: R
Exemplo de Modelagem (cont.)
Se ela nada numa velocidade entre 1 e 1.3 m/s e não pode se afastar mais que 20m do ponto de origem, será que ela conseguirá?
1 <= R, R <= 1.3, P <= 20, river(24,1,R,P).
Esta é a flexibilidade do modelo baseado em restrições!
Escolhas mais complicadas
Uma opção de “call” dá ao seu portador o direito de comprar 100 ações a um preço de exercício E fixo
Uma opção de “put” dá ao seu portador o direito de vender 100 ações a um preço de exercício E fixo
O pagamento (lucro ou prejuízo) de uma opção é determinado por seu custo C e pelo preço corrente da ação S
e.g. custo do call C=$200, Exercício E=$300 Preço do mercado = $2, não utiliza o call:
• pagamento = -$200 Preço do mercado = $9, utiliza o call:
• pagamento = $400
0 1 2 3 4 5 6 7call, buying
call, selling-200-100
0100200
Opções de Mercadocall C=200, E = 300 put C=100, E = 300
0 1 2 3 4 5 6
butterfly-100-50
050
100
Operação Borboleta: Compre um “call” por C=100 com E=500 e outro por C=400 com E=100. Venda dois “calls” por C=200, com E=300
0 1 2 3 4 5 6 7put, buying
put, selling-200-100
0100200
Opções de MercadoPG= S – E – C (para compra de “call”)PG = E + C – S (para venda de “call”)
(C=100,E=500, compra) PG1 = 100S – 600 p/ S>5PG1 = – 100 p/ S<=5
(C=400,E=100, compra) PG2 = 100S – 500 p/ S>1PG2 = – 100 p/ S<=100
(C=200,E=300, venda)PG3 = – S100 + 500 p/ S>3PG3 = 200 p/ S<=3
0 1 2 3 4 5 6
butterfly-100-50
050
100
Operação Borboleta: Compre um “call” por C=100 com E=500 e outro por C=400 com E=100. Venda dois “calls” por C=200, com E=300
Aplicadas as restrições temos:PG = PG1 + PG2 + 2PG3PG = – 100 p/ s>5PG = – 100 p/ s<1PG = 100S – 200 P/ 1<S<3PG = –100S + 400 p/ 3<S<5
Modelando Funções
call payoff S C EC S E
S E C S E_ ( , , )
//
if if 0 100
100 100
buy_call_payoff(S,C,E,P) :-0 <= S, S <= E/100, P = -C.
buy_call_payoff(S,C,E,P) :-S >= E/100, P = 100*S - E - C.
Modelar uma função com n argumentos como um predicado com n+1 argumentos. Os testes são restrições, e o resultado é uma equação.
Modelando OpçõesAcrescente um argumento extraB=1 (compra), B = -1 (venda)call_option(B,S,C,E,P) :-
0 <= S, S <= E/100, P = -C * B.
call_option(B,S,C,E,P) :-S >= E/100, P = (100*S - E - C)*B.
call_option(1, 7, 200, 300, P)
E a resposta é P = 200
O objetivo é dado por:
Usando o Modelobutterfly(S, P1 + P2 + 2*P3) :-
Buy = 1, Sell = -1,call_option(Buy, S, 100, 500, P1),call_option(Buy, S, 400, 100, P2),call_option(Sell, S, 200, 300, P3).
Define a curva dada no gráfico anterior, para lucros:P >= 0, butterfly(S,P).
Tem duas respostas:P S S SP S S S
100 200 2 3100 400 3 4
Por quê restrições e não Linguagem C? Ambos os programas podem responder o
objetivo call_option(1, 7, 200, 300, P). Mas o CLP pode responder, sem muito
esforço, o objetivo: butterfly(3, P1 + P2 + 2*P3).P = 100
E até mesmo o objetivo: P >= 0, butterfly(S,P).P = 100S – 200 /\ 2<=S /\ S<=3P = -100S + 400 /\ 3<=S /\ s<=4
Otimização Muitos problemas requerem a
“melhor” solução Literal de minimização:
minimize(G,E) Responde as questões sobre o
objetivo G que minimiza a expressão E (no contexto do estado)
Exemplos de Otimizaçãop(X,Y) := X = 1.p(X,Y) :- Y = 1.
X >= 0, Y >= 0, minimize(p(X,Y), X+Y)
Respostas: X = 1 /\ Y = 0 e X = 0 /\ Y = 1X >= 0, X >= Y, minimize(true, X-Y)
Resposta: X >= 0 /\ X = Yminimize(butterfly(S,P), -P)
Resposta: S = 3 /\ P = 100
Avaliação de Otimização Um valor de v é uma solução para um estado
se é alguma das soluções deste estado Passo da derivação de uma minimização:
<G1 | C1> para <G2 | C2> onde G1 = L1,L2,...,Lm, e L1 é “minimize(G,E)” existe uma solução v de <G | C1> com v(E) = m e
para todas as outras soluções w temos que m <= w(E)• Então G2 é G,L2,...,Lm e C2 é C1 /\ E = m
Senão G2 é [] e C2 é falso
Exemplo de OtimizaçãoX >= 0, minimize(X >= Y, X-Y) X X Y X Y true
X Y X Y X
X Y X X Y
X X Y X Y
0
0
0 0
0 0
,minimize( , )|
minimize( , )|
|
[]|
X Y X
X X Y
|
[]|
0
0
Valor mínimo de X-Y é 0 e.g. { , }X Y 3 3
Simplificado: X X Y 0
X>=0, Y<=X, m=min(X-Y)m=X-YTomemos X=0, o menor Xm=-YMas Y<=X Y<=0 -Y>=0Tomemos –Y=0, o menor Ym=0-0 m=0 X-Y=0
Otimização
A otimização não precisa necessariamente ser um objetivo:
straddle(S,C1+C2,E,P1+P2) :- Buy = 1, call_option(Buy, S, C1, E, P1),put_option(Buy, S, C2, E, P2).
best_straddle(C,E,P) :-minimize(straddle(S,C,E,P),-P).
Capítulo 7: Estimando Eficiência Avaliação é a busca na árvore de
derivação O tamanho e a forma da árvore de
derivação determinam a eficiência (ignorando o custo da solução) Quanto menor: menos busca Respostas do lado esquerdo da árvore:menos
busca antes de achar a primeira resposta A árvore de derivação depende do modo
de uso (MU)
Modo de Uso (MU) modo de uso (MU): define os tipos de
restrições nos argumentos de um predicado quando avaliado
fixo: o conjunto de restrições implica em um único valor para todas as soluções
livre: o conjunto de restrições permite todos os valores
outros: limitado superiormente, limitado inferiormente
Exemplo de Modo de Uso
MU primeiro arg fixo segundo livre sumlist([1],S). L=[1,2],S > Z, sumlist(L,S).
Estados na árvore de derivação com a chamada de sumlist<sumlist([1], S)|true><sumlist(L’,S’)|[1]=[N’|L’]/\S=N’+S’><sumlist(L’’,S’’)|[]=[N’’|L’’]/\S’=N’’+S’’><N’’=0,S’’=0|/\S’=N’’+S’’>
sumlist([], 0).sumlist([N|L], N+S) :- sumlist(L, S).
Exemplo de Controle de Busca Pense em escrever um programa para
computar:
Raciocíne recursivamente: A soma de N números é a soma de (N-1) + N A soma de 0 números é 0
Problema: sum(1,S) não tem resposta
S N 0 1 2
(S1) sum(N, S+N) :- sum(N-1, S).(S2) sum(0, 0).
Exemplo de Controle de Busca
sum S trueS S
sum S S S falseS S
sum S S S SS S
sum S S S falseS
( , )|
( , ' )| ' []|
( , ' ' )| ' ' []|
( , ' ' ' )| ' ' ' []|
11 2
0 11 2
1 1 11 2
2 01
Árvore de derivação simplificada para sum(1,S).
Note que é infinita no ramo à esquerda, pois N assumiu valores negativos.
Exemplo de Controle de Busca
Derivação infinita antes da resposta
sum(1,S) resposta: S=1, Mas e sum(1,0)?
(S3) sum(0, 0).(S4) sum(N, S+N) :- sum(N-1, S).
sum trueS
sum trueS
sum trueS
sum trueS
( , )|
( , )|
( , )|
( , )|
1 04
0 14
1 14
2 04
N=1, S+N=0 S=-1N’=0, S’+N’=-1 S’=-1N’’=-1, S’’+N’’=-1 S’’=0N’’’=-2, S’’’+N’’’=0 S’’’=2...
Exemplo de Controle de Busca O programa não foi feito para tratar com
números negativos. Corrija para:(S5) sum(0, 0).(S6) sum(N, S+N) :- sum(N-1, S), N >= 1.
6
11,10),1,1(6
11),1,0(6
)0,1(
S
truesumS
truesumS
truesum
Ainda não deu: derivaçãoinfinita de sum(N,S+N)
Exemplo de Controle de Busca
Lembre-se do processamento da esquerda para direita
sum(1,S) dá S = 1, sum(1,0) responde no Métodos:
Reordenamento de regras Adição de restrições redundantes Reordenamento de literais
(S7) sum(0, 0).(S8) sum(N, S+N) :- N >= 1, sum(N-1, S).
Ordenando Regras Regra geral
Coloque as regras não-recursivas antes das regras recursivas
(isto irá evitar derivações infinitas) Regra heurística
Coloque regras que “parecem levar a respostas rápidas” antes (acima) das outras
(isto tende a mover os estados de sucesso para a esquerda da árvore)
Ordenando Literais Restrições Primitivas
Coloque uma restrição no ponto mais à esquerda possível no qual ela poderia causar uma falha (para um determinado MU)
fac(N,F) com N fixo e F livrefac(N, F) :- N = 0,F = 1.fac(N, FF) :- N >= 1, FF = N * F,
N1 = N - 1, fac(N1, F).
fac(N, F) :- N = 0,F = 1.fac(N, FF) :- N >= 1, N1 = N - 1,
fac(N1, F), FF = N * F.
Ordenando Literais RDU:
Coloque os literais determinísticos antes dos outros
determinístico: o literal p(s1,...,sn) em um programa é determinístico para uma árvore de derivação se a cada ponto de escolha onde ele é reescrito, todas as derivações falham, exceto uma, antes da reescrita da RDU (em outras palavras: no máximo uma tem sucesso)
Predicados Deterministicos sumlist(L,S) é determinístico para o MU L
fixo e S livre. Não é para L livre e S fixo. sum(N,S) é similar Predicados determinísticos requerem
menos busca para achar uma resposta CUIDADO! Mover predicados pode mudá-
lo de determinístico para não_determinístico (o bom é que o inverso também é válido!)
Adicionando Restrições Redundantes Uma restrição que pode ser removida de uma
regra sem alterar as respostas válidas de uma árvore é chamada de redundante. (Pode alterar a ordem.)
Restrição de Resposta Redundante (ARC): o mesmo conjunto de respostas para: H :- L1, ..., Li, Li+1, ..., Ln H :- L1, ..., Li, r, Li+1, ..., Ln
Vantagem (para um conjunto de restrições C, num MU) <L1,...,Li,r|C> falha, mas não <L1,...,Li|C>
Adicionando Restrições Redundantes (ARC)
A restrição N >= 1 adicionada ao programa sum é uma ARC.
Outro exemplo: sum(N,7) (novo MU)sum N true
Ssum N S N N S N N
Ssum N S N N S N N
Ssum N S N N S N N
Ssum N S N N S
( , )|
( ' , ' )| ' ' ' '
( ' ' , ' ' )| ' ' ' ' ' ' ' '
( ' ' ' , ' ' ' )| ' ' ' ' ' ' ' ' ' ' ' '
( ' ' ' ' , ' ' ' ' )| ' ' ' ' ' ' ' '
78
1 6 08
2 4 2 08
3 1 3 08
4 3
4 0N N' ' ' ' ' ' ' '
Adicionando Restrições Redundantes (ARC)Sabemos que cada soma é não-negativa
(S9) sum(0, 0).(S10) sum(N, S+N) :-
N >= 1, S >= 0, sum(N-1, S).
sum N trueS
sum N S N N S N N NS
sum N S N N S N N NS
sum N S N N S N N NSfalse
( , )|
( ' , ' )| ' ' ' ' '
( ' ' , ' ' )| ' ' ' ' ' ' ' ' ' '
( ' ' ' , ' ' ' )| ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' /
[]|
710
1 6 0 610
2 4 2 0 210
3 1 3 0 1 310
Restrições Redundantes de Resolvedor Restrição Resolvedor Redundante
(SRC): uma restrição primitiva r é SRC se é implicada pelo conjunto de restrições
Vantagem: Se o resolvedor não está vendo a implicação (resolvedor parcial ou árvore infinita), adicioná-la pode trazer informação extra (falha)
F >= 1, N >= 1, FF = N*F, FF >= 1
Exemplo de Restrições Redundantes de Resolvedor (SRC)
(F1) fac(N, F) :- N = 0,F = 1.(F2) fac(N, FF) :- N >= 1, N1 = N - 1,
FF = N * F, fac(N, F).
O objetivo fac(N,7) é infinito, como era sum(N,7).
(F3) fac(N, F) :- N = 0,F = 1.(F4) fac(N, FF) :- N >= 1, N1 = N - 1,
FF = N * F, F >= 1, fac(N, F).
O objetivo fac(N,7) ainda é infinito!
Exemplo de Restrições Redundantes de Resolvedor (SRC)
fac N trueF
fac N F F N N FF
fac N F F N N N FF
fac N F F N N N N FF
fac N F F N N N
( , )|
( , ' )| ' '
( , ' ' )| ' ' ( ) ' '
( , '" ' )| '" ' ( ) ( ) ' ' '
( , ' ' ' ' )| ' ' ' ' ( )
74
1 1 1 74
2 1 2 7 14
3 1 3 7 1 24
4 1 4 7 1
( ) ( ) ' ' ' 'N N F 2 3
Dado que F’’’’ >= 1 e N >= 4 entãoN N N N F ( ) ( ) ( ) ' ' ' '1 2 3
Deve ser pelo menos 24. Esta restrição não foi satisfeita por não ter sido detectada (resolvedor parcial)
Exemplo de Restrições Redundantes de Resolvedor (SRC)
(F3) fac(N, F) :- N = 0,F = 1.(F4) fac(N, FF) :- N >= 1, N1 = N - 1,
FF = N * F, FF >= N, F >= 1, fac(N, F).
Correção: adicione a SRC, N * F >= N
Que é implicada por N >= 1, F >= 1
CUIDADO: 1 = N * F , 2 = N * F tem sucesso ao se instanciar F, por isso, use um nome único para N*F
Agora o objetivo fac(N,7) falha em tempo finito!
Minimização Minimizar literais causam a busca de
respostas em uma árvore de derivação diferente
Precisamos entender a forma desta árvore para lidar com ela
minimize(G,E) tem o mesmo MU deE < m, G
Para um uso eficiente da minimização, tenha certeza que G é eficiente quando E é limitado superiormente, por um m qualquer dado.
Exemplo de MinimizaçãoPrograma que acha os nós folhas e seus níveis
L1:leaf(node(null,X,null),X,0).L2:leaf(node(L,_,_),X,D+1) :-
leaf(L,X,D).L3:leaf(node(_,_,R),X,D+1) :-
leaf(R,X,D).
h
j k
i
d
m
o p
n
l
e
b
f
s t
q r
g
c
aObjetivo:leaf(t(a),X,D)Respostas:(h,3),(j,4),(k,4),(m,4),(o,5),(p,5),(f,2),(s,4), (t,4),(r,3)
Exemplo de MinimizaçãoObjetivominimize(leaf(t(a),X,D), D):Após encontrar X = h /\ D = 3, o objetivofica:D < 3, leaf(t(a),X,D), o que faz quenunca se visite nós com profundidadesuperior a 3 (?)
h
j k
i
d
m
o p
n
l
e
b
f
s r
q r
g
c
a
falseDDL
DDXktleafL
DDXitleafL
DDXdtleafL
DDXbtleafL
DDXatleaf
trueDXatleafD
)043([]1
3)4,),((3
3)3,),((3
3)2,),((2
3)1,),((2
3),),((
),),((,3
Exemplo de MinimizaçãoMelhore o leaf para o MU com D limitado superiormente: adicione uma ARC
L4:leaf(node(null,X,null),X,0).L5:leaf(node(L,_,_),X,D+1) :-
D >= 0, leaf(L,X,D).L6:leaf(node(_,_,R),X,D+1) :-
D >= 0, leaf(R,X,D).
falseDDL
DDDXdtleafL
DDDXbtleafL
DDXatleaf
trueDXatleafD
)33([]6
23)2,),((5
13)1,),((5
3),),((
,),((,3
Minimização A busca pode nem sempre ser beneficiada
pelos limites e.g. minimize(leaf(t(a),X,D), -D) Ainda deve visitar todos os nós antes de achar
um nó folha de maior profundidade A formulação original é superior, uma vez que
envolve menos restrições (a restrição redundante D>=0 não diminui o espaço de busca)
Conceito-Chave: lembre-se do MU de E<m, G, com m fixo.
Capítulo 8: Domínios e Rótulos
Novos requisitos: precisamos definir os domínios e as variáveis aritmético X :: [1,2,3,4] ou X :: [1..4] não-aritmético X :: [red, blue, yellow] multiplas variáveis [X,Y,Z] :: [0..10]
Se nenhum domínio é dado, é usado o padrão, por exemplo [-10000..10000]
Exemplo de DomíniosObjetivo para o problema do peso da sacola do contrabandista:[W,P,C] :: [0..9], 4*W + 3*P + 2*C <= 9,15*W + 10*P + 7*C >= 30.
O sistema CLP(FD) retorna unknown.
Mas como achar uma solução?
Devemos chamar um resolvedor completo (com backtracking)
D W D P D C( ) [ .. ], ( ) [ .. ], ( ) [ .. ] 0 2 0 3 0 4
Rótulos (Labelling) O predicado interno labeling chama
o resolvedor de restrições completo labeling(Vs) toma uma lista de
variáveis de domínio finito Vs e encontra uma solução
[W,P,C] :: [0..9], 4*W + 3*P + 2*C <= 9,15*W + 10*P + 7*C >= 30, labeling([W,P,C]).Acha as soluções:
W P C W P CW P C W P C
0 1 3 0 3 01 1 1 2 0 0
Restringe e Gera!
Forma típica de um programa de domínio finito Variáveis e domínios são definidos As restrições que modelam o problema são dadas O labeling é adicionado para chamar o resolvedor
completo A minimização pode ser aplicada no labeling Exemplo:
[W,P,C] :: [0..9], 4*W + 3*P + 2*C <= 9,15*W + 10*P + 7*C >= 30, minimize(labeling([W,P,C]), -15*W-10*P-7*C).
Exemplo Send+More=Money
YENOMEROMDNES
Problema Cripto-aritmético, cada dígito é diferente, e a equação deve ficar corretasmm(S,E,N,D,M,O,R,Y) :-
[S,E,N,D,M,O,R,Y] :: [0..9],constrain(S,E,N,D,M,O,R,Y),labeling([S,E,N,D,M,O,R,Y]).
constrain(S,E,N,D,M,O,R,Y) :-S != 0, M != 0, alldifferent_neq([S,E,N,D,M,O,R,Y]), 1000*S + 100*E + 10*N + D+ 1000*M + 100*O + 10*R + E= 10000*M + 1000*O + 100*N + 10*E + Y.
Exemplo Send+More=Money
Após a declaração do domínio, temos:D S D E D N D D D M D O D R D Y( ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) [ .. ] 0 9
Após temos alldifferent_neq adiciona a desigualdade (nãomuda o domínio)Equação final após uma regra de propagação:
S M 0 0 D S D M( ) ( ) [ .. ] 1 9
MD S D E D D D R
D O D N D Y
19
919000
19000
1900
110
1100
19000
max( , ) max( , ) max( , ) max( , )min( , ) min( , ) min( , )
Considerando o domínio corrente, temos:M 9
991 99000
99000
9900
010
0100
09000 1102.
Exemplo Send+More=Money
Portanto D(M) = [1..1]A propagação continua até que:
D S D E D N D DD M D O D R D Y
( ) [ .. ] ( ) [ .. ] ( ) [5.. ] ( ) [ .. ]( ) [ .. ] ( ) [ .. ] ( ) [ .. ] ( ) [ .. ]
9 9 4 7 8 2 81 1 0 0 2 8 2 9
Observe: 3 variáveis estão fixadas e todos os domínios estão reduzidos. O labeling tenta S=0, S=1, ..., S=8 (que falham imediatamente) e então S=9. Depois E=0, E=1, E=2, E=3 (que falham imediatamente) e E=4 (que eventualmente falha), então E=5 dá como resposta:
D S D E D N D DD M D O D R D Y
( ) [ .. ] ( ) [5.. ] ( ) [ .. ] ( ) [ .. ]( ) [ .. ] ( ) [ .. ] ( ) [8.. ] ( ) [ .. ]
9 9 5 6 6 7 71 1 0 0 8 2 2
Gera e Testa!Método sem restrições:
primeiro gera uma possível soluçãoentão testa a solução
smm(S,E,N,D,M,O,R,Y) :-[S,E,N,D,M,O,R,Y] :: [0..9],labeling([S,E,N,D,M,O,R,Y]),constrain(S,E,N,D,M,O,R,Y).
Este programa requer 95671082 escolhas antes de achar a solulção. O anterior requer apenas 35 escolhas (ou 2 que não falham imediatamente)
Restrições Complexas Restrições Complexas como
alldifferent, cumulative e element Modelagem do problema mais
sucinta Melhor propagação = mais eficiência
Pois são primitivas! (reveja a definição) Exemplo:
alldifferent_neq([S,E,N,D,M,O,R,Y])
Rotulagem Há duas escolhas feitas pelo labeling:
Escolha de qual variável instanciar primeiro Escolha de qual valor do domínio tentar
primeiro labeling padrão:
Tenta as variáveis na ordem dada pela lista Tenta os valores do menor para o maior (dado
pela primitiva dom) Podemos programar estratégias
diferentes
Escolha de Variáveis A escolha das variáveis afeta o tamanho da
árvore de derivação Heurística: escolha variáveis com o conjunto do
domínio menor (portanto com menos possíveis respostas)
ExemploD S D E D N D DD M D O D R D Y
( ) [ .. ] ( ) [ .. ] ( ) [5.. ] ( ) [ .. ]( ) [ .. ] ( ) [ .. ] ( ) [ .. ] ( ) [ .. ]
9 9 4 7 8 2 81 1 0 0 2 8 2 9
O labeling tentaria primeiro S, M, O (a escolha já está dada pelo domínio). Melhor que E ou N. Muito melhor que Y primeiro.
Escolha do Valor do Domínio O valor da variáveis somente afeta a
ordem em que os ramos da árvore é explorado
Conhecimento específico do problema pode levar a uma busca mais rápida da solução
Também é importante para a otimização: Boas soluções encontradas cedo reduzem a
busca posterior
Eficiência da Rotulagem Podemos utilizar ambas ordenações
(de variáveis e de valores) juntas
10--19
30--39
50--59
70--79
1
10
100
1000
10000
DefaultFirst-failMiddleout
Número de escolhas diferentes para o problema dasN-Rainhas com estratégias diferentes
• Padrão• Primeira a falhar• Primeiro no meio
Divisão de Domínios(Domain Splitting)
O labeling não precisa ser do tipo Ligar uma variável a um valor
Ele simplesmente deve reduzir o domínio de uma variável
Divisão de Domínios divide o domínio corrente de uma determinada variável pela metade
Modelando diferentemente o (mesmo) Problema Visões diferentes de um problema levam
a diferentes modelos Modelos diferentes = Conjunto de
variáveis diferentes Dependendo das capacidades do
resolvedor, um modelo pode requerer menos busca que outro para achar uma resposta
A comparação empírica pode ser a medida do tempo ou esforço gasto
Modelando diferentemente o (mesmo) Problema
Problema de simples atribuição: quatro trabalhadores w1,w2,w3,w4 e quatro produtos p1,p2,p3,p4. Atribua um produto a um trabalhador de modo que o lucro L >= 19
p p p pwwww
1 2 3 41 7 1 3 42 8 2 5 13 4 3 7 24 3 1 6 3
A matriz de Lucro é:
Modelo 1: Pesquisa de Operações
p p p pwwww
1 2 3 41 7 1 3 42 8 2 5 13 4 3 7 24 3 1 6 3
16 variáveis booleanas Bij significando que otrabalhador i está com o produto j
193632734
528437
1
1
44434241
34333231
24232221
14131211
4
14
1
4
14
1
PBBBBBBBBBBBBBBBB
P
B
B
i ijj
j iji
11 restrições primárias,28 escolhas para achar todas as quatro soluções
B23
Somatória de j é 1 (um só produto por trabalhador)Somatória de i é 1 (um só trabalhador por produto)
Modelo 2: melhorUsando a desigualdade e restrições complexas. Quatro variáveis W1,W2,W3,W4 correspondendo aos trabalhadores
p p p pwwww
1 2 3 41 7 1 3 42 8 2 5 13 4 3 7 24 3 1 6 3
alldifferent W W W Welement W WPelement W WPelement W WPelement W WPP WP WP WP WPP
([ , , , ])( ,[ , , , ], )( ,[8, , , ], )( ,[ , , , ], )( ,[ , , , ], )
1 2 3 41 7 1 3 4 12 2 51 23 4 3 7 2 34 31 6 3 4
1 2 3 419
7 restrições primárias,14 escolhas para achar todas as quatro soluções
W1W2W3W4
1 2 3 4
Modelo 3: DiferenteQuatro variáveis T1,T2,T3,T4 correspondendo aos produtos.
p p p pwwww
1 2 3 41 7 1 3 42 8 2 5 13 4 3 7 24 3 1 6 3
alldifferent T T T Telement T TPelement T TPelement T TPelement T TPP TP TP TP TPP
([ , , , ])( ,[ , , , ], )( ,[ , , , ], )( ,[ , , , ], )( ,[ , , , ], )
1 2 3 41 7 8 4 3 12 1 2 3 1 23 3 5 7 6 34 4 1 2 3 4
1 2 3 419
7 restrições primárias,7 escolhas para achar todos as quatro soluções
1234
T1 T2 T3 T4
Comparando os Modelos A eficiência relativa vem de:
Mapeamento mais direto às restrições primitivas Menos variáveis Normalmente requer avaliação empírica
Outro critério de eficiência: flexibilidade (adicionar restrições novas) e.g. trabalhador 3 deve trabalhar num produto > que
o do trabalhador 2B BB BB B BB B B B
31 24
32 21
33 21 22
34 21 22 23
0 0 W W3 2 ?????
Modelo 1 Modelo 2 Modelo 3
Combinando Modelos Combine os modelos relacionando as
variáveis e seus valores em cada um dos modelos
e.g. B13 = 1 significa W1 = 3 que significa T3 = 1
Modelos combinados podem ganhar mais eficiência atráves da informação que é propagada
A restrição primária iff(V1,D1,V2,D2) é verdade para V1=D1 se e somente se V2=D2
Modelos Combinadosalldifferent T T T Telement T TPelement T TPelement T TPelement T TPP TP TP TP TP
([ , , , ])( ,[ , , , ], )( ,[ , , , ], )( ,[ , , , ], )( ,[ , , , ], )
1 2 3 41 7 8 4 3 12 1 2 3 1 23 3 5 7 6 34 4 1 2 3 4
1 2 3 4
alldifferent W W W Welement W WPelement W WPelement W WPelement W WPP WP WP WP WPP
([ , , , ])( ,[ , , , ], )( ,[8, , , ], )( ,[ , , , ], )( ,[ , , , ], )
1 2 3 41 7 1 3 4 12 2 51 23 4 3 7 2 34 31 6 3 4
1 2 3 419
iff W T iff W T iff W T iff W Tiff W T iff W T iff W T iff W Tiff W T iff W T iff W T iff W T
( , , , ) ( , , , ) ( , , , ) ( , , , )( , , , ) ( , , , ) ( , , , ) ( , , , )( , , , ) ( , , , ) ( , , , ) ( , ,
11 11 1 2 2 1 1 3 31 1 4 4 12 1 1 2 2 2 2 2 2 3 3 2 2 4 4 231 1 3 3 2 2 3 3 3 3 3 3 4 4
, )
( , , , ) ( , , , ) ( , , , ) ( , , , )3
4 1 1 4 4 2 2 4 4 3 3 4 4 4 4 4
iff W T iff W T iff W T iff W T
39 restrições prim. 5 escolhas para achar todas soluções
Resolvedor baseado em Consistência do Arco Assumimos que o sistema CLP(FD) usa um resolvedor
de propagação de limites A Consistência do Arco permite que mais valores
sejam eliminados nas relações binárias das variáveis Exemplo:
Suponha o problema das 8-Rainhas, com uma solução parcial de D(R1)={2}, D(R2)={4}, D(R3)={6}
O resolvedor de restrições baseado em consistência de limites determinará os domínios:
• D(R4)=[1..8], D(R5)=[3..5], D(R6)=[1..5], D(R7)=[1..7], D(R8)=[3..8]
O resolvedor de restrições baseado em consistência de arcos determinará os valores:
• D(R4)={1,3,8}, D(R5)={3,5}, D(R6)={1,5}, D(R7)={1,3,5,7}, D(R8)={3,5,7,8}
Resolvedor baseado em Consistência do Arco O resolvedor baseado em consistência do
arco dá informações muito mais acuradas dos valores possíveis para as variáveis
Outra vantagem é que este resolvedor trabalha tão bem com valores limitados quanto com coleções, enquanto o resolvedor baseado em limites trabalha bem apenas com restrições aritméticas
O programador define a RDU como uma relação binária com múltiplos fatos, e as rotula com a palavra reservada “consistent”, que indica ao CLP que ele deve resolver a relação utilizando consistência de arcos.
Resolvedor baseado em Consistência do Arco
Por exemplo, o programa:
E os objetivos:
likes(joaquim, maria).likes(joaquim, nicole).likes(joaquim, erica).likes(pedro, maria).likes(bernardo, nicole).likes(bernardo, maria).likes(bernardo, erica).
EMENMN ,,Obj1:[N,M,E]::[joaquim, pedro, bernardo],likes(N, neila),likes(M, maria),likes(E, erica).Obj2:[N,M,E]::[joaquim, pedro, bernardo],likes(N, neila) consistent, likes(M, maria) consistent, likes(E, erica) consistent, labeling([N,M,E]).
EMENMN ,,
Resolvedor baseado em Consistência do Arco
Predicados de aridade maior se resolvem pela consistência de hiper-arcos e com predicados unários, consistência de nós.
No exemplo anterior, no objetivo 2, ao invés de fazer o backtracking pelas diferentes regras (caso do objetivo 1), é utilizada a consistência de arcos para avaliar a relação likes. Assim, as desigualdades e as restrições levam ao seguinte domínio:
D(N)={joaquim, bernardo}, D(M)={joaquim, bernardo, pedro}, D(E)={joaquim, bernardo}
A execução do labeling leva D(N)={joaquim}, e a consistência do arco devolve
D(M)={pedro}, D(E)={bernardo}Assim nenhuma outra escolha é necessária para achar a primeira solução. Se for pedida outra solução, o backtraking faz imediatamente D(N)={bernardo} e as restrições da consistência do arco se propagam, não sendo necessária nenhuma outra escolha para a segunda solução
Restrição Reified Uma restrição reified r B
adiciona uma variável booleana B a uma restrição primitiva r
Se r ocorre, então B = 1 Se r não ocorre, então B = 0 A propagação é em ambas as
direções
Restrição Reified Usada para construir combinações
complexas sem usar “escolhas” Imagine que queremos que, das nossas 4
restrições primitivas, sejam satisfeitas apenas 2 ou 3. Isso geraria regras com muitas combinações…
comb(X,Y):- c1, c2, ¬c3, ¬c4.comb(X,Y):- c1, ¬c2, c3, ¬c4.comb(X,Y):- c1, ¬c2, ¬c3, c4.comb(X,Y):- ¬c1, c2, c3, ¬c4.comb(X,Y):- ¬c1, c2, ¬c3, c4....
C1 B1, C2 B2, C3 B3, C4 B4,
B = B1 + B2 + B3 + B4,
2<=B, B<=3
top related