Teaching AI to Solve Puzzles Like a Child: A Three-Stage Rule-Chaining Framework on ARC

> *"Intelligence is not knowledge itself, but the way knowledge is applied."* — Jean Piaget

Prologue: A "children's game" that gives AI headaches

Imagine a 5×5 grid. On the left, an input pattern; on the right, an output pattern. Your task: figure out the rule that transforms input into output, then apply it to a new input.

• Example 1: a red cross → a blue cross
• Example 2: a yellow circle → a green circle
• Test: a red square → ???

You'd instantly say: red becomes blue, so the red square becomes a blue square. Congratulations—you just solved an ARC (Abstraction and Reasoning Corpus) task.

Yet for today's most advanced AI, such puzzles can be harder than calculus. ARC was designed by François Chollet (creator of Keras) to test abstract reasoning—the ability to "see" and "reason" without training data or language instructions. On ARC, GPT-4 scores under 5%; humans are near 85%.

This gap is called the Generalization Gap: AI trained on massive data can still fail at novel puzzles that a kindergartner can solve. This story is about an AI system that crosses this gap—not with more data or bigger models, but by thinking like a child.

ARC: AI's "kindergarten entrance exam"

ARC tests fluid intelligence: understanding and applying novel rules from scratch. Each task contains 2–10 input→output example pairs and one test input. Task types include color transformations, geometric operations (rotation, mirroring, translation), object counting and comparison, pattern completion, and nested rule combinations. Crucially, every test task is completely new—memorizing the training set cannot help. It's like an entrance exam where the teacher shows a few examples and checks whether you can extrapolate.

The three-story reasoning tower

Deblina Kar and her team's Multi-Stage Rule-Chaining Framework resembles a three-story tower:

| Level | Name | Role | Analogy | |-------|------|------|---------| | 1 | Solver 1 | Deterministic rule discoverer | A rigorous logician | | 2 | Solver 2 | Compositional generalizer | A creative architect | | 3 | Solver 3 | Structural abstractionist | A philosopher seeing essence |

The layers are cooperative and progressive: try the simplest method first (Solver 1), escalate to compositional methods (Solver 2), then deploy the highest abstraction (Solver 3).

Solver 1: the logician's microscope

A hybrid cognitive model combining visual perception and symbolic logic:

1. Perception: identifies connected regions, geometric boundaries, repeated textures; encodes objects as 128-dim vectors via a lightweight CNN—seeing "objects," not pixels. 2. Candidate rules: generates symbolic, parameter-free transformations—rotations, mirrors, color replacement, object copy/delete, fill, crop, concatenation. 3. Verification: applies rules to examples and selects the simplest one that explains the data, following the Minimum Description Length (MDL) principle (Occam's razor). 4. Chaining: composes multiple simple rules (e.g., "rotate 90°, then fill, then mirror") like LEGO bricks.

Solver 2: the architect's toolbox

Solver 2 performs structure synthesis—decomposing big problems into small ones and combining the results:

• Block merging: detects overlapping/nested sub-blocks and merges them with spatial alignment rules.
• Dynamic geometry: functions like spiral, ring_creation, and custom_spiral generate complex patterns.
• Context overlays: priority rules resolve color conflicts when sub-patterns overlap.
• Fallback robustness: prunes excess fills, rebuilds local sub-blocks, fills missing parts using learned primary-secondary relations.

Solver 3: the philosopher's insight

Solver 3 handles tasks beyond deterministic logic or composition:

• Latent relational reasoning: modules like stack_patterns_colwise and rotated_inner_pattern reason about relationships between sub-patterns (e.g., "the rule applies to the inner object, not the outer container").
• Hierarchical embedding: recursively embeds compact sub-patterns into higher-dimensional structures—like Russian nesting dolls or fractals.
• Analogy and rotation invariance: detects conceptual equivalence (a 90°-rotated version is "essentially the same"), enabling generalization from few examples.
• LLM-assisted reasoning: an LLM acts as a "cognitive supervisor," predicting intermediate subgrids and proposing symmetry hypotheses—but its outputs are translated back into executable symbolic operations, preserving interpretability.

Results: behind the 95.4%

| Dataset | Tasks | Solved | Accuracy | |---------|-------|--------|----------| | Training | 1,000 | 995 | 99.5% | | Validation | 120 | 105 | 87.5% | | Test | 240 | 230 | 95.8% | | Total | 1,360 | 1,300 | 95.4% |

Per-solver analysis:

| Solver | Reasoning type | Accuracy | Avg. output time | |--------|----------------|----------|------------------| | Solver 1 | Deterministic/geometric | 83.2% | 900 s | | Solver 2 | Compositional/multi-block | 92.8% | 65 s | | Solver 3 | Abstract/contextual | 95.4% | 37 s |

Observations: Solver 1 is the foundation despite the lowest accuracy; Solver 3 is both the most accurate and fastest—once it "gets" a structurally clear but relationally complex problem, execution is quick; the key is complementarity across the three layers.

Interpretability: why this AI is trustworthy

• Reasoning traces: every prediction comes with an explicit symbolic trajectory, e.g. extract template → detect symmetry → apply rotation → map colors → assemble output—the actual executed steps, not post-hoc rationalization.
• Explicit rule representation: unlike a neural net's fuzzy associations, the system reports explicit, parameter-free transformation rules.
• MDL preference: simplest explanations win, matching the human preference for parsimony.

Broader significance

1. Neuro-symbolic synergy: neural networks provide "intuition" (CNN perception, LLM suggestions); symbolic systems provide "logic". This hybrid may be closer to human intelligence than pure end-to-end networks. 2. Progressive fallback: deterministic → compositional → abstract, echoing Kahneman's dual-system theory (fast intuition vs. slow reason). 3. Data efficiency: no millions of training samples needed—symbolic reasoning and compositional generalization handle new tasks, like a child who needs only a few examples to grasp the concept "cat". 4. Interpretable general intelligence: high scores with full transparency offer a new paradigm for trustworthy, explainable AI.

Conclusion

ARC was Chollet's vision of a benchmark for human-like intelligence—not knowledge or compute, but raw capacity to understand and create. For years it has been AI's Waterloo, where powerful LLMs behave like parrots with amazing memory but poor understanding.

Kar's three-stage framework doesn't break the benchmark (95.4% is high but not 100%), but it shows a different path: not making models bigger, but smarter—decomposing problems, composing solutions, abstracting essence. Perhaps true general intelligence lies not in how much is memorized, but in how one thinks. And this three-story reasoning tower—logician, architect, philosopher—is teaching AI to think.

References

• Kar, D., et al. (2026). *A Multi-Stage Rule-Chaining Framework for Compositional and Interpretable Cognitive Reasoning*. arXiv:2609.10654.
• Chollet, F. (2019). *On the measure of intelligence*. arXiv:1911.01547.
• Chollet, F. (2020). *The ARC benchmark*. https://github.com/fchollet/ARC
• Lake, B. M., et al. (2017). Building machines that learn and think like people. *Behavioral and Brain Sciences*, 40, e253.
• Marcus, G. (2020). *The next decade in AI: four steps towards robust artificial intelligence*. arXiv:2002.06177.
• Kahneman, D. (2011). *Thinking, Fast and Slow*. Farrar, Straus and Giroux.
• Mitchell, T. M. (1997). *Machine Learning*. McGraw-Hill.