/*
  http://forums.anandtech.com/showthread.php?p=29473624
  """
  Not sure if this is the correct section but I'll give it a shot. I'm 
  looking for numeric sequence prediction program. Say if I input a 
  set of   or #s say three times and see if it can find a pattern on 
  the next #. 
  say if I input

  first input 3 0 0 4 2 9 6
  second input 4 1 1 5 3 0 7
  third input 5 2 2 6 4 1 8

  Now if you're looking at the above   you would notice that I add one 
  to each   every round. I need a program that can find patterns like that 
  and predict the next #. Basically a program that can think and uses a 
  gizillion methods to see if there is a trend/pattern and try to come 
  up with the next set of #s. Is there such program and can I acquire 
  it for use.

  Or a second example would be something like this:
  First set will be a+b+c = D
  second set (D+a)+(D+b)+(D+c) = D
  third set will be the same as second set because it just repeats the 
  same process so a,b,c would be what I would inpute and D would 
  total +a,b,c and so on.
  
  Is there such program? Also if i'm not clear on anything please let me know. 
  """

  I stumbled upon an unknown / unexpected feature of the program:
  If the the Unknown is just one number - [1] - (instead of the required 2 numbers, e.g. [1,2]),
  it finds these solutions:
    code = ((A + 2) mod 10) = [[[3,4],5],[[0,1],2],[[4,5],6],[[2,3],4],[[9,0],1],[[6,7],8]] = [[1] = 3]
    code = ((2 + A) mod 10) = [[[3,4],5],[[0,1],2],[[4,5],6],[[2,3],4],[[9,0],1],[[6,7],8]] = [[1] = 3]
    code = ((A - 8) mod 10) = [[[3,4],5],[[0,1],2],[[4,5],6],[[2,3],4],[[9,0],1],[[6,7],8]] = [[1] = 3]

  Setting to just one number means that the program should just consider the first variable, here "A".



  If stating the Unknown proper form, [1,2] it finds a lot more solutions:
  code = (B + 1) = [[[3,4],5],[[0,1],2],[[4,5],6],[[2,3],4],[[9,0],1],[[6,7],8],[[5,6],7]] = [[1,2] = 3]
  code = (B + (2 - 1)) = [[[3,4],5],[[0,1],2],[[4,5],6],[[2,3],4],[[9,0],1],[[6,7],8]] = [[1,2] = 3]
  code = ((2 - 1) + B) = [[[3,4],5],[[0,1],2],[[4,5],6],[[2,3],4],[[9,0],1],[[6,7],8]] = [[1,2] = 3]
  code = (B + (1 * 1)) = [[[3,4],5],[[0,1],2],[[4,5],6],[[2,3],4],[[9,0],1],[[6,7],8]] = [[1,2] = 3]
  code = ((1 * 1) + B) = [[[3,4],5],[[0,1],2],[[4,5],6],[[2,3],4],[[9,0],1],[[6,7],8]] = [[1,2] = 3]
  code = (B + (1 / 1)) = [[[3,4],5],[[0,1],2],[[4,5],6],[[2,3],4],[[9,0],1],[[6,7],8]] = [[1,2] = 3.0]
  code = ((1 / 1) + B) = [[[3,4],5],[[0,1],2],[[4,5],6],[[2,3],4],[[9,0],1],[[6,7],8]] = [[1,2] = 3.0]
  code = (B + (1 mod 2)) = [[[3,4],5],[[0,1],2],[[4,5],6],[[2,3],4],[[9,0],1],[[6,7],8]] = [[1,2] = 3]
  code = ((1 mod 2) + B) = [[[3,4],5],[[0,1],2],[[4,5],6],[[2,3],4],[[9,0],1],[[6,7],8]] = [[1,2] = 3]
  code = (B + (1 mod 3)) = [[[3,4],5],[[0,1],2],[[4,5],6],[[2,3],4],[[9,0],1],[[6,7],8]] = [[1,2] = 3]
  ...

  But we want to ensure that both A and B are used, and activate the 
    get_global_map().put("use_all_variables",true),
  which is a harder problem. Some solutions found:

  code = (A + ((B + 1) - A)) = [[[3,4],5],[[0,1],2],[[4,5],6],[[2,3],4],[[9,0],1],[[6,7],8]] = [[1,2] = 3]
  code = (B + (1 mod (A + 10))) = [[[3,4],5],[[0,1],2],[[4,5],6],[[2,3],4],[[9,0],1],[[6,7],8]] = [[1,2] = 3]
  code = (1 + (B mod (A + 10))) = [[[3,4],5],[[0,1],2],[[4,5],6],[[2,3],4],[[9,0],1],[[6,7],8]] = [[1,2] = 3]

   Cf problem1.conf

*/
data(problem1,Data,Vars,Unknown,Ops,Constants,MaxC) :-
  Data = [
    [[3,4],5],
    [[0,1],2],
    [[4,5],6],
    [[2,3],4],
    [[9,0],1],
    [[6,7],8]
    ],
  Unknown = [1], % See comment above
  % Unknown = [1,2],
  Vars = ["A","B"],
  % get_global_map().put("debug",true),
  % get_global_map().put("use_all_variables",true),
  Ops = new_map([infix=["+","-","*","/","mod"]]),
  Constants = 1..10,          
  MaxC = 6.