Skip to content


Switch branches/tags

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?

Latest commit


Git stats


Failed to load latest commit information.
Latest commit message
Commit time

RamseyScript is a high-level scripting language for recursively
generating long pattern-free objects. It is case-insensitive, so
it ignores capitalization, and also does not distinguish between
'-' and '_'.

Essentially, every script does the same thing:

  1. Start with some seed object (e.g. the empty sequence)

  2a. Attempt to extend the object.

  2b. Check that the object is still pattern-free (as defined by
      a set of filters given by the script). If it's still good,
      repeat (2a) on the extended object.

  2c. Otherwise, try a different extension and repeat (2b). If
      there are no more possible extensions, quit.

  3. Output the longest pattern-free extension found.

As a concrete example, consider the calculation of the van der Waerden
number w(3; 2), the longest 3-AP-free 2-coloring of the interval [1, n].
The script would be

  set n-colors 2
  filter no-3-aps
  search colorings

The effect of the final line is to:

  1. Start with the empty coloring.

  2a. Attempt to add the next number, colored red. (On the first
      iteration, the "next number" is 1.)

  2b. If the coloring is monochromatic-3-AP-free, repeat (2a).

  2c. Otherwise, try making the next number blue and repeat (2b).

  3. Output the longest monochromatic-3-AP-free extension found (which
     will be some 2-coloring of [1, 8]). Conclude that every 2-coloring
     of [1, 9] has a monochromatic 3-AP, and therefore that w(2;3) is 9.

Advanced features are:

  1. Change the final output. This is done by the "target" command, as

       target any-length

     This will output every object found; the default target, max-length,
     only outputs the longest object.

     To remove all targets, use "target clear". To see a list of all
     available targets, just type "target".

  2. Output auxiliary data. This is done by the "dump" command, as

       dump iters-per-length

     This will also output a list which counts the number of objects
     found at each recursion depth, to allow for data analysis/plotting.

  3. Start with a non-trivial seed. For example, typing

       search sequences [1,3,7,9]

     would search through the space of sequences beginning in 1,3,7,9.
     The special seed "random" will create a random seed:

       set random-length 5
       search colorings random

  4. Run in quiet mode. By default RamseyScript outputs a lot of human
     readable information which is inappropriate for automated scripts.
     To prevent any output, add the command "quiet" to a script before
     running it. To see the status of your targets, run "state".

  5. Split up a problem for parallel processing. RamseyScript uses only
     one thread, one processor, which is inefficient if parallelizable
     hardware is available. The special target "fork" will output lines
     of the form "search [space] [seed]" suitable for creating extra
     scripts (which can then be run in separate RamseyScript instances).
     It is used as such:

       set max-depth 11
       set fork-depth 10
       target clear    # remove the default max-depth target
       target fork
       filter no-double-3-aps
       search colorings

   6. Manually iterate. If you have a split-up problem as in the previous
      step, you will wind up with candidate solutions from every instance
      of RamseyScript. To combine these (e.g., to find the -real- maximum
      length object), use the command "process", like so:

        process [[1, 2, 4, 7, 8] [3, 5, 6, 9, 10]]
        process [[1, 3, 4, 7, 9, 10, 12] [2, 5, 6, 8, 11, 13]]
        process [[1, 3, 6, 8, 9, 11, 14, 16] [2, 4, 5, 7, 10, 12, 13, 15]]

      (If you do not use "quiet" and "state" as explained in item (4) above,
       you will get a bunch of extraneous output.)



  set <variable> <value>

Sets a variable. Not all variables are effective for each search space.
``variable'' should be one of:

      alphabet: The alphabet to use when searching words. Specified in the
                format [c1 c2 c3 ... cn].
                Default value: (none)

     ap_length: The length of AP's filtered out by the no-double-n-ap filter
                Default value: (none)

 base_sequence: A sequence that will be used instead of 1, 2, 3, ... when
                creating colorings. If unset, the positive integers will be

     dump-file: The file to output dump output (see 'dump'), or "-" to use
                Default value: -

       gap-set: The set of allowable gap sizes when searching sequences or
                colorings. For sequences, the value must be a 1D sequence
                of the form [x y z] containing the allowable gap sizes.

                For colorings, if the gap-set is a sequence, this sequence
                defines the allowable gap sizes for each color. Alternately,
                if the gap-set is a coloring (i.e., a sequence of sequences)
                then each color of the gap-set defines the allowable gap
                sizes for the respective colors in the search space.
                Default value: (none)

     max-depth: The maximum depth to search the space.
                Default value: (none)

  max-run-time: The maximum time (in seconds) to search before stopping.
                Default value: (none)

max-iterations: The number of iterations to run before stopping.
                Default value: (none)

      n-colors: The number of colors to use when searching colorings.
                Default value: 3

    prune-tree: Whether or not the search tree should be pruned; i.e., if some
                element is filtered out, should new elements be built from it?

                For example, if a sequence S contains a double-3-AP, then every
                sequence starting with S will too, so we would set prune-tree
                to nonzero.

                But if a permutation P contains a double-3-AP, it still might
                be that permutations built from P could be double-3-AP-free,
                so we would set prune-tree to 0.
                Default value: 1

 random-length: If the seed is set to RANDOM on a supported space, this
                sets the length of the generated seed.
                Default value: 10

   stall-after: Like max-iterations, but resets its counter every time a target
                (e.g., new object of maximum length) is reached.
                Default value: (none)

  get <variable>

