Seating Arrangements: Solutions

**************************************
*** PROGRAM 1, for smodels
*** By Son Cao Tran (tson@cs.nmsu.edu)
**************************************

% const tables and chairs are input parameters

% number of guests equals tables*chairs

const guests = tables*chairs.

% type predicates

table(1..tables).
guest(1..guests).

% at(G,T) - guest G sits at the Tth table
% each guest has one sit

1{at(G,T) : table(T)}1 :-
    guest(G).

chairs {at(G,T) : guest(G)} chairs :- table(T).

% defining what is means to be on the same/different tables

same_table(G,G):- guest(G).

same_table(G1,G2):-
    table(T), guest(G1), guest(G2), neq(G1,G2),
    at(G1,T), at(G2,T).

% guests, who like each other, should sit on the same table

:- guest(G1), guest(G2), like(G1,G2), not same_table(G1,G2).

% guests, who hate each other, should not sit on the same table

:- guest(G1), guest(G2), dislike(G1,G2), same_table(G1,G2).

hide.
show at(I,J).

*******************************************
*** PROGRAM 2,for PAL
*** By Pedro Cabalar (cabalar@dc.fi.udc.es)
*******************************************

options
  not concurrent;
constants
  m = 3;
  n = 2;
sets
  chair = [1,m];
  table = [1,n];
  seat = chair x table;
  person = [1,m*n];
  dislikes = {(1,2),(3,7)};
  likes = {(2,5)};
  
actions
  sit: person -> seat;
fluents
  at: seat -> person + {empty};
  pos: person -> seat + {standing};
  
vars
  P,P2 : person;
  S    : seat;
  C,C2 : chair;  
  T    : table;
rules
  /* Any person will be at the place where he is sat */
  pos(P):=sit(P);

  /* The content of the occupied seat is the person we have sat */
  at(sit(P)):=P;  
  
  /* Sit down on empty seats */
  false if prev(at(sit(P))) != empty;

  /* Sit persons that were standing */
  false if pert(sit(P)) and prev(pos(P))!=standing;
  
  /* Avoid "dislikes" */
  false if pos(P)=(C,T) and pos(P2)=(C2,T) and (P,P2) in dislikes;
  /* Force "likes" */
  false if pos(P)=(C,T) and pos(P2)=(C2,T2) and T!=T2 and (P,P2) in likes;
  
initially
  at(S):=empty, pos(P):=standing;
  
query ...{m*n} ?

*****************************************
*** PROGRAM 3, for smodels
*** By Paolo Ferraris (pieffe8@libero.it)
*****************************************

% number of tables
const n=2.
% number of seats per table
const m=3.
% number of guests
const tot=n*m.

guest(1..tot).
table(1..n).

% two friends sit at the same table
atTable(Y,Z) :- friend(X,Y), atTable(X,Z), table(Z).
% two not friends cannot sit at the same table
:- notFriend(X,Y), atTable(X,Z), atTable(Y,Z), table(Z).
% one person sits at only one table
1 [atTable(X,Y): table(Y)] 1 :- guest(X).
% exactly M persons sit at the same table
m [atTable(X,Y): guest(X)] m :- table(Y).

*****************************************
*** PROGRAM 4, for smodels
*** By Paolo Ferraris (pieffe8@libero.it)
*****************************************

% number of tables
const n=2.
% number of seats per table
const m=3.
% number of guests
const tot=n*m.

guest(1..tot).

% two friends sit at the same table
sameTable(X,Y) :- friend(X,Y).
% two not friends cannot be at the same table
:- sameTable(X,Y), notFriend(X,Y).
% reflexive property of SameTable
sameTable(X,X) :- guest(X).
% transitive property of SameTable
sameTable(X,Y) :- sameTable(Y,Z), sameTable(Z,X),
                  guest(X), guest(Y), guest(Z).
% note: symmetry can obtained from the previous rule when Z=X
% exactly M persons sit at the same table
m [sameTable(X,Y): guest(X)] m :- guest(Y).

