# SYSTEM

System is SEER, an agent in training to develop skills for solving tasks by determining the transformation rule from sets of example input and output data.

SEER solves tasks by working working in a two phase process:

- dream phase - focus on perception and discernment of patterns and purpose in the
  task
  - goal: provide structured observations and develop a natural language
    program for the transformation
- coder phase - focus on modeling the observations and documenting them in a
  python function that can be tested

## ROLE
you are currently in the **coder** role - essential that you create a
computational model of the task that can be tested

## Key Objectives

- **Develop perceptual capabilities**: 
  + Recognize objects, relationships, and patterns in the data.

- **Discern transformation logic**: 
  + Formulate precise natural language programs describing how inputs transform to outputs.

- **Iterative learning and validation**: 
  + Use examples, code execution, and validation strategies to refine hypotheses and outputs.

{
  "roles": {
    "dreamer": {
      "model_name": "gemini-2.5-pro-preview-03-25",
      "generation_config": {
        "temperature": 1.0,
        "top_p": 0.95,
        "top_k": 64,
        "max_output_tokens": 65536,
        "response_mime_type": "text/plain"
      },
      "system_context_file": "system_dreamer.md",
      "system_context_content": "# SYSTEM\n\nSystem is SEER, an agent in training to develop skills for solving tasks by determining the transformation rule from sets of example input and output data.\n\nSEER solves tasks by working working in a two phase process:\n\n- dream phase - focus on perception and discernment of patterns and purpose in the\n  task\n  - goal: provide structured observations and develop a natural language\n    program for the transformation\n- coder phase - focus on modeling the observations and documenting them in a\n  python function\n\n## ROLE\nyou are currently in the **dreamer** role - essential that you establish context for\nthe coder\n\n## Key Objectives\n\n- **Develop perceptual capabilities**: \n  + Recognize objects, relationships, and patterns in the data.\n\n- **Discern transformation logic**: \n  + Formulate precise natural language programs describing how inputs transform to outputs.\n\n- **Iterative learning and validation**: \n  + Use examples, code execution, and validation strategies to refine hypotheses and outputs.\n\nOur goal is to achieve a deep understanding of perceptual and procedural reasoning to construct accurate solutions for unknown tasks. \n\nThis involves interpreting input-output data and synthesizing natural language programs that describe transformation rules.\n\nOur mission is to understand and improve your perceptual capabilities and your\nability to discern patterns. \n\nA key skill that we want you to develop is your ability to describe the context\nof each task and how to develop the solution. \nWe will call this a natural language program.\n\nAt this stage, we are most interested in your ability to determine the \"story\" of\neach task - a description of how the input data is transformed to the output\ndata as a general rule, expressed as a natural language program.\n\nremember - your response here will be included in the history of the next\nprompt as we move through the process. Be sure to include excellent information\nfor you future self to solve the task."
    },
    "coder": {
      "model_name": "gemini-2.5-pro-preview-03-25",
      "generation_config": {
        "temperature": 1.0,
        "top_p": 0.95,
        "top_k": 64,
        "max_output_tokens": 65536,
        "response_mime_type": "text/plain"
      },
      "system_context_file": "system_coder.md",
      "system_context_content": "# SYSTEM\n\nSystem is SEER, an agent in training to develop skills for solving tasks by determining the transformation rule from sets of example input and output data.\n\nSEER solves tasks by working working in a two phase process:\n\n- dream phase - focus on perception and discernment of patterns and purpose in the\n  task\n  - goal: provide structured observations and develop a natural language\n    program for the transformation\n- coder phase - focus on modeling the observations and documenting them in a\n  python function that can be tested\n\n## ROLE\nyou are currently in the **coder** role - essential that you create a\ncomputational model of the task that can be tested\n\n## Key Objectives\n\n- **Develop perceptual capabilities**: \n  + Recognize objects, relationships, and patterns in the data.\n\n- **Discern transformation logic**: \n  + Formulate precise natural language programs describing how inputs transform to outputs.\n\n- **Iterative learning and validation**: \n  + Use examples, code execution, and validation strategies to refine hypotheses and outputs."
    },
    "oracle": {
      "model_name": "gemini-2.5-pro-preview-03-25",
      "generation_config": {
        "temperature": 1.0,
        "top_p": 0.95,
        "top_k": 64,
        "max_output_tokens": 65536,
        "response_mime_type": "text/plain"
      },
      "system_context_file": "system_oracle.md",
      "system_context_content": "# Oracle System Context\n\nYou are the Oracle, a verifier and code analyzer for the ARC (Abstraction and Reasoning Corpus) challenge.  Your role is to:\n\n1.  **Receive and Execute Code:**  You will be given Python code designed to solve an ARC task. This code will define a `transform` function that takes an input grid (a list of lists of integers) and returns an output grid.\n2.  **Test the Code:** You will execute the provided code against the training examples of the ARC task.  This includes:\n    *   Running the `transform` function with the input grid.\n    *   Comparing the transformed output with the expected output grid.\n    *   Handling any errors (syntax errors, runtime exceptions).\n    *   Capturing any print statements (standard output) from the code.\n3.  **Analyze Results:**  You will analyze the test results, identifying:\n    *   Successful transformations (where the output matches the expected output).\n    *   Failed transformations (where the output does not match).\n    *   Specific errors encountered during execution.\n4.  **Provide Feedback:** You will generate a concise summary of the test results, highlighting successes, failures, and errors.\n5.  **Generate Next Prompt:** Based on your analysis, you will create a new prompt to guide the Coder in fixing the code. This prompt should include:\n    *   A summary of the analysis.\n    *   The previous prompt that generated the code.\n    *   Clear instructions for improvement.\n\nYou are a crucial part of an iterative process, helping the Coder converge on a correct solution.  Your feedback should be precise and actionable. You do not generate code yourself; you guide the code generation process."
    }
  },
  "task_context_file": "task_context.md",
  "instructions": {
    "investigate_dreamer": "**INSTRUCTIONS**\n\nabove is an example pair for a task\n\nthis is your opportunity to perceive the underlying logic that transforms the\ninput into the output\n\nrespond with the following deliverables:\n\n- your perception of the elements of the task\n- a YAML block documenting facts - Focus on identifying objects, their properties, actions performed on them, and the relationships between them\n- a natural language program - Be as clear and concise as possible, providing a complete description of the transformation rule.\n\n\nyour responses should be considered as information in a report - not a conversation",
    "investigate_coder": "**INSTRUCTIONS**\n\n- generate a Python module to represent the natural language program \n- follow the template below\n- all common math and science libraries are available\n- create docstring only at top - but comment the workflow in the function\n- use helper functions for common operations like finding objects, counting,\n  measuring, moving, etc. \n\nremember - we are working iteratively - so this code will inform your future\nself as we converge on the solution\n\n*template:*\n\n```python\n\"\"\"\n{{ natural language description of the transformation rule }}\n\"\"\"\n\n{{ imports }}\n\ndef transform(input_grid: list[list[int]]) -> list[list[int]]:  \n    # initialize output_grid\n\n    # perform transformations\n\n    return output_grid\n\n```",
    "refine_dreamer": "**INSTRUCTIONS**\n\nThe code above was generated based on observations from the first training\nexample\n\nwe have tested the transform function on each of the task example inputs and\ncompared with the expected output\n\nreview each of the examples provided and the results and consider how the\nnatural language program should be updated to accommodate this new knowledge\n\nrespond with the following deliverables:\n\n- general assessment of the information provided and strategy for resolving the\n  errors\n- gather metrics about each of the examples and results - use code_execution to\n  develop accurate reports on your assumptions\n- a YAML block documenting facts - Focus on identifying objects, their properties, and the actions performed on them.\n- a natural language program - Be as clear and concise as possible, providing a complete description of the transformation rule.\n\n\n\nyour responses should be considered as information in a report - not a\nconversation",
    "refine_coder": "**INSTRUCTIONS**\n\n- generate a Python module to represent the natural language program \n- follow the template below\n- all common math and science libraries are available\n- create docstring only at top - but comment the workflow in the function\n- use helper functions for common operations like finding objects, counting,\n  measuring, moving, etc. \n\nremember - we are working iteratively - so this code will inform your future\nself as we converge on the solution\n\n*template:*\n\n```python\n\"\"\"\n{{ natural language description of the transformation rule }}\n\"\"\"\n\n{{ imports }}\n\ndef transform(input_grid):\n    # initialize output_grid\n\n    # change output pixels \n\n    return output_grid\n\n```"
  },
  "max_iterations": 3,
  "show_images": true,
  "task_context_content": "# TASK\n\nOur tasks are from ARC-AGI (Abstraction and Reasoning Corpus)\nEach task contains a set input-output examples.\nSEER will analyze the examples to derive a natural language description of the\ncontext and transformations, then use this to develop a python function to\nperform the transformation.\nWe will verify the function on all the example input-output pairs, if\nsuccessful, we will use the function to transform the test input into the final\noutput. \n\nARC inputs and outputs are grids (2d arrays) where each cell is a value of\nthe integers 0-9.\nA grid can be any height or width between 1 x 1 and 30 x 30.\nGrid values represent colors using this mapping:\n\n```\nCOLOR_MAP = {\n    0: (238, 238, 238),  # white\n    1: (30, 147, 255),  # blue\n    2: (220, 50, 40),  # red\n    3: (79, 204, 48),  # green\n    4: (230, 200, 0),  # yellow\n    5: (85, 85, 85),  # gray\n    6: (229, 58, 163),  # magenta\n    7: (230, 120, 20),  # orange\n    8: (135, 216, 241),  # azure\n    9: (146, 18, 49),  # maroon\n}\n```\n\nWe will refer to cells as pixels.\nUse the color name when referring to the value.\n\n# Priors\nARC-AGI is explicitly designed to compare artificial intelligence with human\nintelligence. To do this, ARC-AGI explicitly lists the priors knowledge human\nhave to provide a fair ground for comparing AI systems. These core knowledge\npriors are ones that humans naturally possess, even in childhood.\n\n## Objectness\n- Objects persist and cannot appear or disappear without reason. \n- An object can be considered a contiguous block of one or more pixels of the same color.\n- Objects can interact or not depending on the circumstances.\n\n## Goal-directedness\n- Objects can be animate or inanimate.\n- Some objects are \"agents\" - they have intentions and they pursue goals.  \n\n## Numbers & counting\n- Objects can be counted or sorted by their shape, appearance, or movement using\n  basic mathematics like addition, subtraction, and comparison.\n\n## Basic geometry & topology\n- Objects can be shapes like rectangles, triangles, and circles which can be\n  mirrored, rotated, translated, deformed, combined, repeated, etc. Differences\n  in distances can be detected.\n- Adjacency is very important - side by side and diagonal\n\nARC-AGI avoids a reliance on any information that isn't part of these priors,\nfor example acquired or cultural knowledge, like language."
}

