Teaching AI to Solve Puzzles Like a Child: How a Three-Stage Reasoning Tower Learns to 'See' the World

> *"The essence of intelligence is not knowledge itself, but the way knowledge is applied."* — Jean Piaget

!arc_three_tower_card.svg

Prologue: A "Children's Game" That Stumps AI

Imagine a 5×5 grid of colored cells. On the left is an "input" pattern; on the right, an "output" pattern. Your task: infer the rule that transforms input into output, then apply it to a new input.

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

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

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 understand and reason without training data or verbal instructions. GPT-4 scores under 5% on ARC; humans approach 85%.

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

ARC: AI's "Kindergarten Entrance Exam"

ARC tests human-like "fluid intelligence": understanding and applying rules from scratch on unseen problems. Each task contains:

• 2–10 example pairs (input → output)
• 1 test input requiring application of the discovered rule

Task types vary widely: color transformations, geometric operations (rotation, mirroring, translation), object counting and comparison, pattern completion, and nested rule combinations. Crucially, every test task is entirely new — memorizing the training set is useless.

The Three-Story Reasoning Tower

The system by Deblina Kar and her team is called the Multi-Stage Rule-Chaining Framework. Its core idea is 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 abstractor | A philosopher of essence |

The layers collaborate and escalate: the system tries the simplest approach first, then falls back to more complex reasoning.

Solver 1: The Logician's Microscope

A hybrid cognitive model combining visual perception with symbolic logic:

1. Perception: identifies connected components as objects, detects geometric boundaries and repeated textures, and encodes objects as 128-dimensional vectors via a lightweight CNN — seeing "objects" rather than pixels. 2. Candidate rule generation: symbolic, parameter-free operations — rotation, mirroring, color replacement, object copy/delete, fill, crop, concatenation. 3. Validation and selection: applies each rule to examples and picks the simplest one that explains them, following the Minimum Description Length (MDL) principle (Occam's razor). 4. Rule chaining: composes multiple simple rules if no single rule suffices, like building complex structures from LEGO bricks.

Solver 2: The Architect's Toolbox

When deterministic logic fails, Solver 2 performs structural synthesis — decomposing large problems, solving sub-problems, and combining results:

• Block merging: detects overlapping/nested sub-blocks and merges them via spatial alignment rules.
• Dynamic geometry generation: functions like spiral, ring_creation, and custom_spiral for spirals, rings, and periodic patterns.
• Context superposition: priority rules resolve color conflicts in overlapping regions.
• Robust fallbacks: pruning excess fills, rebuilding local sub-blocks, filling gaps via learned "primary-secondary" relations.

Solver 3: The Philosopher's Insight

Solver 3 handles tasks beyond deterministic or compositional methods:

• Latent relational reasoning: modules like stack_patterns_colwise and rotated_inner_pattern understand relations between sub-patterns (e.g., "the rule applies to the inner object, not the container").
• Hierarchical embedding: recursively embeds compact sub-patterns into higher-dimensional structures — like understanding Russian nesting dolls or fractals.
• Analogy and rotation invariance: detects conceptual equivalence (e.g., 90°-rotated versions are "essentially the same"), enabling generalization from few examples.
• LLM-assisted reasoning: a large language model serves as a "cognitive supervisor" — predicting intermediate subgrids, resolving ambiguous overlaps, proposing symmetry hypotheses. Crucially, LLM outputs are translated back into executable symbolic operations, preserving interpretability.

Results: The Story Behind 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% | 900s | | Solver 2 | Compositional/multi-block | 92.8% | 65s | | Solver 3 | Abstract/contextual | 95.4% | 37s |

Notable observations: Solver 1 is the foundation despite the lowest accuracy; Solver 3 is both most accurate and fastest (its problems are structurally clear once "understood"); and the three layers are complementary rather than substitutive.

Interpretability: Why This AI Is Trustworthy

• Reasoning traces: every prediction carries a symbolic trajectory, e.g. extract template → detect symmetry → apply rotation → map colors → assemble output — the actual execution steps, not post-hoc explanations.
• Explicit rule representation: unlike a neural network's fuzzy associations, the system reports explicit, parameter-free transformation rules.
• MDL preference: like humans, the system prefers the simplest sufficient explanation.

Broader Implications

1. Neuro-symbolic synergy: neural networks (CNN for perception, LLM for high-level suggestions) act as heuristic tools providing "intuition," while symbolic systems handle "logic." 2. Progressive fallback: a deterministic → compositional → abstract cascade balances efficiency and coverage, echoing Kahneman's dual-system theory. 3. Data efficiency: the system generalizes via symbolic reasoning rather than millions of samples — much like children, who recognize cats after seeing a few. 4. Explainable general intelligence: high ARC scores with full transparency offer a new paradigm for trustworthy, interpretable AI.

Conclusion

For four years, ARC has been AI's Waterloo — where the most powerful language models behave like parrots with remarkable memory but poor understanding. Kar's three-stage framework doesn't fully defeat it (95.4% ≠ 100%), but it demonstrates a different path:

Not making models bigger, but making them smarter — decomposing problems, combining solutions, abstracting essence. Curious, flexible, learning from examples, adjusting from failure. Perhaps true general intelligence lies not in how much is memorized, but in how one thinks. 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.