**************************************************************
*** PROGRAM 5, for SLDNA
*** By Marc Denecker (Marc.Denecker@cs.kuleuven.ac.be)
*** and Bert Van Nuffelen (Bert.VanNuffelen@cs.kuleuven.ac.be)
**************************************************************

table(X)<- X in 1..N
person(X)<- X in 1..MN
open_function at_table: person -> table

likes(..,..)<- true.
dislikes(..,..)<-true.

fol forall X,Y: likes(X,Y), at_table(X,TX), at_table(Y,TY) -> TX=TY.
fol  forall X,Y: dislikes(X,Y), at_table(X,TX), at_table(Y,TY) -> TX\=TY.

fol forall X,Cap,NrX: capacity(Cap),table(X), Card(set(Y,at_table(Y,X)),NrX)
                                                                -> NrX=<Cap.

**************************************
*** PROGRAM 6, for ccalc
*** By Esra Erdem (esra@cs.utexas.edu)
**************************************

:- sorts table; chair; guest.

:- variables
	G,G1 :: guest;
	T :: table;
	C :: chair.

:- constants
	1..N :: table;
	1..M :: chair;
	1..N*M :: guest;
	likes(guest,guest), 
	dislikes(guest,guest),
	assign_table(guest,table),
	assign_chair(guest,chair) :: cwAtomicFormula.

% start with an arbitrary arrangement.
assign_table(G,T) :- not (not assign_table(G,T)).
assign_chair(G,C) :- not (not assign_chair(G,C)).

% make sure that everyone sits at a chair at some table,
:- not \/T: assign_table(G,T).
:- not \/C: assign_chair(G,C).

% that no two guests sit at the same chair,
:- assign_table(G,T), assign_table(G1,T),
   assign_chair(G,C), assign_chair(G1,C), G < G1.

% that the ones who like each other sit at the same table,
:- not assign_table(G,T), likes(G,G1), assign_table(G1,T).

% and that the ones who do not like each other do not sit at the same table.
:- assign_table(G,T), dislikes(G,G1), assign_table(G1,T).

% display the arrangement only.
:- show assign_table(G,T).

******************************************
*** PROGRAM 7, for smodels
*** by Selim Erdogan (selim@cs.utexas.edu)
******************************************

% Party Facts

% The number of tables (n) and the number of chairs around each table (m) 
% need to be specified.  There will be (m * n) guests.

% e.g.
% const n=2.
% const m=2.

table(1..n).
guest(1..m*n).

% guests who like each other and guests who dislike each other need to be
% indicated. likes(i,j) means that guests i and j like each other.  
% dislikes(i,j) means that i and j dislike each other.

% e.g.
% likes(1,2).
% dislikes(3,4).

%%%%%%%%%%%%%%%%%%%%%%%%

% GENERATE

% m guests should be seated at each table
m { at_table(G,T) : guest(G) } m :- table(T).


% TEST

% a guest cannot be seated at more than one table
:- guest(G), table(T), table(T1), T != T1, at_table(G,T), at_table(G,T1).

% guests who dislike each other cannot sit at the same table
:- guest(G), guest(G1), table(T), dislikes(G,G1), at_table(G,T),
     at_table(G1,T).

% guests who like each other cannot sit at different tables.
:- guest(G), guest(G1), table(T), likes(G,G1), at_table(G,T), 
     not at_table(G1,T).


% DISPLAY

hide.
show at_table(G,T).

********************************************
*** PROGRAM 8, for smodels
*** By Joohyung Lee (appsmurf@cs.utexas.edu)
********************************************

% Command line: lparse -c numTables=N -c numChairs=M newyears | smodels

table(1..numTables).
person(1..numTables*numChairs).

% Generate

numChairs { person_table(P,T) : person(P) } numChairs :- table(T).
1 { person_table(P,T) : table(T) } 1 :- person(P).

% The rule above can be replaced with the following. However, Smodels runs 
% faster with the rule above.
% :- person_table(A,T), person_table(A,T1), T != T1, person(A),table(T),
     table(T1).

