Your LLM can do math but it’s confidently wrong about it
You ask Claude: “If I have 5 apples and you give me 3 more, then I give you back 2, how many do I have?”
Claude: “You have 6 apples. 5 + 3 = 8, then 8 - 2 = 6.”
Correct.
Now ask: “If I have N apples and the number follows a Fibonacci sequence, what’s the value of F(N+2)?”
Claude: “The next Fibonacci number after N would be… [makes something up]”
Wrong.
Claude can do arithmetic when it’s spelled out. It fails when it needs to use formal logic or algebra. It’s fluent but not rigorous.
This is the problem neuro-symbolic AI solves.
The 60-year arc of AI
1960s-1980s: Symbolic AI (logic, rules, reasoning)
Knowledge representation: Facts and rules, explicitly encoded.
% Example: Rule-based reasoning
parent(tom, bob).
parent(bob, ann).
grandparent(X, Z) :- parent(X, Y), parent(Y, Z).
% Query: Who is Tom's grandchild?
?- grandparent(tom, X).
X = ann.
Strengths:
- Guaranteed correct answers
- Explainable (you can trace why)
- Can handle unlimited complexity
Weaknesses:
- Requires hand-coding all knowledge
- Brittle (one missing fact breaks the chain)
- No learning from data
1990s-2020s: Neural networks (learning, pattern recognition)
Deep learning: Learn patterns from data, no hand-coding required.
Input data → Neural network → Output
(learns from examples, not rules)
Strengths:
- Learns from data automatically
- Scales to complex domains
- No hand-coding needed
Weaknesses:
- No guarantees (could be confidently wrong)
- Can’t handle logical reasoning
- Black box (why did it decide that?)
2020s: Neuro-Symbolic (combining both)
LLMs for reasoning + knowledge graphs for grounding + formal logic for guarantees.
Input → [LLM reads query] → [Graph constrains search] → [Logic engine verifies] → Output
(flexible) (structured) (guaranteed correct)
Example: Contract analysis
- LLM extracts key terms from a contract (neural)
- Knowledge graph stores relationships (structure)
- Logic engine checks: “Is this compliant with regulations?” (symbolic)
Why this convergence matters now
1. LLMs hit a reasoning ceiling
Scaling models helps, but there’s a ceiling on what next-token prediction can do.
Small model (7B): "5 + 3 = 8 ✓, but F(5) = ?"
Medium model (70B): "5 + 3 = 8 ✓, F(5) = 5 ✓ (sometimes)"
Large model (405B): "5 + 3 = 8 ✓, F(5) = 5 ✓ (more often)"
Even the largest LLMs confabulate on complex logic. They’re better at larger scales, but not perfect.
2. Knowledge graphs solve grounding
Vector databases (RAG) are fine for retrieval (“what does this document say?”) but they’re not great for reasoning (“what does this mean in the context of our entire knowledge base?”).
Knowledge graphs let you:
- Query explicitly (follow relationships)
- Reason soundly (use graph paths as proofs)
- Update efficiently (change a relationship, not re-embed everything)
3. Formal logic solves verification
Some decisions need guarantees. “Is this transaction compliant?” can’t be answered probabilistically. You need certainty.
Logic systems (Prolog, constraint solvers) give you that. They can prove whether something is true or definitively false.
4. Costs favor hybrid
Fine-tuning a 175B LLM is expensive. Running a symbolic reasoner on a 7B LLM is cheap and often more correct.
All-LLM approach: 405B model, costs $0.10 per 1000 tokens
Neuro-Symbolic: 7B LLM + knowledge graph + Prolog
costs $0.01 per 1000 tokens (and more correct)
How they work together
The pattern: LLM → Graph → Logic
Example: Fraud detection
- LLM reads the transaction (“User bought $5000 in electronics from unknown merchant in Belarus”)
- Graph searches for context (User → account age, User → transaction history, Country → risk level)
- Logic engine checks rules (
- IF transaction_amount > 3x_avg AND country_risk > 0.7 THEN flag
- IF account_age < 30 days AND international_tx THEN flag
- Result: FLAGGED (two rules triggered)
- LLM explains decision (“Your transaction was flagged because it’s 8x your typical spend and the merchant is in a high-risk region. It’s on hold for 24hr review.”)
Each layer does what it’s best at:
- LLM: Natural language understanding
- Graph: Relationship lookup (fast, structured)
- Logic: Rule verification (certain)
- LLM again: Explanation (natural language)
Another pattern: Graph → LLM → Logic
Example: Enterprise Q&A
- Graph stores company knowledge (Product → features, Feature → pricing tier, etc.)
- LLM reasons over graph (“You asked about pricing for Enterprise customers using Feature X. Based on the graph, I know Feature X is in Premium tier, which costs $Y/month.”)
- Logic engine checks constraints (“Can an Enterprise customer with Budget Z afford this? IF cost_per_month < Z/12 THEN yes”)
- Return answer (Yes, with explanation)
Three real uses
1. Compliance and regulations
Regulations are rules (symbolic). Contracts are text (neural). Verify that text meets rules.
Regulation: "All loans > $100k must have 2 approvals"
Contract text: "This $150k loan has 1 approval from Alice"
Neuro-symbolic check: FAILED (1 ≠ 2)
Confidence: 100% (formal logic proved it)
2. Complex reasoning (math, logic puzzles)
Pure LLMs struggle with multi-step logic. Combining with symbolic reasoning helps.
Question: "If A→B and B→C, does A→C?"
LLM alone: "Probably yes? (60% confident)"
LLM + Logic: YES (100% confident, by transitivity rule)
3. Grounded question-answering
LLM reasons over knowledge graph instead of hallucinating.
Question: "What's the revenue impact of Feature X on customers in region Y?"
LLM-only: "Based on typical SaaS patterns, it probably increases revenue by 5-10%"
(Sounds good, probably wrong)
Neuro-symbolic: Graph knows:
- Revenue data for Feature X
- Customers in region Y who use it
- Actual impact: 12% increase
Result: "Feature X increased revenue by 12% for region Y customers"
(Grounded, verifiable)
Why enterprises are adopting it now
- Cost pressure: Fine-tuning huge LLMs is expensive, hybrid is cheaper
- Compliance: Regulators want to understand AI decisions (neuro-symbolic is more explainable)
- Accuracy: Hybrid systems are often more accurate than LLM-only
- Maturity: Tools are mature now (LangChain, Neo4j, Prolog engines all production-ready)
Common misconceptions
Misconception 1: “Neuro-symbolic means no neural networks”
Wrong. It means adding symbolic reasoning to neural networks, not replacing them.
Misconception 2: “Knowledge graphs are the only way”
There are other symbolic approaches (constraint solvers, rule engines, theorem provers). Graphs are one option.
Misconception 3: “We need to choose: neural OR symbolic”
No. The future is hybrid. Use both. Use the right tool for each task.
The preview: What’s next in this series
- Post 9: Knowledge graphs as the data layer
- Post 10: Agentic knowledge graph engineering (concrete architecture)
- Post 11: Reasoning engines (logic programming + LLMs)
- Post 12: Production patterns (how to deploy this safely)
- Post 13: Enterprise case studies and future directions
Each post builds on this foundation: combining neural networks with symbolic reasoning.
The takeaway
Pure LLMs are powerful but not certain. Pure logic systems are certain but fragile. Neuro-symbolic AI combines both:
- Neural: Flexible, learns from data, handles ambiguity
- Symbolic: Rigid, guaranteed correct, handles logic
Together they can solve problems neither can alone.
If you’re building something that needs both accuracy and explanation, neuro-symbolic is the architecture worth learning.
Next in this series: Knowledge Graphs as the Symbolic Backbone