Mutually exclusion in a logic task

Question

There is three friends - misha, petya, vova. Surnames: ivanov, semyonov, gerasimov.

name(misha).
name(vova).
name(petya).
surname(ivanov).
surname(semyonov).
surname(gerasimov).

misha isn't gerasimov.

full_name(misha,X) :- 
surname(X),
X \= gerasimov.

vova is studying in the 6th grade. gerasimov is in the 5th. How to define surnames (several) of vova?

The father of vova is an engineer, the father of ivanov is a locksmith.

father(vova,ingeneer).
father(ivanov,locksmith).

How to define surname (one) of vova?

I think this would be a good task for CHR rather than vanilla Prolog. — Daniel Lyons, Aug 10 '19 at 07:41
thanks. how make CHR program in Prolog syntax for this task? — demsee, Aug 10 '19 at 08:30

score 2 · Accepted Answer · answered Aug 10 '19 at 14:03

First we need to capture the fact that each name has one of the given surnames.

is_one_of(Name, [ivanov, semyonov, gerasimov]) :-
    member(Name, [misha, vova, petya]).

We are also given characteristics (studying, father) about names and surnames, each one with different values. This is captured by the following predicates.

name_characteristic(vova, studying, sixth_grade).
name_characteristic(vova, father, ingeneer).

surname_characteristic(gerasimov, studying, fifth_grade).
surname_characteristic(ivanov, father, locksmith).

We are also given that gerasimov is_not the surname of misha.

is_not(misha, gerasimov).

Rule 1: Name cannot have Surname if for some common characterictic, their values are different.

is_not(Name, Surname) :-
    name_characteristic(Name, Characteristic, Value1),
    surname_characteristic(Surname, Characteristic, Value2),
    Value1 \= Value2.

Rule 2: Name must have Surname if none of the other possible surnames is the surname of Name.

is_(Name, Surname) :-
    is_one_of(Name, Surnames),
    select(Surname, Surnames, RemainingSurnames),
    is_none_of(Name, RemainingSurnames).

is_none_of(_, []).
is_none_of(Name, [Surname | RemainingSurnames]) :-
    is_not(Name, Surname),
    is_none_of(Name, RemainingSurnames).

Querying for is(vova, Surname) yields:

Surname = semyonov

Querying for is_not(Name, Surname) yields:

Name = misha,
Surname = gerasimov

Name = vova,
Surname = gerasimov

Name = vova,
Surname = ivanov

score 1 · Answer 2 · answered Aug 12 '19 at 20:11

This solution uses the chr library, which is actually a somewhat different language than Prolog. I am learning CHR now myself and this is actually my second program or so written with it. It may be overly similar to that or the improved version I got on the mailing list. So take it with a grain of salt.

CHR seems to me to be a good fit for programs that start with a lot of possibilities and then cancel out bad possibilities. Perhaps the cancelling can continue until you converge on a solution. That's the way this program works, we generate all the possible name/surname sets and then use our impossibility constraints to reduce the possible surname sets until they converge to one, whereupon we remove them from the other name/surname sets until everything converges.

The first two lines introduce the library and the constraints we'll be using:

:- use_module(library(chr)).
:- chr_constraint name/1, surnames/1, impossible/2, matched/2, possible/2.

The first constraint generates the possibilities we need to walk over.

gen_possibilities @
  name(Name), surnames(Surnames)
  ==> possible(Name, Surnames).

The idea here is that we have the surnames in a list already and we're just making a pair called possible between each name and the totality of possible surnames.

impossibility @
  impossible(Name, Surname), possible(Name, Surnames)
  <=> select(Surname, Surnames, Remaining) 
  | possible(Name, Remaining).

Once we are told something is impossible, we can simply remove it from the list of possible surnames for that name. select/3 is useful for removing single items from a list and giving you the remainder. We use a guard here in case the surname is already not present in the possible list of surnames, as may happen after the fourth constraint is applied.

only_possiblity @
  possible(Name, [Surname])
  <=> matched(Name, Surname).

Once that list of possibilities dwindles to a single name, we have successfully made a match.

remove_matched @
  matched(_, Surname), possible(Name, _)
  ==> impossible(Name, Surname).

If we have made a match, then that surname becomes impossible for all the other names.

An additional cleanup constraint may be added but is not required, if an impossibility constraint cannot be absorbed because the name was already taken care of:

irrelevant_impossibility @
  possible(Name, Surnames) 
  \ impossible(Name, Surname)
  <=> \+ memberchk(Surname, Surnames) 
  | true.

Now we can run the program. I have taken the liberty of inlining the logic for the 5th/6th grade and different fathers. I felt like the intent was easy enough to figure out by reading and I didn't think I'd gain much by modeling it specifically. Kudos to @RobertBaron for going to the trouble in his solution!

main :-
    name(misha),
    name(vova),
    name(petya),
    surnames([ivanov, semyonov, gerasimov]),
    impossible(misha, gerasimov),  % stated impossible
    impossible(vova, gerasimov),   % different grades
    impossible(vova, ivanov).      % different fathers

The result of executing this is:

?- main.
name(petya),
name(vova),
name(misha),
surnames([ivanov, semyonov, gerasimov]),
matched(petya, gerasimov),
matched(misha, ivanov),
matched(vova, semyonov).

I believe this fulfill the constraints set before you.

Mutually exclusion in a logic task

2 Answers2