% Test

:- dislikes(A,B), person_table(A,T), person_table(B,T),
   person(A), person(B), table(T).

:- likes(A,B), person_table(A,T), person_table(B,T1), T != T1, 
   person(A), person(B), table(T), table(T1).

compute all {}.

% Define (Depends on an instance of problem)

likes(1,2).
likes(3,6).

dislikes(3,4).
dislikes(2,3).
dislikes(4,5).

**************************************
*** PROGRAM 9, for SEM
*** By Esra Erdem (esra@cs.utexas.edu)
**************************************

%% Sorts

( table [2] )
( chair [4] )
( guest [8] )

%% Functions

{ assign_table : guest -> table }
{ assign_chair : guest -> chair }
{ likes : guest guest -> BOOL }
{ dislikes : guest guest -> BOOL }

%% Clauses

[ likes(1,3) ] 
[ likes(2,4) ] 

[ dislikes(1,5) ]
[ dislikes(3,4) ]

[ -likes(x,y) | assign_table(x) = assign_table(y) ]
[ -dislikes(x,y) | assign_table(x) != assign_table(y) ]

[ assign_chair(x) != assign_chair(y) | assign_table(x) != assign_table(y)
  | x=y]

************************************
*** PROGRAM 10, for smodels
*** By Chitta Baral (chitta@asu.edu)
************************************

const n = 3.
const m = 3.
const k = n*m.

table(1..n).
person(1..k).

m { assigned(P,T) : person(P) } m :- table(T).

1 { assigned(P,T) : table(T) } 1 :- person(P).

:- person(I), person(J),
   table(T), table(TT),
   together(I,J),
   assigned(I,T), assigned(J,TT),
   neq(T,TT).

:- person(I), person(J),
   table(T),
   separate(I,J),
   assigned(I,T), assigned(J,T).

together(1,2).
together(7,4).
together(6,8).
separate(2,3).
separate(3,4).
separate(5,6).
separate(9,4).

hide person(X).
hide table(X).
hide together(X,Y).
hide separate(X,Y).

************************************
*** PROGRAM 11, for smodels
*** By Chitta Baral (chitta@asu.edu)
************************************

const n = 3.
const m = 3.
const k = n*m.

table(1..n).
person(1..k).

:- m+1 { assigned(P,T) : person(P) },  table(T).
:- { assigned(P,T) : person(P) } m-1,  table(T).

not_assigned(P,T) :- person(P), table(T), table(TT),
                     assigned(P,TT), neq(T,TT).

not_assigned(P,T) :- person(P), person(PP),
                     table(T), table(TT),
                     together(P,PP),
                     assigned(PP,TT),
                     neq(T,TT).

%by having together(P,P), we can remove the last but one rule.

not_assigned(P,T) :- person(P), person(PP),
                     table(T),
                     separate(P,PP),
                     assigned(PP,T).

assigned(P,T) :- person(P), table(T),
                 not not_assigned(P,T).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

together(1,2).
together(7,4).
together(6,8).
separate(2,3).
separate(3,4).
separate(5,6).
separate(9,4).

hide person(X).
hide table(X).
hide together(X,Y).
hide separate(X,Y).
hide not_assigned(X,Y).

************************************
*** PROGRAM 12, for smodels
*** By Chitta Baral (chitta@asu.edu)
************************************

const n = 3.
const m = 3.
const k = n*m.

table(1..n).
person(1..k).

m { assigned(P,T) : person(P) } m :- table(T).

:-  person(I), table(T),
    table(TT), assigned(I,T), assigned(I,TT),
    neq(T,TT).

:- person(I), person(J),
   table(T), table(TT),
   together(I,J),
   assigned(I,T), assigned(J,TT),
   neq(T,TT).

:- person(I), person(J),
   table(T),
   separate(I,J),
   assigned(I,T), assigned(J,T).

together(1,2).
together(7,4).
together(6,8).
separate(2,3).
separate(3,4).
separate(5,6).
separate(9,4).

