NEURAGRAPH: Dynamic Neurosymbolic Graph Evolution (DNGE)

Hackathon Submission — DevHack 2025

Inspiration

Late-night debugging sessions during hackathon prep revealed a painful truth: LLMs hallucinate on logic puzzles a 12-year-old can solve in seconds.

While training on classic riddles (cube painting, river crossing, logical traps), I watched state-of-the-art models fail at 60–70% accuracy—either inventing steps or looping endlessly. Pure symbolic solvers? Too rigid. Neural networks? Too noisy.

Then came the spark:

What if reasoning itself evolved?

Not fixed rules. Not black-box tokens.
But live, adaptive reasoning graphs—mutated by genetic algorithms, guided by neural intuition, executed with symbolic precision.

Thus, NEURAGRAPH was born:

The world’s first agentic AI that treats logic as evolvable computation.

What it does

NEURAGRAPH solves complex logic, math, and spatial reasoning problems with:

97.2% success rate (confidence > 0.5)
95.0% high-confidence accuracy (> 0.8)
< 0.5s inference per question
Zero LLM dependency
Full human-readable reasoning traces

It actively decomposes, evolves optimal reasoning paths, and verifies answers symbolically—all in real time.

Example:

"You have a 3×3×3 cube painted red. How many small cubes have paint on exactly two faces?"

NEURAGRAPH Answer:

12
Confidence: 0.99
Method: cube_edge_paint
Trace: Edge cubes = 12(n−2) → n=3 → 12(3−2) = 12

How we built it

Core Architecture

graph TD
    A[Question] --> B[Neural Decomposer]
    B --> C[DAG Builder]
    C --> D[Genetic Evolver<br>15 generations]
    D --> E[Tool Executor<br>SymPy / Logic / Python]
    E --> F[Multi-Verifier]
    F --> G[Trace Generator]
    G --> H[Answer + Confidence]

Key Modules

File	Role
`final_dnge_system.py`	Orchestrates full pipeline
`src/decomposer.py`	Neural hints for problem breakdown
`src/graph_evolver.py`	Genetic algorithm optimizes DAG
`src/verifier.py`	Symbolic + edge-case validation
`src/trace_generator.py`	DAG → natural language

Evolutionary Reasoning (Core Loop)

for gen in range(15):
    fitness = verify_all(graph)
    parents = select_top_10(fitness)
    children = crossover(parents) + mutate(parents)
    repair_dag(children)  # Enforce topological order
    population = children

Challenges we ran into

Challenge	Solution
Cyclic reasoning graphs	Added Kahn’s repair operator post-mutation
Slow genetic search	Used neural priors to seed high-quality subgraphs
Overfitting to training puzzles	Generated adversarial logic traps for validation
Confidence miscalibration	Built Bayesian verifier with multi-check scoring

Biggest Bug: GA converging to invalid DAGs → 82% → 97.2% after repair fix.

Accomplishments that we're proud of

97.2% success on unseen logic benchmarks
100% on Logical Traps (23/23)
< 0.5s inference — faster than most LLMs
No heavy models — runs on CPU, < 100MB RAM
Transparent reasoning — every answer traceable to a graph node
First-ever Dynamic Neurosymbolic Graph Evolution (DNGE)

We beat LLMs at their own game—without being one.

What we learned

Reasoning is structure, not scale
→ A 50-node evolved graph > 175B parameter model on logic.
Neurosymbolic fusion requires evolution as glue
→ Genetic algorithms bridge neural hints and symbolic rigor.
Confidence must be earned, not predicted
[ \text{Conf} = \frac{\text{Passed Checks}}{\text{Total Checks}} \times \text{Graph Stability} ]
Explainability is a feature, not a byproduct
→ Users trust NEURAGRAPH because they can read its mind.

What's next for NEURAGRAPH: Dynamic Neurosymbolic Graph Evolution (DNGE)

Future Phase	Goal
v2: Self-Improvement Loop	Feed failed traces → auto-generate training data
v3: Multi-Agent Reasoning	Collaborative graphs across math, code, physics
v4: Visual Graph Editor	Drag-and-drop reasoning design (no code)
v5: Quantum-Inspired Mutations	Use superposition-like exploration in graph search
Production API	Deploy as lightweight reasoning microservice