 ```////////////////////////////////////////////////////////////////////////////////////////
//
// Dean Clark's Problem (Clock Triplets Problem)
//
// The problem was originally posed by Dean Clark and then presented
// to a larger audience by Martin Gardner.
//
// The problem was discussed in Dr. Dobbs's Journal, May 2004 in an article
// by Timothy Rolfe. According to the article, in his August 1986 column for
// Isaac Asimov's Science Fiction Magazine, Martin Gardner presented this problem:
//
//     Now for a curious little combinatorial puzzle involving the twelve
//     numbers on the face of a clock. Can you rearrange the numbers (keeping
//     them in a circle) so no triplet of adjacent numbers has a sum higher
//     than 21? This is the smallest value that the highest sum of a triplet
//     can have.
//
// Timothy Rolfe solves the problem using a rather complex algorithm and also
// presents a generic algorithm for numbers other than 12 (clock numbers) and
// 21 (highest sums of triplets). The main emphasis of the algorithm was put
// on the computational speed. The article stressed the fact that a simple
// backtracking algorithm would be simply too slow due to the number of permutations.
//
// In this F1 sample, we achieve reasonable computational speeds while the code
// is quite simple. The code, in the spirit of logical programming, does not require
// us to specify any particular algorithm.
//
// Similar to Timothy Rolfe, we also use two optimizations to cut down on identical
// solutions:
//
// 1.  We nail down one number (number 12 to position 0). This reduces the
//     number of solutions by 12.
// 2.  We remove "mirror" solutions by postulating that the number right of 12 is
//     greater then the number left of 12. This reduces the number of solutions
//     by one half.
//
// These optimizations can be removed by simply commenting out the corresponding line.
//
// To solve the original problem, run the query
//
//         all Cloque(x)
//
// The above query will generate all 261 solutions in about 12 seconds using a modest
// AMD Athlon 1600+.
//
// The code for a general solution of the problem is in the predicate CloqueMN.
//
// For example, using the query:
//
//        all CloqueMN(x,12,21)
//
// solves the original problem,
//
//        all CloqueMN(x,13,23)
//
// will generate all solutions for a clock with 13 numbers with the highest sum of any
// triplet being 23.
//
////////////////////////////////////////////////////////////////////////////////////////

pred Cloque(x::[0..11]->>L[1..12]) iff   // 6264 solutions with no optimizations
x(0) = 12 &     // Optimization 1: nail down number 12 (522 solutions)
x(1) > x(11) &  // Optimization 2: remove mirror solutions (261 solutions)
x(0)  + x(1)  + x(2)  <= 21 &
x(1)  + x(2)  + x(3)  <= 21 &
x(2)  + x(3)  + x(4)  <= 21 &
x(3)  + x(4)  + x(5)  <= 21 &
x(4)  + x(5)  + x(6)  <= 21 &
x(5)  + x(6)  + x(7)  <= 21 &
x(6)  + x(7)  + x(8)  <= 21 &
x(7)  + x(8)  + x(9)  <= 21 &
x(8)  + x(9)  + x(10) <= 21 &
x(9)  + x(10) + x(11) <= 21 &
x(10) + x(11) + x(0)  <= 21 &
x(11) + x(0)  + x(1)  <= 21

// This is the code for the general case of an array of "m" elements
// with the maximum value of the sum of any three consequitive elements being "n"

pred CloqueMN(x::[0..]->>L[1..], m:<I,n:<I) iff
Len(x,m) &          // Set the length of the array to be "m"
x(0) = m &          // Optimization 1: nail down number "m" (reduce solutions to solutions/m)
x(1) > x(m-1) &     // Optimization 2: remove mirror solutions (reduce solutions by one half)
CloqueMNEx(x,m,n,0) // Set the constraints for "m" and "n"

local pred CloqueMNEx(x::[0..]->>L[1..], m:<I,n:<I,i:<I) iff
if i < m then
j = (i+1) mod m & k = (i+2) mod m &
x(i) <= m & x(j) <= m & x(k) <= m &
x(i) + x(j) + x(k) <= n &
CloqueMNEx(x,m,n,i+1)
end

```