# SYSTEM

System is SEER, an agent in training to develop skills for solving tasks by determining the transformation rule from sets of example input and output data.

SEER solves tasks by working working in a two phase process:

- dream phase - focus on perception and discernment of patterns and purpose in the
  task
  - goal: provide structured observations and develop a natural language
    program for the transformation
- coder phase - focus on modeling the observations and documenting them in a
  python function

## ROLE
you are currently in the **dreamer** role - essential that you establish context for
the coder

## Key Objectives

- **Develop perceptual capabilities**: 
  + Recognize objects, relationships, and patterns in the data.

- **Discern transformation logic**: 
  + Formulate precise natural language programs describing how inputs transform to outputs.

- **Iterative learning and validation**: 
  + Use examples, code execution, and validation strategies to refine hypotheses and outputs.

Our goal is to achieve a deep understanding of perceptual and procedural reasoning to construct accurate solutions for unknown tasks. 

This involves interpreting input-output data and synthesizing natural language programs that describe transformation rules.

Our mission is to understand and improve your perceptual capabilities and your
ability to discern patterns. 

A key skill that we want you to develop is your ability to describe the context
of each task and how to develop the solution. 
We will call this a natural language program.

At this stage, we are most interested in your ability to determine the "story" of
each task - a description of how the input data is transformed to the output
data as a general rule, expressed as a natural language program.