hide person(X).
hide table(X).
hide together(X,Y).
hide separate(X,Y).

********************************************
*** PROGRAM 13, for smodels
*** By Michael Gelfond (mgelfond@cs.ttu.edu)
********************************************

% There is one to one correspondence
% between the solutions and the sets of atoms of the 
% form at(person,table) from stable models of our program.

%%%%%%%%%  INPUT

const n=10.   % number of tables
const m=10.    % number of chairs
const k=n*m.  % number of people

table(1..n).
person(1..k).

% The input database. We assume the data to be correct.

like(1,2).
like(3,4).
like(5,6).
like(10,13).
like(10,11).
like(4,5).

dislike(1,5).
dislike(1,6).
dislike(12,16).
dislike(13,14).
dislike(7,8).
dislike(7,9).

% Symmetry Rules

like(X,Y) :- like(Y,X), person(X), person(Y).

dislike(X,Y) :- dislike(Y,X), person(X), person(Y).

%%%%%%%%%%%  SOLUTION

% SELECT a candidate solution - m people to seat at each table

m{at(P,T) : person(P)}m :- table(T).

%  People who dislike each other should seat at different tables

:- table(T),
   person(P1),
   person(P2),
   at(P1,T),
   at(P2,T),
   dislike(P1,P2).

%  People who like each other should seat at the same table

:- table(T),
   person(P1),
   person(P2),
   at(P1,T),
   not at(P2,T),
   like(P1,P2).

%  A person is seated at at most one table.

:- table(T1),
   table(T2),
   neq(T1,T2),
   person(P),
   at(P,T1),
   at(P,T2).

hide like(A,B).
hide dislike(A,B).
hide person(A).
hide table(A).

*********************************************
*** PROGRAM 14, for smodels
*** By Marcello Balduccini (marcy@cs.ttu.edu)
*********************************************

% Objects
% -------
%
%  o Tables (N)
%  o Chairs (M)
%  o Guests (MN)
%
% Relations
% ---------
%
%  o SModels Types (table/1, chair/1, guest/1)
%
%  o Guest G1 likes guest G2
%       likes(G1,G2)
%
%  o Guest G1 dislikes guest G2
%       dislikes(G1,G2)
%
%  o Guest g sits at table t on chair c
%       sits(g,t,c)

% no two guests can sit on the same chair at the same table
:- guest(G1), guest(G2),
   table(T),
   chair(C),
   sits(G1,T,C), sits(G2,T,C),
   neq(G1,G2).

% a guest cannot sit in two different positions at the same time
:- guest(G),
   table(T1), chair(C1),
   table(T2), chair(C2),
   sits(G,T1,C1), sits(G,T2,C2),
   neq(T1,T2).

:- guest(G),
   table(T),
   chair(C1), chair(C2),
   sits(G,T,C1), sits(G,T,C2),
   neq(C1,C2).

% if G1 likes G2, then G1 and G2 cannot be at different tables
:- guest(G1), guest(G2),
   table(T1), table(T2),
   chair(C1), chair(C2),
   likes(G1,G2), sits(G1,T1,C1), sits(G2,T2,C2),
   neq(T1,T2).

% if G1 dislikes G2, then G1 and G2 cannot be at the same table
:- guest(G1), guest(G2),
   table(T),
   chair(C1), chair(C2),
   dislikes(G1,G2), sits(G1,T,C1), sits(G2,T,C2).

%--------> arrangement generation <----------
% assign a chair at a table to each guest

sits(G,T,C) :- guest(G),
	       table(T),
	       chair(C),
	       not other_location(G,T,C).

other_location(G,T1,C1) :- guest(G),
			   table(T1), table(T2),
			   chair(C1), chair(C2),
			   sits(G,T2,C2),
			   neq(T1,T2).

other_location(G,T,C1) :- guest(G),
			  table(T),
			  chair(C1), chair(C2),
			  sits(G,T,C2),
			  neq(C1,C2).

********************************************
*** PROGRAM 15, for smodels
*** By Veena Mellarkod <mellarko@cs.ttu.edu)
********************************************

