Не повторяйте решения на Прологе

Пролог всегда будет пытаться найти все возможные решения, доступные для ваших утверждений, учитывая ваш набор истин. Расширение работает как поиск в глубину:

son(a, d).
son(b, d).
son(a, c).
son(b, c).

brother(X, Y) :-
    son(X, P),
    son(Y, P),
    X \= Y.

                         brother(X, Y)
       _______________________|____________________________        [son(X, P)]
      |               |                  |                 |
X = a, P = d     X = b, P = d       X = a, P = c      X = a, P = b
      |               |                  |                 |  
      |              ...                ...               ...
      |
      | (X and P are already defined for this branch;
      |  the algorithm now looks for Y's)
      |__________________________________________                  [son(Y, d)]
                |                                |
      son(a, d) -> Y = a               son(b, d) -> Y = b
                |                                |
                |                                |                 [X \= Y]
      X = a, Y = a -> false            X = a, Y = b -> true
                                                 |
                                                 |
                                  solution(X = a, Y = b, P = d)

Но, как видите, расширение будет выполнено во всех ветвях, так что вы получите больше похожего на окончательный ответ решения. Как указал @Daniel Lyons, вы можете использовать встроенный setof.

Вы также можете использовать оператор ! -- cut -- который останавливает "горизонтальное" расширение, как только ветвь будет признана допустимой, или добавить оператор, позволяющий избежать множественных решений.

Для получения дополнительной информации взгляните на алгоритм объединения.

Во-первых, я бы посоветовал не обновлять базу данных Prolog динамически. По некоторым причинам рассмотрите статью "Как обращаться с динамической базой данных Prolog?".

Вы можете использовать комбинацию встроенных setof/3 и member/2, как предложил @DanielLyons в своем ответе.

В качестве еще одной альтернативы рассмотрим следующий запрос, в котором setof/3 используется довольно необычным образом, например так:

?- setof(t,brother(X,Y),_).
X = a, Y = b ;
X = b, Y = a.

Вы можете исключить один набор с помощью сравнения:

brother(X, Y) :-
   son(X, P),
   son(Y, P),
   X \= Y, X @< Y.

?- brother(X, Y).
X = a,
Y = b ;
X = a,
Y = b ;
false.

Поскольку X и Y будут реализованы в обоих направлениях, требование, чтобы X было меньше Y, является хорошим способом сократить количество решений вдвое.

Ваша вторая проблема заключается в том, что X и Y являются братьями более чем по одному родителю. Самым простым решением здесь было бы сделать ваши правила более явными:

mother(a, d).
mother(b, d).
father(a, c).
father(b, c).

brother(X, Y) :-
  mother(X, M), mother(Y, M),
  father(X, F), father(Y, F),
  X \= Y, X @< Y.

?- brother(X, Y).
X = a,
Y = b ;
false.

Этот метод очень специфичен для этой конкретной проблемы, но лежащие в его основе рассуждения не таковы: у вас было две копии, потому что a и b являются «братьями» по c, а также по d — Пролог был прав, создав это решение дважды, потому что была скрытая переменная. присваивается два разных значения.

Более элегантным решением, вероятно, было бы использование setof/3 для получения решений. Это может работать даже с вашим исходным кодом:

?- setof(X-Y, (brother(X, Y), X @< Y), Brothers).
Brothers = [a-b].

Недостатком этого подхода является то, что вы получаете список, а не Пролог, генерирующий различные решения, хотя вы можете исправить это поведение с помощью member/2.

Это должно работать. Но я думаю, что это можно улучшить (я не специалист по Прологу):

brother(X, Y) :-
    son(X, P1),
    son(Y, P1),
    X @< Y,
    (son(X, P2), son(Y, P2), P1 @< P2 -> false; true).

Если вы используете компилятор Strawberry Prolog, вы не получите все ответы, набрав это:

?- brother(X, Y),
   write(X), nl,
   write(Y), nl.

Чтобы получить все ответы, напишите это:

?- brother(X, Y),
   write(X), nl,
   write(Y), nl,
   fail.

Я надеюсь, что это поможет вам. :)

Я пришел к ответу.

% Include the dictionary
:- [p1]. % The dictionary with sons

:- dynamic(found/2).

brother(X, Y) :-
    % Get two persons from the database to test
    son(X, P),
    son(Y, P),

    % Test if the two persons are different and were not already used
    testBrother(X, Y).

% If it got here it's because there is no one else to test above, so just fail and retract all
brother(_, _) :-
    retract(found(_, _)),
    fail.

testBrother(X, Y) :-
    X \= Y,
    \+found(X, Y),
    \+found(Y, X),

    % If they were not used succed and assert what was found
    assert(found(X, Y)).

Он всегда возвращает сбой в конце, но он преуспевает в следующем.

• брат(Х, Y). % Каждый брат без повторения
• брат('Уррака', X). % Каждый брат Урраки без повторения
• брат («Уррака», «Санчо I»). % Верно, ведь у Уррака и Санчо у меня одни и те же отец и мать. На самом деле, даже если бы у них была только одна и та же мать или один и тот же отец, это вернет правду. Немного не в контексте, но все же верно, если у них три или более общих родителей, это все равно будет работать.

Это не удается со следующим:

• брат(Х, Х). % Неверно, потому что это один и тот же человек
• брат('Нет', X). % False, потому что нет даже в базе данных
• брат («Нет», «Санчо I»). % Ложь по той же причине

Таким образом, я могу, например, спросить: брат (X, Y) и начать нажимать «;» увидеть каждого брата и сестру без повторения.

Я также могу выполнить команду Brother(a, b) и Brother(b, a), предполагая, что a и b являются людьми в базе данных. Это важно, потому что некоторые решения будут использовать @‹ для проверки вещей, и, например, Brother(b, a) потерпит неудачу.

Вот оно.