/*
  Grouping ids

  What is the closed form of grouping ids for 1..N
  E.g. 
    [1,2] -> 1
    [3,4] -> 2
    [5,6] -> 3
    ...


  AllGood:
  [program = A - A div 2, res = 10, count = 74]
  [program = A mod (A * 6) - A div 2, res = 10, count = 34]
  [program = A mod A mod 16 mod (5 * A) * A + A - A div 2, res = 10, count = 12]


  With / and ceiling:
  AllGood:
  [program = ceiling(A / 2), res = 10, count = 89]

  In general:

  For grouping of M the best form is ->   ceiling(A / M)

*/

data(group_ids_2,Data,Vars,Unknown,Ops,Constants,MaxSize,Params) :-
  
  Data = [ [[1],1],
           [[2],1],
           [[3],2],
           [[4],2],
           [[5],3],
           [[6],3],
           [[7],4],
           [[8],4],
           [[9],5],
           [[10],5],
           [[11],6],
           [[12],6],
           [[13],7],
           [[14],7],
           [[15],8],
           [[16],8],
           [[17],9],
           [[18],9],
           [[19],10]
           % [[20],10]]
  ],
  Unknown = [20],    
  Vars = ['A'],
  % Ops = [+,-,*,mod,div],
  Ops = [+,-,*,/,ceiling,floor],
  Constants = [1,2,10,20],
  MaxSize = 1,
  Params = new_map([init_size=1000,
                    num_gens=100
                   ]).



/*
  What about groups of 3?


  AllGood:
  [program = ceiling(A / 3), res = 7, count = 59]


  AllGood:
  [program = (A + 2) div 3, res = 7, count = 1]

  AllGood:
  [program = (2 + A) div 3, res = 7, count = 35]

  AllGood:
  [program = (A + 2) div 3, res = 7, count = 949]
  [program = (2 + A) div 3, res = 7, count = 796]
  [program = (2 + A) div (7 mod 4), res = 7, count = 521]
  [program = (A + 2) div (7 mod 4), res = 7, count = 482]
  [program = (2 + A) div (3 mod 6), res = 7, count = 58]

  resultMap = [7 = 5]

*/

/*
data(group_ids_3,Data,Vars,Unknown,Ops,Constants,MaxSize,Params) :-
  
  Data = [ [[1],1],
           [[2],1],
           [[3],1],
           [[4],2],
           [[5],2],
           [[6],2],
           [[7],3],
           [[8],3],
           [[9],3],
           [[10],4],
           [[11],4],
           [[12],4],
           [[13],5],
           [[14],5],
           [[15],5],
           [[16],6],
           [[17],6],
           [[18],6]
           % [[20],10]]
  ],
  Unknown = [19],    
  Vars = ['A'],
  Ops = [+,-,*,mod,div],
  % Ops = [+,-,*,/,ceiling,floor],
  Constants = 1..10,
  MaxSize = 1,
  Params = new_map([init_size=1000,
                    num_gens=1000
                   ]).

*/


/*

  Grouping of 4:

  AllGood:
  [program = (A + 3) div 4, res = 5, count = 958]
  [program = (3 + A) div 4, res = 5, count = 941]
  [program = (3 + A) div (9 div 2), res = 5, count = 897]
  [program = (A + 3) div (9 div 2), res = 5, count = 836]
  [program = (3 + A) div (10 mod 6), res = 5, count = 813]
  [program = (A + 3) div (6 - 2), res = 5, count = 777]
  [program = (3 + A) div (4 mod 5), res = 5, count = 714]
  [program = (3 + A) div (6 - 2), res = 5, count = 712]
  [program = (3 + A) div (4 mod 9), res = 5, count = 658]
  [program = (A + 3) div (10 mod 6), res = 5, count = 154]
  [program = (3 + A) div (7 - 3), res = 5, count = 77]
  [program = (A + 3) div (4 mod 5), res = 5, count = 66]
  [program = (A + 3) div (7 - 3), res = 5, count = 26]
  [program = (A + 3) div (4 mod 9), res = 5, count = 21]

  resultMap = [5 = 14]


  AllGood:
  [program = ceiling(A / 4), res = 5, count = 854]

*/

/*
data(group_ids_4,Data,Vars,Unknown,Ops,Constants,MaxSize,Params) :-
  
  Data = [ [[1],1],
           [[2],1],
           [[3],1],
           [[4],1],
           [[5],2],
           [[6],2],
           [[7],2],
           [[8],2],
           [[9],3],
           [[10],3],
           [[11],3],
           [[12],3],
           [[13],4],
           [[14],4],
           [[15],4],
           [[16],4],
           [[17],5]
  ],
  Unknown = [18],    
  Vars = ['A'],
  % Ops = [+,-,*,mod,div],
  Ops = [+,-,*,/,ceiling,floor],
  Constants = 1..10,
  MaxSize = 1,
  Params = new_map([init_size=1000,
                    num_gens=1000
                   ]).

*/