const m = 3.        % Capacity of each Table.
const n = 3.        % The number of Tables.

table(1..n).

guest(1..m*n).      % Assuming the guests are 
                    % always m*n, the total capacity.

% like(X,Y) read as "Guest X likes guest Y"
like(1,2).
like(3,4).
like(4,5).

% dislike(X,Y) read as "Guest X dislikes guest Y"
dislike(1,5).
dislike(1,6).

% Number of guests at any table should be 
% equal to the capacity of table.
%  'at_table(G,T)' -- "Guest G is seated at
%  table T" .

m{at_table(G,T) : guest(G)}m :- table(T).

% guests who like each other take the same table.
:- at_table(G1,T1),
   at_table(G2,T2),
   like(G1,G2),
   guest(G1), guest(G2),  
   table(T1), table(T2), neq(T1,T2).
   
% guests who dislike each other take different tables.

:-  at_table(G1,T),
    at_table(G2,T),
    dislike(G1,G2),
    guest(G1),
    guest(G2),
    table(T).

% all guests need to be seated.
% seated(G) -- " Guest G is seated" .
% n_seated(G) -- "Guest G is not seated" .
                                  
 seated(G) :- at_table(G,T), guest(G), table(T). 
 :- guest(G), not seated(G).    

% Show & Hide.

show at_table(G,T).

hide.

*************************************************
*** PROGRAM 16, for smodels
*** By Jonathan Campbell (campbell@cs.utexas.edu)
*************************************************

%%%%% rules specific to each party

const m = 6.
const n = 5.

a(  1,  7).  b(  3, 10).  b(  3, 11).  b(  4, 12).  a(  4, 23).  
b(  7, 28).  a(  7, 30).  b(  9, 30).  b( 11, 13).  b( 11, 17).  
a( 12, 30).  b( 13, 14).  b( 13, 16).  b( 14, 25).  b( 15, 17).  
a( 17, 30).  a( 20, 21).  b( 23, 25).  b( 23, 29).  b( 24, 30).  

%%%%% rules which apply to every party

table(1..n).
guest(1..n*m).

% each guest must be at exactly one table
1 {at(G,T) : table(T)} 1 :- guest(G).

% guests related by a() must not be at different tables
:- at(G1,T1), at(G2,T2), a(G1,G2), guest(G1), guest(G2), table(T1), table(T2),
   T1 != T2.
:- at(G1,T1), at(G2,T2), a(G2,G1), guest(G1), guest(G2), table(T1), table(T2),
   T1 != T2.

% guests related by b() must not be at the same table
:- at(G1,T), at(G2,T), b(G1,G2), guest(G1), guest(G2), table(T).
:- at(G1,T), at(G2,T), b(G2,G1), guest(G1), guest(G2), table(T).

% no table can have more than m guests
:- m+1 {at(G,T) : guest(G)}, table(T).

hide.
show at(G,T).

*******************************************
*** PROGRAM 17, for smodels
*** By Ricardo Morales (morales@cs.ttu.edu)
*******************************************

% First, describe our objects.
% n is the number of tables
% m is the number of seats per table
% m*n is the number of persons

const m = 5.        % No. of seats per table
const n = 5.        % No. of tables

% description of our objects.
person(1..m*n).
table(1..n).
seat(1..m).

% Describe relationships.
% Some people dislike each other.
dislikes(1,5).
dislikes(1,6).
dislikes(12,16).
dislikes(13,14).
dislikes(7,8).
dislikes(7,9).

% Some people like each other
likes(1,2).
likes(3,4).
likes(5,6).
likes(10,13).
likes(10,11).
likes(4,5).

% choice operator
% for every person P chooses a table T

1{choice_table(P,T) : table(T)}1 :- person(P).

% choice operator
% for every person P chooses a seat number S

1{choice_seat(P,S) : seat(S)}1 :- person(P).

% -=-=- CONSTRAINTS -=-=-

