SynProS - Synthesis of Programmatic Strategies

Competition Format and Resources Available

The synthesizers submitted to this track will be evaluated on the same maps used in the other tracks of the competition. Each participant is allowed to submit a synthesizer that will be used by the organizers to generate one programmatic strategy for each map. The programmatic strategy must be able to play on any starting location of the maps. Each synthesizer will run for a limited amount of time for each map (see details in the table below).

The synthesizer must produce a programmatic strategy within the time limit. If the synthesizer fails to produce a strategy within the time limit or if it exhausts the memory allowed for synthesis, the entry will be assigned a penalty score equivalent to a number of defeats equal to the number of participants in the competition.

In this first installment of the competition the participants aren't allowed to change the DSL provided by the organizers. Participants using a modified DSL will be disqualified from the competition.

The same participant/group can submit multiple synthesizers to the competition. We encourage submissions of multiple synthesizers only when the synthesizers implement different ideas. Synthesizers submited by the same participant/group that aren't substantially different (e.g., differ on a set of parameters) will be disqualified by the organizers.

We will follow the same set of rules used in the other tracks of the competition. The participants should read all rules before submitting their entries to the competition.

The competition will be run on machines running Linux. Each synthesizer will have access to the following resources (the synthesizer will be run by the competition organizers):

• Time limit for each map: 24 hours.
• CPU usage: Maximum of 8 CPU's will be available to each synthesizer.
• Memory: Maximum of 16 GB's of memory.
• Disk Space: Maximum of 1 GB in disk.

How to Submit Your Synthesizer

The participants can either submit your entire project or just the code of your synthesizer. The participants should follow the steps below to submit their synthesizer.

• Step 1. Check if your synthesizer implements a serialized file (using the class SerializableController to save your programmatic strategy) as output. This file needs to be compatible with the original framework, which means that you can't include new commands or changes the DSL.
• Step 2. Upload your project to a public GitHub repository. If the project uploaded to GitHub contains all we need to run the synthesizer, then jump to step 4.
• Step 3. If you need to add libraries, folders, or other resources, compact all we need to run your synthesizer in a zip file.
• Step 4. Send the link to your GitHub repository and the zip file with additional resources to rubens.moraes@ufv.br. Please include in the email any additional instruction needed to run your synthesizer.

The artifacts sent to the competition will be tested before the competition starts and the participants will be contacted if any issues arise.

Score and Classification

The score of a synthesizer on a map is computed as follows:

Map Score = Winning Rate - (Winning Rate x 0.4 x Non-Interpretability Penalty)

We explain below how winning rate and non-interpretability penalty are computed. The final score of a synthesizer is the average of the scores on all maps. The synthesizer with highest final score will be the winner of this track.

The table below shows an example of how the final score of a synthesizer is computed if two maps are used.

Map	Winning Rate	Interpretability Penalty	Map Score
map 1	90.8	0.0	90.8
map 2	82.4	0.94	51.42
Total Score			71.11

The winning rate is defined by the score in a round-robin tournament among all the entries. See the MicroRTS Competition rules page for more information.

Interpretability of the synthesized strategies is key in this track. We approximate the interpretability of a strategy with the size of the program encoding the strategy. Smaller programs will be deemed as more interpretable. The non-interpretability penalty used in the map score formula is computed based on the number of instructions used in the strategiy. If a strategy uses 10 or fewer instructions, then its non-interpretability penalty is 0.0. The penalty is increased by 0.01 for each instruction above 10, to a maximum of non-interpretability penalty of 1.0, as summarized in the table below.

Number of Instructions	Non-Interpretability Penalty
less than or equal to 10	0.0
Each instruction above 10 increases the penalty in	0.01
100 or more	1.0

Let's consider the following example of a programmatic strategy for playing MicroRTS.

                                    for(u):
                                        if not HaveUnitsStrongest(Heavy,u):
                                            harvest(1,u)
                                    for(u): 
                                        if not HaveQtdEnemiesbyType(Heavy,9):
                                            attack(Worker,closest,u)
                                        if not HaveUnitsStrongest(Ranged,u):
                                            moveaway(Worker,u)
                                            train(Worker,4,Right)
                                

The program uses 12 instructions: 2 for-loops, 3 ifs, 3 Boolean expressions, 4 commands that return actions. The non-interpretability score of this strategy is 0.02.