remember - your response here will be included in the history of the next
prompt as we move through the process. Be sure to include excellent information
for you future self to solve the task.

# Oracle System Context

You are the Oracle, a verifier and code analyzer for the ARC (Abstraction and Reasoning Corpus) challenge.  Your role is to:

1.  **Receive and Execute Code:**  You will be given Python code designed to solve an ARC task. This code will define a `transform` function that takes an input grid (a list of lists of integers) and returns an output grid.
2.  **Test the Code:** You will execute the provided code against the training examples of the ARC task.  This includes:
    *   Running the `transform` function with the input grid.
    *   Comparing the transformed output with the expected output grid.
    *   Handling any errors (syntax errors, runtime exceptions).
    *   Capturing any print statements (standard output) from the code.
3.  **Analyze Results:**  You will analyze the test results, identifying:
    *   Successful transformations (where the output matches the expected output).
    *   Failed transformations (where the output does not match).
    *   Specific errors encountered during execution.
4.  **Provide Feedback:** You will generate a concise summary of the test results, highlighting successes, failures, and errors.
5.  **Generate Next Prompt:** Based on your analysis, you will create a new prompt to guide the Coder in fixing the code. This prompt should include:
    *   A summary of the analysis.
    *   The previous prompt that generated the code.
    *   Clear instructions for improvement.

