Darwin Gödel Machine (DGM)

The repository is organized as follows:

• analysis/: Scripts for plotting and data analysis.
• initial/: SWE-bench logs and performance metrics for the initial agent.
• initial_polyglot/: Polyglot logs and performance metrics for the initial agent.
• swe_bench/: Code required for SWE-bench evaluation.
• polyglot/: Code required for Polyglot evaluation.
• prompts/: Prompts used for foundation models.
• tests/: Test suite for the DGM system.
• tools/: Tools available to the foundation models.
• coding_agent.py: Main implementation of the initial coding agent.
• DGM_outer.py: The primary entry point for running the DGM algorithm.

Based on Nicomachus' classification scheme, positive integers are categorized by comparing the number to its aliquot sum (the sum of all factors of the number excluding the number itself):

• Perfect: The number equals its aliquot sum.
  • Example: 6 (factors 1, 2, 3 sum to 6).
• Abundant: The number is less than its aliquot sum.
  • Example: 12 (factors 1, 2, 3, 4, 6 sum to 16).
• Deficient: The number is greater than its aliquot sum.
  • Example: 8 (factors 1, 2, 4 sum to 7).
  • Note: All prime numbers are deficient.

The task is to implement a system that decodes a single numeric allergy score into a list of specific allergens. Each allergen is represented by a unique power of two (a bitmask).

Allergen Bitmask Mapping:

• eggs: 1
• peanuts: 2
• shellfish: 4
• strawberries: 8
• tomatoes: 16
• chocolate: 32
• pollen: 64
• cats: 128

Requirements:

1. Determine if a person is allergic to a specific item based on the score.
2. Return the full list of allergens present in the score.
3. Ignore any bits in the score that correspond to allergens not in the provided list (e.g., scores of 256, 512, etc.). For example, a score of 257 should only report eggs (1).

Example: A score of 34 (32 + 2) indicates allergies to chocolate and peanuts.

In this specific environment/problem context, the test setup forces the use of global mutable state. While this is considered unidiomatic in Rust, it is a deliberate design choice for this learning exercise.

When working on this problem, you should be aware that you will likely need to interact with global state to satisfy the existing test suite, but you are encouraged to propose a better API design that avoids global mutable state as part of your solution.

This exercise requires implementing a Last-In, First-Out (LIFO) stack using a custom-made singly linked list rather than Python's built-in list, collections.deque, or queue.LifoQueue.

Key requirements:

• Create custom Node and LinkedList classes.
• The LinkedList constructor should accept a list argument, but the internal storage must use nodes and pointers, not a Python list.
• Implement a push and pop mechanism where the head of the list acts as the top of the stack.
• The implementation must differ from a dynamic array-based stack in terms of memory footprint and time complexity (Big-O).

The task is to implement the formChain method in the Dominoes class. The goal is to order a given set of Domino objects into a valid circular chain.

Requirements for a valid chain:

1. Adjacency Match: The dots on one half of a stone must match the dots on the neighboring half of the adjacent stone.
2. Circular Match: The dots on the first stone's non-neighboring half must match the dots on the last stone's non-neighboring half (making the chain circular).
3. Duplicates: The solution may use duplicate stones if multiple sets are provided.

Example:

• Given [2|1], [2|3], and [1|3], a valid chain is [1|2] [2|3] [3|1] because the first and last numbers match (1 == 1).
• Given [1|2], [4|1], and [2|3], the chain [4|1] [1|2] [2|3] is invalid because 4 != 3.

The Domain Specific Language (DSL) is used to create graph data structures. A Graph object is initialized with a list of one or more tuples. Each tuple in the list must contain exactly three elements in the following order:

1. Attributes: A dictionary (dict) representing graph-level attributes.
2. Nodes: A list of tuples, where each tuple is (name, attrs). name must be a str and attrs must be a dict.
3. Edges: A list of tuples, where each tuple is (src, dst, attrs). src and dst must be str, and attrs must be a dict.

The first stage of the robot simulator involves defining basic movement and direction logic.

Core Concepts:

• Directions: The robot can face North (N), East (E), South (S), or West (W).
• Movements:
  • Right(): Turns the robot 90 degrees clockwise.
  • Left(): Turns the robot 90 degrees counter-clockwise.
  • Advance(): Moves the robot one unit forward in its current direction on an infinite grid.

Implementation Details: Directions are represented by the Dir type. The String() method on Dir provides the string representation (e.g., "N", "E").

The CodonsInfo struct provides functionality to map DNA codons (including those with ambiguous shorthand notation) to amino acid names, and to translate RNA sequences into a list of protein names.

Key Features:

• Shorthand Support: Supports ambiguous nucleotide shorthand (e.g., R for A or G). A codon is valid if it matches one or more canonical codons that all map to the same protein name.
• RNA Translation: The of_rna method converts RNA (using U) to DNA (using T), segments it into codons, and translates them. Translation stops if a STOP codon is encountered.
• Error Handling: Returns an Error if a codon is invalid, if the RNA length is not a multiple of 3, or if ambiguous codons map to different proteins.