Como codifico isso na programação do conjunto de respostas?

Question

Eu sou um novato total para responder a programação definida e estou lutando com uma pergunta bastante simples. O programa deve ser escrito em clingo.

Então aqui está a questão:

Uma estrutura de argumentação abstrata consiste em um conjunto A de argumentos e uma relação de ataque R ⊆ AXA entre eles. Para quaisquer dois argumentos a1 e a2, se (a1, a2) ∈ R então dizemos que a1 ataca a2: se alguém admite o argumento a1, então ele lança dúvidas sobre o argumento a2. Formalmente, um subconjunto de argumentos E ⊆ A é estável se as seguintes duas condições forem válidas:

1. nenhum argumento em E ataca qualquer outro argumento de E.
2. qualquer argumento fora de E é atacado por um argumento de E.

Escreva um programa ASP que identifique subconjuntos estáveis ​​de argumentos em uma determinada instância por meio de conjuntos de respostas. A instância será fornecida por meio de dois predicados argumento / 1 e ataque / 2 correspondendo a A e R respectivamente.

Aqui está um exemplo:

argument (a).    
argument (b).    
argument (c).    
argument (d).    
attack (a,b).    
attack (b,c).    
attack (d,c).

Saída válida:

choose (a) choose (d)

Foi o que tentei, o que obviamente está errado:

choose(X)  :- argument(X), attack(X,Y).

Eu não sei como abordar isso.

Por favor ajude.

Answer 1

Uma abordagem simples de solução em 3 etapas é a seguinte:

1. descreva os fatos (verifique)
2. gere o que deseja como resultado, mas deixe a escolha do programa
3. dar regras que soluções não se aplicam

Portanto, comece com 2:

gerar resultados possíveis. Pense em palavras simples: para cada argumento, eu escolho ou não.
A parte pode ou não pode ser resolvida com um subsum {}.

{choose(X)} :- argument(X).

ou ainda mais simples: eu escolho uma subsum dos argumentos

{choose(X):argument(X)}. 

Vamos verificar as soluções com Potassco e #show choose/1.modo ressonante enumerate all:

Answer: 1

Answer: 2
choose(b)
Answer: 3
choose(c).
..
Answer: 15
choose(a) choose(b) choose(c)
Answer: 16
choose(a) choose(b) choose(c) choose(d)
SATISFIABLE

Todas as combinações são encontradas. É hora de remover o material errado. Novamente: pense em palavras simples: Não é possível que eu escolha dois argumentos onde um ataca o outro. (Se a cabeça for deixada aberta, isso é considerado falso.)

:- choose(X), attack(X,Y), choose(Y).

Agora verifique novamente:

Answer: 1

Answer: 2
choose(a)
Answer: 3
choose(d)
Answer: 4
choose(a) choose(d)
Answer: 5
choose(c)
Answer: 6
choose(a) choose(c)
Answer: 7
choose(b)
Answer: 8
choose(b) choose(d)
SATISFIABLE

Agora precisamos ter certeza de que cada argumento não escolhido seja atacado por pelo menos um elemento escolhido:

1 {choose(Y):attack(Y,X)} :- argument(X), not choose(X).

Lê: Para cada argumento X, que não é escolhido, o número de argumentos escolhidos que o atacam é pelo menos um.

Vamos verificar:

Answer: 1
choose(a) choose(d)
SATISFIABLE

Agradável.

Como as restrições são normalmente formuladas com a cabeça vazia, vamos reformular a última regra:

:- argument(X), not choose(X), {choose(Y):attack(Y,X)} 0.

Lê: Não há nenhum argumento X, que não é escolhido e tem no máximo 0 argumentos escolhidos, que atacam X. Ele dá a mesma saída.

Código completo:

argument (a;b;c;d).   
attack (a,b).    
attack (b,c).    
attack (d,c).

{choose(X):argument(X)}.
:- choose(X), attack(X,Y), choose(Y).
:- argument(X), not choose(X), {choose(Y):attack(Y,X)} 0.

#show choose/1.