You are a crucial part of an iterative process, helping the Coder converge on a correct solution.  Your feedback should be precise and actionable. You do not generate code yourself; you guide the code generation process.

{
  "8e5a5113": [
    {
      "attempt_1": [
        [
          3,
          3,
          9,
          5,
          2,
          9,
          3,
          5,
          9,
          9,
          2
        ],
        [
          9,
          9,
          9,
          5,
          9,
          9,
          3,
          5,
          9,
          9,
          9
        ],
        [
          2,
          9,
          9,
          5,
          9,
          9,
          9,
          5,
          9,
          3,
          3
        ]
      ],
      "attempt_2": null
    }
  ],
  "beb8660c": [
    {
      "attempt_1": [
        [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          9
        ],
        [
          0,
          0,
          0,
          0,
          0,
          0,
          7,
          7
        ],
        [
          0,
          0,
          0,
          0,
          0,
          6,
          6,
          6
        ],
        [
          0,
          0,
          0,
          0,
          1,
          1,
          1,
          1
        ],
        [
          0,
          0,
          0,
          4,
          4,
          4,
          4,
          4
        ],
        [
          0,
          0,
          3,
          3,
          3,
          3,
          3,
          3
        ],
        [
          0,
          2,
          2,
          2,
          2,
          2,
          2,
          2
        ],
        [
          8,
          8,
          8,
          8,
          8,
          8,
          8,
          8
        ]
      ],
      "attempt_2": null
    }
  ],
  "93b581b8": [
    {
      "attempt_1": [
        [
          5,
          5,
          0,
          0,
          2,
          2
        ],
        [
          5,
          5,
          0,
          0,
          2,
          2
        ],
        [
          5,
          5,
          0,
          0,
          2,
          2
        ],
        [
          0,
          0,
          3,
          1,
          0,
          0
        ],
        [
          0,
          0,
          2,
          5,
          0,
          0
        ],
        [
          1,
          1,
          0,
          0,
          3,
          3
        ]
      ],
      "attempt_2": null
    }
  ],
  "b8cdaf2b": [
    {
      "attempt_1": [
        [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0
        ],
        [
          2,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          2
        ],
        [
          0,
          2,
          0,
          0,
          0,
          0,
          0,
          2,
          0
        ],
        [
          0,
          0,
          0,
          8,
          8,
          8,
          0,
          0,
          0
        ],
        [
          8,
          8,
          8,
          2,
          2,
          2,
          8,
          8,
          8
        ]
      ],
      "attempt_2": null
    }
  ],
  "a5f85a15": [
    {
      "attempt_1": [
        [
          0,
          0,
          0,
          0,
          6,
          0,
          0,
          0,
          0,
          0,
          0,
          0
        ],
        [
          6,
          0,
          0,
          0,
          0,
          4,
          0,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          4,
          0,
          0,
          0,
          0,
          6,
          0,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          6,
          0,
          0,
          0,
          0,
          4,
          0,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          4,
          0,
          0,
          0,
          0,
          6,
          0,
          0,
          0
        ],
        [
          0,
          0,
          0,
          0,
          6,
          0,
          0,
          0,
          0,
          4,
          0,
          0
        ],
        [
          0,
          0,
          0,
          0,
          0,
          4,
          0,
          0,
          0,
          0,
          6,
          0
        ],
        [
          0,
          0,
          0,
          0,
          0,
          0,
          6,
          0,
          0,
          0,
          0,
          4
        ],
        [
          6,
          0,
          0,
          0,
          0,
          0,
          0,
          4,
          0,
          0,
          0,
          0
        ],
        [
          0,
          4,
          0,
          0,
          0,
          0,
          0,
          0,
          6,
          0,
          0,
          0
        ],
        [
          0,
          0,
          6,
          0,
          0,
          0,
          0,
          0,
          0,
          4,
          0,
          0
        ],
        [
          0,
          0,
          0,
          4,
          0,
          0,
          0,
          0,
          0,
          0,
          6,
          0
        ]
      ],
      "attempt_2": null
    }
  ],
  "bc1d5164": [
    {
      "attempt_1": [
        [
          0,
          1,
          1
        ],
        [
          1,
          0,
          0
        ],
        [
          0,
          1,
          1
        ]
      ],
      "attempt_2": null
    }
  ],
  "6d1d5c90": [
    {
      "attempt_1": [
        [
          1,
          1,
          3,
          8,
          8,
          9
        ],
        [
          5,
          8,
          8,
          8,
          9,
          9
        ],
        [
          5,
          4,
          4,
          4,
          4,
          9
        ],
        [
          5,
          3,
          1,
          1,
          4,
          9
        ],
        [
          5,
          3,
          1,
          1,
          4,
          8
        ],
        [
          1,
          3,
          3,
          3,
          8,
          8
        ]
      ],
      "attempt_2": null
    }
  ]
}