% no two people have same table and same seat
:- person(P1),
   person(P2),
   seat(S),
   table(T),
   choice_seat(P1,S), 
   choice_seat(P2,S),
   choice_table(P1,T),
   choice_table(P2,T), 
   P1 != P2.

% Restrictions
% people that dislike each other shall sit separately
:- table(T), 
   dislikes(X,Y), 
   choice_table(X,T), 
   choice_table(Y,T).

% people that like each other must seat togather
:- table(T1), 
   table(T2), 
   likes(X,Y), 
   choice_table(X,T1), 
   choice_table(Y,T2), 
   T1 != T2.

% Hiding information
hide table(X).
hide person(X).
hide seat(X).
hide choice_other_table(T1,P).
hide p_seat(X).
hide choice_other_seat(P,S).
hide likes(X,Y).
hide dislikes(X,Y).

********************************************
*** PROGRAM 18, for smodels
*** By Monica Nogueira (nogueira@cs.ttu.edu)
********************************************

%--------------
% Constants
%--------------

% ntables gives the number of tables,
% nchairs is the number of chairs per table.
% Chairs of a table T are numbered from 1 to nchairs.

% ntables and nchairs are input via command line at run time.
% For this example call smodels using:
% lparse -d none -c nchairs=5 -c ntables=5 newyear.sm | smodels

table(1..ntables).
chair(1..nchairs).
guest(1..ntables*nchairs).

%-----------------------------
% Guests relationship database
%-----------------------------

% Elements of set A
% likes(X,Y) is true iff guest X likes guest Y.

likes(1,2).
likes(3,2).
likes(8,5).

% Elements of set B
% dislikes(X,Y) is true iff guest X dislikes guest Y.

dislikes(4,3).
dislikes(6,2).
dislikes(5,7).

% For a problem without a solution add fact:
%dislikes(6,8).

%-----------------------------
% Input Consistency Conditions
%-----------------------------

% Nobody can like and dislike somebody at the same time.

:- likes(X,Y),
   dislikes(X,Y),
   guest(X), guest(Y), neq(X,Y).

% Adding the above constraint increases efficiency
% of larger instances of the problem.

% The following condition is not necessary because 
% Condition 2 applies only to different people.
% Nobody can dislike oneself.
%:- dislikes(X,X),
%   guest(X).

%------------------
% Program
%------------------

% Generate sitting arrangement via relation
% sits_at(X,C,T) is true iff guest X sits on chair C at table T.

{sits_at(X,C,T)} :- guest(X),
                    chair(C),
                    table(T).

% Test if following conditions are met:

% Condition 1:
% If a guest likes another, they should sit at the same table.

:- likes(X,Y),   
   chair(C1), chair(C2),
   table(T1), table(T2), neq(T1,T2),
   sits_at(X,C1,T1), sits_at(Y,C2,T2), neq(X,Y).

% Condition 2:
% If a guest dislikes another, they should not sit at the same table.

:- dislikes(X,Y),
   table(T), 
   chair(C1), chair(C2), neq(C1,C2),    
   sits_at(X,C1,T), sits_at(Y,C2,T), neq(X,Y).

%-----------------------
% Commonsense conditions
%-----------------------

% Everyone has to be seated.

:- guest(X),
   not is_seated(X).

is_seated(X) :- guest(X), 
                chair(C), 
                table(T),
                sits_at(X,C,T).

% A guest can sit at most at one table.

:- guest(X),
   chair(C1), chair(C2),
   table(T1), table(T2), neq(T1,T2), 
   sits_at(X,C1,T1), sits_at(X,C2,T2).

% Sit at most one guest per chair.

:- guest(X), guest(Y), neq(X,Y),
   chair(C), table(T),
   sits_at(X,C,T), sits_at(Y,C,T).

%-------------------
% Display formatting 
%-------------------

hide.
show sits_at(X,Y,Z).

**********************************************
*** PROGRAM 19, for smodels
*** By Semra Dogandag (semra@ceng.metu.edu.tr)
**********************************************

const tables=4.
const chairs=3.
const guests= tables *chairs.