Prints the value of <variable>.

  unset <variable>

Unsets a previously-set variable. If the variable does not exist, does nothing.


  filter <filter>

Adds a filter on the space to be searched. Multiple filters may be
used. To delete filters, use "filter clear" and re-add the ones you
want kept. ``filter'' should be one of:

             no-3-aps: Only recurse on objects with no 3-AP's

             no-n-aps: Only recurse on objects with no n-AP's, with
                       n set by "set ap-length"

      no-double-3-aps: Only recurse on objects with no double-3-AP's

      no-double-n-aps: Only recurse on objects with no double-AP's of
                       length n, with n set by "set ap-length".

       no-rainbow-aps: Only recurse on colorings with no rainbow-AP's
                       (i.e., arithmetic progressions with one entry
                       of each color). Note that this filter must be
                       used with a different filter, since by itself,
                       it simply tells the program to color every
                       number the same.

   no-odd-lattice-aps: No arithmetic progressions on lattices, with
                       length equal to the number of columns on the
                       lattice. (So named because if the lattice has
                       4 columns, all 4-AP's with odd gap size will
                       appear as straight lines through grid points.)

  no-additive-squares: Only recurse on words with no additive squares

no-pythagorean-triples: Only recurse on objects with no solutions to
                        X^2 + Y^2 = Z^2.

   no-schur-solutions: Only recurse on objects with no solutions to
                       X + Y = Z.

  filter clear

Removes all set filters.

Search Spaces

  search <space> [seed]

Selects a search space and recursively explores it, looking for longer
and longer elements which satisfy the given filter. There is no default
value. If you do not specify a 'search' line, the program will do
nothing. ``space'' should be one of:

   colorings: The space of r-colorings of integers, for some given r.
              For colorings, the seed may be RANDOM, in which case a
              seed of length random-length is generated.
              Default seed: [[1] [] []]

    lattices: The space of r-colorings of integers, organized as a
              grid of m columns (with r and m given). This allows a
              geometric interpretation of some Ramsey-type problems.
              Default seed: []

  partitions: synonym of 'colorings'

permutations: The space of permutations of [1,n]. You cannot change
              the seed for this space.
              Default seed: [1]

   sequences: The space of strictly increasing sequences
              Default seed: [1]

       words: The space of words on some given alphabet
              Default seed: []


  target <target>

Chooses a goal to achieve when searching through Ramsey objects. Whenever
a target is reached (e.g., a new object of maximal length is found), the
current object is output. Multiple targets may be specified.

By default, the "max-length" target is set. ``target'' should be one of:

  max-length: Output the current object every time one is found one maximal
              length is found.

  any-length: Output every object found while recursing.

  target clear

Removes all set targets.

Additional Output

  dump <iterations-per-length>

Output auxiliary data about the search space or program operation.

iterations-per-length: dump the number of iterations spent at each
                       search-space depth

  dump clear

Removes all data dumps.

Manual Recursion

It is possible to operate RamseyScript manually (i.e., when the Ramsey
objects are obtained externally, and no recursion needs to be done, just
filtering). This is done using the following three commands:


Resets all output dumps and targets.

  process <space> <object> 

Runs filters, outputs and targets on ``object'', which is a Ramsey object
of type ``space''. ``space'' is any valid search space (see the ``search''


Output all targets and run all output dumps.


## Look for 2-colorings of [1, N] with no double-3-ap's
## This will find that there is no such coloring of [1, 17],
## though there is one of [1, 16].

set n-colors 2
filter no-double-3-aps
search colorings

# (end file)

## Explore the space of 3-colorings of [1, N] with no double-3-ap's.
## One does exist of [1, 390], but this is all that is known so far.

set n-colors 3
filter no-double-3-aps
set max-iterations 10000000

search colorings RANDOM
search colorings RANDOM
search colorings RANDOM
search colorings RANDOM
search colorings RANDOM

# (end file)

## Explore the space of permutations with no 3-AP's. Output the iterations
## at each depth (i.e., the number of valid permutations of each length)
## to output.dump.

# The resultant output will match the values computed by G.J. Simmons.
# See American Mathematical Monthly 82 (1975) pp. 76-77.

filter no-3-aps

set dump-depth 25
set dump-file output.dump
dump iterations-per-length

set max-depth 20
search permutations

# (end file)

## Check some 3-colorings for double-3-aps

target clear
target any-length

filter no-double-3-aps
process colorings [[2, 5, 6, 8, 9] [1, 3, 7] [4, 10]]
process colorings [[2, 5, 6, 8, 9] [1, 3, 7, 10] [4]]
process colorings [[2, 5, 6] [1, 3, 7, 8, 9, 10] [4]]


Explore mathematical spaces related to Ramsey-type problems.







No packages published