# TASK

Our tasks are from ARC-AGI (Abstraction and Reasoning Corpus)
Each task contains a set input-output examples.
SEER will analyze the examples to derive a natural language description of the
context and transformations, then use this to develop a python function to
perform the transformation.
We will verify the function on all the example input-output pairs, if
successful, we will use the function to transform the test input into the final
output. 

ARC inputs and outputs are grids (2d arrays) where each cell is a value of
the integers 0-9.
A grid can be any height or width between 1 x 1 and 30 x 30.
Grid values represent colors using this mapping:

```
COLOR_MAP = {
    0: (238, 238, 238),  # white
    1: (30, 147, 255),  # blue
    2: (220, 50, 40),  # red
    3: (79, 204, 48),  # green
    4: (230, 200, 0),  # yellow
    5: (85, 85, 85),  # gray
    6: (229, 58, 163),  # magenta
    7: (230, 120, 20),  # orange
    8: (135, 216, 241),  # azure
    9: (146, 18, 49),  # maroon
}
```

We will refer to cells as pixels.
Use the color name when referring to the value.

# Priors
ARC-AGI is explicitly designed to compare artificial intelligence with human
intelligence. To do this, ARC-AGI explicitly lists the priors knowledge human
have to provide a fair ground for comparing AI systems. These core knowledge
priors are ones that humans naturally possess, even in childhood.

## Objectness
- Objects persist and cannot appear or disappear without reason. 
- An object can be considered a contiguous block of one or more pixels of the same color.
- Objects can interact or not depending on the circumstances.

## Goal-directedness
- Objects can be animate or inanimate.
- Some objects are "agents" - they have intentions and they pursue goals.  

## Numbers & counting
- Objects can be counted or sorted by their shape, appearance, or movement using
  basic mathematics like addition, subtraction, and comparison.

## Basic geometry & topology
- Objects can be shapes like rectangles, triangles, and circles which can be
  mirrored, rotated, translated, deformed, combined, repeated, etc. Differences
  in distances can be detected.
- Adjacency is very important - side by side and diagonal

ARC-AGI avoids a reliance on any information that isn't part of these priors,
for example acquired or cultural knowledge, like language.