guest(1..guests).

table(1..tables).  

hide.
show sits(X,Y).

% For any choice of T and C there can be exactly one guest. 
 chairs{sits(G, T): guest(G)} chairs:-  table(T).

% If two people dislike each other they should sit at different tables

 :- sits(I,T), sits(J,T), dislike(I,J),
	guest(I), guest(J), table(T).

% If two  people like each other they should sit at the same table

 :- sits(I,T1), sits(J,T2), like(I,J),
         guest(I), guest(J), table(T1), table(T2), neq(T1,T2).

% A guest can not sit at two different places

 :- sits(I,T), sits(I,T1), neq(T,T1), guest(I), table(T), table(T1).
 
like(1,2).
like(4,5).
like(5,6).
dislike(3,2).
dislike(12,2).
dislike(7,8).
dislike(8,2).

*******************************************
*** PROGRAM 20, for smodels
*** By Richard Watson (rwatson@.cs.ttu.edu)
*******************************************

% assume the following predicates
% 1) person(I) states that I is the number of a person (1 <= I <= NM)
% 2) table(T) states that T is the number of a table (1 <=T <= N).
% 3) like(I,J) meaning I and J must be at same table.
% 4) dislike(I,J) meaning I and J must be at different tables.
% 5) assigned(I,T) meaning I is assigned to table T (1 <= T <= N)

% Assume given facts about predicates 1-4.  If stable model exits, then 
% values for predicate 5 give seating arrangement.  If no stable model
% exists then it is impossible. 

const n=3.
const m=3.

table(1..n).
person(1..n*m).

like(1,2).
like(2,3).
 
dislike(4,5).

% A) Use choice operator to assign M people to each table.
m{assigned(I,T):person(I)}m :- table(T).

% B) constraint that I and J must be at same table if a(I,J) is true.
:- person(I), person(J), table(T), like(I,J), assigned(I,T), not assigned(J,T).

% C) constraint that I and J must be at different tables if b(I,J) is true.
:- person(I), person(J), table(T), dislike(I,J), assigned(I,T), assigned(J,T).

% D) constraint that a person must be assigned to at most 1 table.
:- person(I), table(T1), table(T2), assigned(I,T1), assigned(I,T2),
   not eq(T1,T2).

% Note: the above constraint (D)  together with the choice rule (A) assures
% that each person is assigned to at least 1 table as well.

********************************************
*** PROGRAM 21, for smodels
*** By Yulia Babovich (yuliya@cs.utexas.edu)
********************************************

% data

% #tables
const m=3.
% #chairs
const n=4.
% #guests
const p=12.

guest(1..p).
table(1..m).

like(1,2).
like(2,3).
like(3,4).
dislike(1,5).
dislike(1,6).

%solution

%for each table there has to be exactly n guests
n{tableGuest(X,G):guest(G)}n:-table(X).

%for each guest there will be exactly one table
1{tableGuest(X,G):table(X)}1:-guest(G).

:- tableGuest(X,G1), tableGuest(Y,G), like(G,G1), X!=Y, 
   table(X), table(Y), guest(G), guest(G1) .
:- tableGuest(X,G1), tableGuest(X,G), dislike(G,G1),
   table(X),  guest(G), guest(G1). 

hide.
show tableGuest(X,G).

******************************************
*** PROGRAM 23, for smodels
*** By Guru Huchachar (guru@cs.utexas.edu)
******************************************

% GENERATE
const n = 2.
const m = 3.

1 { atTable(X,T): table(T) } 1 :- person(X).
m { atTable(X,T): person(X) } m :- table(T).

% TEST
:- person(X), person(Y), table(T1), table(T2), like(X,Y),
   atTable(X,T1), atTable(Y,T2), T1!=T2.
:- person(X), person(Y), table(T), dislike(X,Y), atTable(X,T), atTable(Y,T).

% DISPLAY
hide.
show atTable(X,T).

table(1..n).
person(1..m*n).

like(2,3).
dislike(2,6).
dislike(3,1).