> For the complete documentation index, see [llms.txt](https://neurosymbolicai.gitbook.io/neuro-symbolic-ai-in-practice/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://neurosymbolicai.gitbook.io/neuro-symbolic-ai-in-practice/part-iii-core-approaches/chapter-4/4-3-hybrid-architectures/4-3-applications.md). # 4.3.3–4.3.14 Case Studies & Applications > This section presents twelve case studies illustrating the hybrid co-processing paradigm across domains. Each case study follows the structure: **Problem → NeSy Approach → Key Result → Takeaway**. A comparison table at the end of the section (§4.3 Summary) allows rapid cross-referencing. *** ## 4.3.3 Case Study: AlphaCode — Planning over Program Space **Problem.** Competitive programming requires simultaneously understanding natural language problem statements, reasoning about algorithms, and generating correct code. Pure neural approaches produce syntactically plausible but semantically incorrect programs. **NeSy Approach.** **AlphaCode** (Li et al., 2022) combines a large transformer with a deterministic symbolic oracle (the program executor): 1. **Large-scale pre-training:** A transformer model (1.4B parameters) is pre-trained on a large corpus of GitHub code across multiple languages. 2. **Fine-tuning on competitive programming:** The model is fine-tuned on CodeContests — a dataset of competitive programming problems with solutions from Codeforces, HackerEarth, and similar platforms. 3. **Large-scale sampling:** For each problem, the model samples a large number (hundreds to thousands) of candidate programs. 4. **Symbolic filtering (test execution):** Generated programs are executed against provided example test cases. Programs that fail any test case are immediately eliminated. This is the symbolic verification oracle — a deterministic program evaluator. 5. **Clustering and selection:** Surviving programs are clustered by output behavior (not code text), and one representative from the largest cluster is submitted. The intuition: programs that agree on outputs are more likely to be implementing the same correct algorithm. **Key Result.** AlphaCode achieved approximately the **50th percentile** among human competitors on Codeforces — the first time any AI system performed at this level on competitive programming. (Context: this was measured via simulated contests on problems predating the training cutoff, evaluated against active Codeforces participants who are self-selected competitive programmers — a stronger baseline than general software engineers.) **Takeaway.** The sampling-filtering loop is structurally identical to the plan generation-verification loop in LLM-Modulo (Section 1.3). The neural model generates candidates; the symbolic oracle filters. The key insight: the oracle provides *ground truth* feedback, not learned approximations. Any domain with a deterministic correctness check can apply this pattern. *** ## 4.3.4 PLOI — Planning with Learned Object Importance **Problem.** Classical planning's scalability bottleneck is often not the planning algorithm itself, but **state representation size**: a problem with 100 objects and 20 predicate types has a grounding with millions of potential fluents. Even a fast planner struggles when most of those fluents are irrelevant to the current goal. **NeSy Approach.** **PLOI** (Chitnis et al., 2021) uses a neural classifier to filter irrelevant objects before planning, then relies on the planner's failure signal to recover: 1. A **neural relevance classifier** (a graph neural network over the scene's entity-relation graph) takes the full initial state and goal as input and outputs an importance score $\rho(o) \in \[0,1]$ for each object $o$. 2. Objects below a threshold are pruned from the state representation, yielding a much smaller planning problem. 3. A **classical planner** solves the reduced problem. 4. If the planner fails (the pruned objects were actually needed), the threshold is relaxed and more objects are included — a **progressive refinement** loop that guarantees completeness. **Key Result.** On robotic manipulation domains with 50–100 objects, PLOI achieves 3–5× planning speedups over baselines, with the neural classifier trained from fewer than 500 demonstration plans. Completeness is maintained by the progressive refinement fallback.(Chitnis et al., 2021) **Takeaway.** Relevance filtering is a problem classical planners solve poorly (they consider all objects equally) and that neural networks can learn well (relevance is a perceptual judgment about goal-object relationships). The planner's failure feedback drives progressive threshold relaxation — this bidirectional loop is what places PLOI in §4.3 (Hybrid) rather than §4.2 (Neural Helps Symbolic). *Reference:*\ Chitnis, Rohan, et al. "PLOI: Planning with Learned Object Importance." *Proceedings of AAAI*, 2021. | Code: *** ## 4.3.5 The stable-worldmodel Benchmark (2026) **Problem.** Any neuro-symbolic system that includes a learned world model must answer: *how accurately does the world model predict state transitions, and does that accuracy translate to better plans?* There was no unified benchmark to answer this question systematically. **NeSy Approach.** **stable-worldmodel** (Maes et al., 2026) is a benchmark platform specifically designed to decouple world model evaluation from planning evaluation: * **Unified evaluation protocol** across multiple world model architectures and planning solvers, covering grid-worlds, logistics, robotic manipulation, and navigation environments. * **Decoupled evaluation:** Measures world model prediction accuracy (dynamics understanding, representation quality) separately from downstream control performance, enabling systematic in-silico evaluation of generalization. * **Open-source modular codebase:** Enables rapid ablation studies across visual, geometric, and physical factors of variation; researchers can swap world models in and out without changing the planning algorithm. * **High-performance data layer:** Native support for MP4, HDF5, and LeRobot datasets, eliminating the data-loading bottleneck that afflicts prior world model benchmarks. **Key Result.** The benchmark reveals that world model accuracy does not automatically translate to better planning performance — a model that scores highly on next-state prediction can produce worse plans than a less accurate one that happens to be precise in the regions the planner actually explores. **Takeaway.** World models and planners must be co-designed. A world model trained in isolation, optimized for prediction accuracy on the training distribution, will systematically underperform a model designed to be accurate where the planner actually searches. This motivates the co-design principle that is the hallmark of the most successful hybrid systems in §4.3. *Reference:*\ Maes, Lucas, et al. "stable-worldmodel: A Platform for Reproducible World Modeling Research and Evaluation." *arXiv preprint* arXiv:2605.21800 (2026). *** ## 4.3.6 FunSearch — Discovering New Mathematics with LLMs **Problem.** AlphaProof proves theorems humans posed; AlphaCode generates programs to pass test cases. Neither discovers fundamentally new mathematical constructions — objects that no human had previously found. The question is whether an LLM, guided by a formal evaluator, can explore beyond the boundary of known mathematics. **FunSearch** (Romera-Paredes et al., 2024) introduces a new pattern in the neuro-symbolic design space: **LLM-guided evolutionary program search for mathematical discovery**. Unlike AlphaProof (which finds formal proofs of known conjectures) and AlphaCode (which generates programs to pass test cases), FunSearch discovers *new mathematical constructions and algorithms* not previously known. **Architecture:** ``` ┌─────────────────────────────────────────────────────────────┐ │ FunSearch Loop │ │ │ │ 1. POPULATION: island-based pool of Python programs │ │ (mathematical constructions) │ │ │ │ 2. SAMPLE: select high-scoring programs as few-shot │ │ examples for the LLM │ │ │ │ 3. GENERATE: LLM produces a new program by │ │ combining / mutating the selected examples │ │ │ │ 4. EVALUATE: exact symbolic evaluator scores the │ │ program against the mathematical criterion │ │ (e.g., size of cap-set, packing density) │ │ │ │ 5. FILTER: programs below threshold discarded; │ │ high-scorers added to population │ │ │ │ 6. REPEAT: millions of iterations across island pool │ └─────────────────────────────────────────────────────────────┘ ``` The separation of roles is clean: the **LLM** provides variation (generating novel programs by analogy and combination); the **symbolic evaluator** provides selection pressure (measuring exact mathematical quality). Neither alone suffices: the LLM cannot evaluate correctness, and the evaluator cannot generate programs. **Key Result:** * **Cap-set problem:** Discovered a cap-set of size **512** in $\mathbb{F}\_3^8$ — improving on Edel's 20-year-old record of 496 (2004) and establishing the best known lower bound for cap-sets in dimension 8 over the ternary field * **Bin packing:** Discovered a new online heuristic that reduces average excess capacity by 3.5% over the previous best algorithm on standard benchmarks * **Symmetry in sorting networks:** Discovered new lower bounds for sorting network depth **Takeaway.** AlphaProof proves theorems humans posed; FunSearch discovers constructions humans had not found. Any domain with a formal, exact evaluator (a mathematical criterion, a physics simulation, a compiler) can instantiate this pattern: the symbolic component defines what "correct" or "better" means; the neural component explores the space of what is possible. *Reference:* Romera-Paredes, Bernardino, et al. "Mathematical Discoveries from Program Search with Large Language Models." *Nature* 625 (2024): 468–475. | Code: *** ## 4.3.7 Task and Motion Planning — PDDLStream **Problem.** Classical planning operates over discrete state spaces: objects exist, predicates are true or false, actions teleport objects between configurations. Real robot manipulation requires reasoning in continuous configuration spaces: an arm must plan a collision-free trajectory to grasp an object at a specific pose, and the grasp pose itself is a continuous variable. Neither pure symbolic nor pure neural approaches solve this alone. **Task and Motion Planning (TAMP)** is the subfield that integrates symbolic task planning (PDDL-level goal decomposition) with continuous motion planning (sampling-based geometric planners). It is, structurally, one of the most important neuro-symbolic applications currently deployed in robotics research. ### PDDLStream **PDDLStream** (Garrett et al., 2020) is the dominant TAMP framework. It extends PDDL with **streams** — lazy, conditional generators for continuous objects: ```pddl ; Stream: sample a grasp pose for an object (:stream sample-grasp :inputs (?obj) :domain (Graspable ?obj) :outputs (?grasp) :certified (Grasp ?obj ?grasp)) ; Stream: plan a collision-free trajectory (:stream plan-motion :inputs (?robot ?q1 ?q2) :domain (and (Conf ?robot ?q1) (Conf ?robot ?q2)) :outputs (?traj) :certified (Motion ?robot ?q1 ?traj ?q2)) ``` Streams are invoked **optimistically**: the task planner assumes a stream will succeed and plans with the certified facts; only if the plan is committed to execution does the stream actually generate a continuous value (calling IK solvers, motion planners, or grasp estimators). If a stream fails, the planner backtracks and tries alternative task sequences. **Architecture:** ``` Natural language goal / symbolic goal specification │ ▼ PDDL task planner ← Symbolic (Fast Downward) (optimistic planning) │ Plan skeleton + stream calls ▼ Stream generators ← Symbolic + Neural (IK, motion planning, grasp estimation) │ Continuous values ▼ Feasibility checking ← Symbolic oracle (collision checking) │ ▼ Executable robot plan ``` ### Neural Samplers for TAMP The critical bottleneck in PDDLStream is stream invocation: sampling grasp poses, trajectory plans, and placements for complex scenes requires expensive computation. **Neural samplers** (Chitnis et al., 2022) replace hand-crafted geometric samplers with learned neural networks that predict likely-successful continuous values given the scene context, dramatically reducing the number of samples needed. **Key Result.** On tabletop manipulation tasks with 5–10 objects, neural samplers reduce TAMP solve time by 3–7× while maintaining 95%+ success rate. The symbolic task planner and feasibility checker remain unchanged — the neural component only accelerates the sampling step. **Takeaway.** PDDLStream's optimistic planning architecture is the right pattern for any domain where task structure is discrete and formal, but achieving each task step requires solving a continuous geometric or physical problem. The symbolic planner guarantees task-level correctness; the neural sampler accelerates the continuous search without compromising that guarantee. *References:* Garrett, Caelan Reed, et al. "PDDLStream: Integrating Symbolic Planners and Blackbox Samplers via Optimistic Adaptive Planning." *Proceedings of ICAPS*, 2020. | Code: Chitnis, Rohan, et al. "Learning Neuro-Symbolic Skills for Bilevel Planning." *Proceedings of CoRL*, 2022. *** ## 4.3.8 World Models for Planning — DreamerV3 **Problem.** Training an RL agent to plan in complex environments requires millions of real-world interactions. Direct rollouts are expensive, slow, and in physical systems, potentially destructive. A learned world model would allow the agent to simulate trajectories internally — but building one that generalizes across diverse domains with a single configuration had not been achieved. A **learned world model** is a neural network that predicts future states given current state and action: $\hat{s}*{t+1} = f*\theta(s\_t, a\_t)$. For planning, a world model eliminates the need for expensive real-world rollouts: the planner simulates future trajectories in the model and selects actions based on predicted outcomes. The section covers DreamerV3 — the pixel-space paradigm frequently paired with symbolic task planners. For the feature-space paradigm (JEPA-WMs), see §4.4.2. **DreamerV3** (Hafner et al., 2024) is the most general-purpose learned world model for planning across diverse domains. It learns a compact **latent world model** from raw observations: * **Encoder:** maps observations (pixels, proprioception) to a compact latent state $z\_t$ * **Dynamics:** predicts next latent state $\hat{z}*{t+1} = p*\theta(z\_t, a\_t)$ using a Recurrent State Space Model (RSSM) * **Decoder:** reconstructs observations from latent states (for training signal) * **Reward / termination predictors:** predict task reward and episode end from latent states Planning occurs entirely in latent space using an actor-critic trained on imagined rollouts. **Key results (at time of publication, early 2023):** Outperforms prior specialized methods across over 150 diverse tasks with a single configuration; achieves superhuman performance on 33 of 55 Atari games on the Atari 100K benchmark (100,000 environment steps); state-of-the-art on DeepMind Control Suite, ProcGen, and Crafter; first RL agent to collect diamonds in Minecraft without domain knowledge. **Takeaway.** DreamerV3 demonstrates that a single neural world model architecture can generalize across radically different domains — but its latent space is pixel-derived and requires reward annotation. When combined with symbolic task planners (the latent model handles continuous dynamics, a PDDL planner handles discrete task structure), it exemplifies the §4.3 Hybrid pattern. For reward-free, feature-predictive physical planning, see the JEPA-WM paradigm (§4.4.2). *Reference:* Hafner, Danijar, et al. "Mastering Diverse Domains through World Models." *International Conference on Learning Representations (ICLR)*, 2024. | Code: *** ## 4.3.9 Eureka — LLM-Guided Reward Function Design **Problem.** Designing reward functions for complex dexterous manipulation tasks (pen spinning, ball tossing) requires extensive domain expertise and trial-and-error. Hand-crafted reward functions are brittle, domain-specific, and rarely transfer across robot morphologies. **NeSy Approach.** **Eureka** (Ma et al., 2024) introduces a new pattern: the **LLM designs the symbolic reward function** for reinforcement learning, and the RL training loop provides symbolic feedback that guides iterative reward refinement.(Ma et al., 2024) GPT-4 acts as the reward engineer: ``` ┌────────────────────────────────────────────────────────────────┐ │ Eureka Loop │ │ │ │ 1. PROPOSE: GPT-4 generates Python reward function │ │ def compute_reward(state, action, next_state): │ │ # reads joint positions, velocities, contacts... │ │ return reward_value │ │ │ │ 2. EXECUTE: RL training runs with proposed reward │ │ (symbolic feedback oracle: task success metrics, │ │ training curves, final episode returns) │ │ │ │ 3. EVALUATE: GPT-4 reads RL training results, │ │ identifies failure modes, proposes revised reward │ │ │ │ 4. ITERATE until reward surpasses human-designed baseline │ └────────────────────────────────────────────────────────────────┘ ``` **The neuro-symbolic structure:** The LLM is the neural generator proposing symbolic specifications (reward function code). The RL training loop is the symbolic oracle providing ground-truth performance feedback. The reward function itself is the neural-to-symbolic interface: a Python function that maps simulator state to a scalar signal that the RL algorithm can optimize. **Key Result.** Eureka surpasses human-engineered reward functions on **83% of 29 open-source RL environments** spanning 10 distinct robot morphologies, including challenging dexterous tasks such as pen spinning (shadow hand) and ball tossing, as well as locomotion and other control tasks. The discovered reward functions are interpretable Python code that domain experts can inspect, edit, and transfer to new tasks. **Takeaway.** Eureka operationalizes the reward specification problem as a program synthesis task with the RL training loop as the correctness oracle — directly instantiating LLM-Modulo (§1.3) at the *objective* level rather than the plan level. Any domain with a Python-accessible simulator and measurable task success criteria can apply the Eureka pattern without architectural changes to the RL algorithm. *Reference:* Ma, Yecheng Jason, et al. "Eureka: Human-Level Reward Design via Coding Large Language Models." *Proceedings of ICLR*, 2024. | Code: *** ## 4.3.10 SWE-bench — Test Suites as Formal Correctness Oracles **Problem.** Real software engineering requires understanding a repository, diagnosing a bug from a GitHub issue description, and producing a code patch that actually fixes the issue — without regressions. LLMs without a formal correctness signal produce plausible-looking patches that routinely fail. **NeSy Approach.** **SWE-bench** (Jimenez et al., 2024) formalizes software engineering as a neuro-symbolic task: the **test suite is the symbolic oracle** — deterministic, domain-expert-specified, and providing binary correctness feedback.(Jimenez et al., 2024) **The NeSy structure is exact:** ``` Issue description (natural language) │ ▼ LLM agent (neural) reads codebase, proposes code patch │ ▼ Test suite execution (symbolic oracle) 100% deterministic correctness signal │ ▼ If tests pass: patch accepted If tests fail: agent iterates (reflection/re-generation) ``` **Key Result.** LLMs without test execution ("propose and hope") achieve near-zero SWE-bench resolution rates. With test execution as the symbolic oracle, state-of-the-art systems (SWE-agent + GPT-4 Turbo, 2024) resolve **12.5%** of the benchmark — rising to **50%+** with stronger models and scaffolding by 2025. This factor-of-50+ improvement from adding a formal oracle directly mirrors the LLM-Modulo thesis: the neural component generates; the symbolic component verifies; the combination far exceeds either alone. **SWE-agent** (Yang et al., 2024) provides the agent scaffolding: a structured **Agent-Computer Interface (ACI)** that equips the LLM with file editing tools, test execution, and a terminal — designed specifically for the iterative generate-execute-repair loop that test-driven software engineering requires.(Yang et al., 2024) **Takeaway.** The test-suite-as-oracle pattern generalizes beyond software: any domain where correctness is formally checkable (theorem proving with Lean 4, optimization with feasibility verification, planning with PDDL validators) can instantiate the same architecture. The ACI's symbolic structure (file system, test runner, bash terminal) is itself part of the neuro-symbolic architecture — not merely incidental tooling. *References:* Jimenez, Carlos E., et al. "SWE-bench: Can Language Models Resolve Real-World GitHub Issues?" *Proceedings of ICLR*, 2024. | Benchmark: Yang, John, et al. "SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering." *arXiv preprint* arXiv:2405.15793 (2024). | Code: *** ## 4.3.11 Faithful Reasoning Chains and Structured Robot Planning ### Selection-Inference — Formally Auditable Reasoning Steps **Problem.** Chain-of-thought prompting produces reasoning traces that are fluent but not necessarily faithful — the stated reasoning steps may not reflect the model's actual computation, making them legally and clinically unauditable.(Creswell et al., 2023) **NeSy Approach.** **Selection-Inference** (Creswell et al., 2023) replaces free-form CoT with an alternating two-step loop where each step is constrained to be formally verifiable: 1. **Selection:** from a working memory of established facts, select the minimal subset relevant to the next inference step. 2. **Inference:** from the selected facts, produce exactly one new logical proposition. This enforces that each reasoning step is *traceable to its premises* — a causal chain where each proposition cites the facts it derived from. The two LLM modules (selector and inferrer) operate in sequence; there is no automated formal consistency checker in the base Creswell et al. system. Interpretability is achieved through the structured trace rather than a runtime symbolic oracle. **Architecture:** ``` Working Memory: {F1, F2, F3, ...established facts} │ ▼ Selection Model (LLM) selects {F2, F3} as relevant to next step │ ▼ Inference Model (LLM) derives new proposition F_new from {F2, F3} │ ▼ Working Memory += {F_new} (step recorded with explicit premise citations) │ repeat until query answered ``` **Key Result.** Selection-Inference outperforms standard CoT on multi-step logical reasoning benchmarks while producing reasoning chains where each step is independently auditable. **Takeaway.** A radiologist, judge, or safety engineer can verify each inference against its stated premises. This is a categorical improvement over CoT for regulated domains (medical, legal, aerospace) where the reasoning process, not merely the conclusion, must be formally defensible. *Reference:* Creswell, Antonia, et al. "Selection-Inference: Exploiting Large Language Models for Interpretable Logical Reasoning." *Proceedings of ICLR*, 2023. *** ### ProgPrompt — Task Plans as Executable Programs **Problem.** Natural language robot instructions are ambiguous and lack error handling. A robot executing "make coffee" has no structured way to detect that the coffee machine is unavailable mid-execution, or to generate a corrective plan. **NeSy Approach.** **ProgPrompt** (Singh et al., 2023) represents robot task plans as **Python programs with assertion checks and error handling**, turning symbolic program structure into the planning representation itself.(Singh et al., 2023) ```python def task_make_coffee(): assert_at(robot, "kitchen") # pre-condition check navigate_to("coffee_machine") assert_available("coffee_machine") # symbolic state check pick_up("coffee_pod") insert("coffee_pod", "coffee_machine") press_button("brew") wait_until(state="brew_complete") # symbolic state monitor pick_up("coffee_cup") navigate_to("table") place("coffee_cup", "table") ``` The program structure encodes task semantics: sequential steps, pre-condition assertions, error handlers, loops for retry. An LLM generates this program from a natural language instruction; a symbolic program executor runs it and triggers re-planning when assertions fail. **Key Result.** ProgPrompt substantially outperforms unstructured LLM task planning on VirtualHome benchmarks, with assertion-based recovery enabling completion of tasks that unstructured generation fails on. **Takeaway.** Code as Policies (§2.2) generates robot programs primarily for sequential execution. ProgPrompt emphasizes **symbolic feedback**: assertion failures return structured error information (`AssertionError: coffee_machine not available`) that the LLM can reason about, generate a corrective subplan for, and retry. This closed-loop symbolic feedback is structurally identical to the test-execution-as-oracle pattern of SWE-bench (§4.3.10), applied to robot task execution. *Reference:* Singh, Ishika, et al. "ProgPrompt: Generating Situated Robot Task Plans Using Large Language Models." *Proceedings of ICRA*, 2023. | Code: *** ## 4.3.12 Latplan — Learning Symbolic Planning Models from Image Observations **Problem.** Classical planning (Chapter 3) assumes a PDDL domain model is given by a human engineer. But for many robotics and autonomous system applications, the state space is observed only through raw images. Writing PDDL from scratch is expensive and error-prone. Can a neural network learn the propositionalized symbolic model *directly from image transitions*? **NeSy Approach.** **Latplan** (Asai and Fukunaga, AAAI 2018; JAIR 2021) uses a discrete variational autoencoder to encode image observations into a *binary* latent space — each latent dimension is forced toward 0 or 1 via the Concrete (Gumbel-softmax) relaxation during training. The binary latent code is the propositionalized symbolic state: each bit is a ground atom. A second neural network (the transition model) learns operator preconditions and effects from observed image transitions. Both the AAAI 2018 and JAIR 2021 versions use the Concrete (Gumbel-softmax) relaxation during training to produce near-binary latent codes; the JAIR 2021 version additionally introduces the Cube-Space AE architecture, which further enforces the binary constraint structure. **Architecture:** ``` Image obs. (s_t, s_{t+1}) ──► Discrete VAE encoder ──► z_t ∈ {0,1}^K (propositionalized state) │ Transition model ──► preconditions, effects │ STRIPS-style operator library │ Classical planner (Fast Downward) ──► plan │ Discrete VAE decoder ──► action image sequence ``` Key technical insight: the binary constraint on the latent space is the symbolic bridge — continuous neural perception is forced into a discrete propositional representation that a classical planner can reason over. The symbolic planning is purely classical (no neural components at search time) — Latplan inherits all of classical planning's optimality and completeness guarantees *relative to the learned model*. > \[!IMPORTANT] **NeSy insight.** Latplan shows that the boundary between "learned" and "given" can be pushed further toward the perceptual end — the neural component handles perception and model acquisition; the symbolic component handles planning and guarantees. This directly addresses the §5.2 open problem on symbol grounding. **Key Results.** * 8-puzzle, Sokoban, Blocksworld, and LightsOut: Latplan (JAIR 2021) finds valid plans from raw pixel observations with success rates above 80% using Fast Downward. (The earlier AAAI 2018 version evaluated on 8-puzzle and Hanoi.) * The learned PDDL models are human-inspectable — the propositionalized states have interpretable structure corresponding to tile positions. > \[!WARNING] **Limitations.** The learned PDDL model is approximate — planning errors compound if the VAE's binary discretization is noisy. Latplan does not yet scale to complex 3D robotics scenes; it works best on structured 2D grid worlds. Plan length is limited by the transition model's accuracy: long plans degrade. **Takeaway.** Latplan closes the loop between raw observation and formal planning — it is the answer to "where does the PDDL model come from?" for vision-based systems. The binary latent space is not just a design choice; it is the NeSy interface that makes classical planning applicable to image-based environments. *References:* Asai, Masataro, and Alex Fukunaga. "Classical Planning in Deep Latent Space." *Journal of Artificial Intelligence Research* 71 (2021): 1009–1050. arXiv:2107.00110. Code: Asai, Masataro. "Unsupervised Grounding of Plannable First-Order Logic Representation from Images." *Proceedings of ICAPS* 2019. arXiv:1902.08093. *** ## 4.3.13 Neuro-Symbolic Causal Reasoning: DECI and CITRIS **Problem.** Standard NeSy approaches (Chapters 4.1–4.3) establish formal correctness, planning, or knowledge-base consistency. But they do not reason about *causality* — interventions, counterfactuals, and mechanisms. Causal AI asks: not just "does A correlate with B?" but "does A *cause* B, and what happens if we intervene to set A = a?" This is critical for scientific discovery, treatment effect estimation, and robust generalization under distribution shift. **The NeSy Connection.** Pearl's causal hierarchy (association → intervention → counterfactual) maps naturally to a symbolic formalism: a Structural Causal Model (SCM) is a directed acyclic graph (DAG) over variables, where each edge represents a causal mechanism. Neural networks learn the mechanisms; the symbolic DAG represents the causal structure. ### DECI — Deep End-to-end Causal Inference **DECI** (Geffner et al., NeurIPS 2022) jointly learns: * The causal graph $\mathcal{G}$ (symbolic DAG) via a continuous relaxation of the acyclicity constraint (NOTEARS framework) * The conditional mechanisms $p(x\_i \mid \text{parents}(x\_i))$ via a neural flow model (Normalizing Flow) At inference time, do-calculus interventions are applied to the symbolic DAG; the neural mechanisms compute the post-intervention distribution. **Architecture:** ``` Observational data {x_1,...,x_N} │ ▼ DECI joint training: Symbolic: adjacency matrix A (soft, acyclicity constraint: tr(e^(A∘A)) - d = 0) Neural: NF mechanism p_θ(x_i | x_{pa(i)}) │ ▼ Symbolic DAG G* ──► do-calculus: P(Y | do(X=x)) ──► causal effect estimates │ Neural flows ──► counterfactuals: P(Y_{X=x} | X=x', Y=y') ``` **Results.** On the SERGIO gene expression benchmark, DECI achieves AUROC 0.82 for causal graph recovery (vs. 0.74 for the PC algorithm and 0.71 for NOTEARS). The paper reports competitive performance across over a thousand experiments on synthetic datasets and causal ML benchmarks including SERGIO.(Geffner et al., 2022) ### CITRIS — Causal Identifiability from Temporal Interventions in Latent Spaces **CITRIS** (Lippe et al., ICML 2022) learns a disentangled latent representation where each latent dimension corresponds to a causally independent factor, identified via temporal interventions in video sequences. The symbolic causal structure — which factors are independent, which are causally related — is discovered from temporal transitions. > \[!IMPORTANT] **Why this is NeSy.** The causal graph is a *symbolic structure* (a DAG with formal do-calculus semantics) that organizes neural components. The hybrid system provides counterfactual reasoning — a capability that pure neural systems cannot provide even in principle, because it requires the symbolic causal graph to define the intervention semantics. > \[!TIP] **When to use.** DECI and CITRIS are the right tools for scientific discovery where causal mechanism identification matters (genomics, drug interaction, economics); for robust ML systems that must generalize under distribution shift (the causal graph identifies invariant mechanisms); and for any application requiring counterfactual ("what if") queries — pure correlation models cannot answer these. > \[!WARNING] **Limitations.** Causal graph learning is a hard combinatorial problem; DECI uses continuous relaxations that may not recover the exact graph in all cases. Both systems assume *sufficient interventional diversity* in the training data; purely observational data leads to ambiguous causal graphs (Markov equivalence class). Scalability is a constraint: DECI scales to approximately 50 variables, and exact causal discovery is NP-hard in the number of variables. **Takeaway.** Causal NeSy systems provide reasoning capabilities — interventional and counterfactual queries — that no amount of scaling a purely associative neural network can provide. The symbolic causal graph is not a convenience; it is the *necessary* representation for correct causal inference. *References:* Geffner, Tomas, et al. "Deep End-to-end Causal Inference." *Advances in Neural Information Processing Systems* 35 (NeurIPS 2022). arXiv:2202.02195. Code: Lippe, Phillip, et al. "CITRIS: Causal Identifiability from Temporal Interventions in Latent Spaces." *Proceedings of ICML* 2022. arXiv:2202.03169. Code: Pearl, Judea, and Dana Mackenzie. *The Book of Why: The New Science of Cause and Effect*. Basic Books, 2018. ISBN: 978-0465097609. *** ## 4.3.14 Process Reward Models (PRMs): Step-Level Symbolic Verification for Mathematical Reasoning **Problem.** Outcome supervision (RLHF on final answers) trains models to *appear* to reason correctly, but does not ensure each *step* of a multi-step argument is valid. A model may produce a correct final answer via an incorrect reasoning chain (spurious correlation), or fail to generalize because intermediate steps are not individually verified. Mathematical reasoning — where each derivation step has a formal correctness criterion — is the canonical test case. **NeSy Approach.** A **Process Reward Model (PRM)** (Lightman et al., NeurIPS 2024) is a symbolic oracle that assigns a correctness label to each *reasoning step* rather than just the final answer. The PRM is trained on human-annotated step-level labels indicating whether each individual step in a chain-of-thought is correct. At inference time, the PRM scores intermediate steps during beam search, steering generation toward chains with valid intermediate steps. **Architecture:** ``` Problem p │ LLM generates step-by-step solution: Step 1: "Let x = the number of apples..." Step 2: "Then 2x + 3 = 17, so x = 7" Step 3: "Therefore the answer is 7" │ PRM (trained value head) assigns: Step 1: ✓ (correct setup) Step 2: ✓ (valid algebra) Step 3: ✓ (consistent with step 2) │ Best-of-N selection: pick chain with highest min-step PRM score ``` **The symbolic oracle.** Unlike final-answer ORMs (Outcome Reward Models), the PRM's step-level labels encode a *symbolic correctness criterion* — mathematical validity of each derivation step. This makes PRMs a §4.1/§4.3 NeSy system: a symbolic verifier (the trained PRM, which encodes mathematical correctness) constrains neural generation at inference time. **Key Results** (Lightman et al., MATH benchmark): | Verification method | MATH accuracy | | --------------------------------- | ------------- | | No verification (greedy) | 33.0% | | ORM (outcome reward, best-of-N) | 43.5% | | PRM (process reward, best-of-N) | 56.3% | | PRM (process reward, beam search) | 68.2% | **Connection to STaR (§4.1).** STaR uses a binary symbolic oracle (final answer correct/incorrect) to filter reasoning chains. PRMs use a *per-step* symbolic oracle and enable finer-grained guidance. The combination — STaR's self-improvement loop with PRM-guided generation — is the basis for current state-of-the-art mathematical reasoning systems (DeepSeek-R1, Qwen-Math). > \[!TIP] **When to use.** PRMs are appropriate for mathematical reasoning, formal proof generation, and multi-step scientific calculation; for any domain where intermediate steps have a verifiable correctness criterion; and when you want to improve reasoning quality beyond what final-answer supervision provides. > \[!WARNING] **Limitations.** PRMs require step-level human annotations — expensive to collect. OpenAI's PRM800K dataset involved 800,000 step-level labels. The PRM's implicit symbolic criterion is learned, not formal — it can still make step-level errors on novel problem types. For fully certified step-level verification, use a formal proof checker (Lean 4, as in AlphaProof §4.3.1) rather than a trained PRM. **Takeaway.** PRMs show that introducing symbolic structure *within* the reasoning chain — not just at the output — dramatically improves both accuracy and generalization. The step-level symbolic oracle is the key; it transforms unconstrained generation into structured, verifiable reasoning. *References:* Lightman, Hunter, et al. "Let's Verify Step by Step." *Advances in Neural Information Processing Systems* 37 (NeurIPS 2024). arXiv:2305.20050. Data: Zelikman, Eric, et al. "STaR: Bootstrapping Reasoning With Reasoning." *Advances in Neural Information Processing Systems* 35 (NeurIPS 2022). arXiv:2203.14465. *** ## Case Study Comparison The twelve case studies above share the same underlying architecture — neural generator, symbolic oracle, feedback loop — but differ in how that architecture is instantiated. The table below allows rapid cross-referencing: | Case Study | Domain | Neural Role | Symbolic Oracle | Key Result | | ------------------------------------------ | --------------------------------------------- | --------------------------------------- | ----------------------------------------- | ----------------------------------------- | | AlphaCode (§4.3.3) | Competitive programming | Candidate program generator | Test executor | 50th-percentile on Codeforces | | PLOI (§4.3.4) | Robot manipulation | Object relevance classifier | Classical planner + failure signal | 3–5× speedup, completeness preserved | | stable-worldmodel (§4.3.5) | World model evaluation | Learned dynamics predictor | Unified benchmark evaluator | Model accuracy ≠ planning performance | | FunSearch (§4.3.6) | Mathematical discovery | LLM program mutator | Exact mathematical evaluator | Improved 20-year-old cap-set record | | PDDLStream (§4.3.7) | Robot TAMP | Neural grasp/trajectory sampler | PDDL task planner + collision checker | 3–7× TAMP speedup | | DreamerV3 (§4.3.8) | Multi-domain RL | Latent world model | Actor-critic in imagination | Superhuman on 33/55 Atari games | | Eureka (§4.3.9) | Dexterous RL | Reward function proposer | RL training loop | Beats human reward on 83% of envs | | SWE-bench (§4.3.10) | Software engineering | LLM patch generator | Test suite | 50%+ resolution rate (2025) | | Selection-Inference / ProgPrompt (§4.3.11) | Logic / robotics | Reasoning chain generator | Structured trace / assertion executor | Auditable reasoning; robust task recovery | | Latplan (§4.3.12) | Robotic planning from images | Neural (discrete VAE propositionalizer) | Symbolic (PDDL planner) | >80% plan success on 8-puzzle, Sokoban | | DECI / CITRIS (§4.3.13) | Causal discovery and counterfactual reasoning | Neural (normalizing flow mechanisms) | Symbolic (DAG causal graph + do-calculus) | AUROC 0.82 causal graph recovery | | PRMs (§4.3.14) | Mathematical reasoning step verification | Neural (LLM generator) | Symbolic (step-level correctness oracle) | 56.3% → 68.2% on MATH with beam search | *** ## Summary of Section 4.3 Hybrid co-processing architectures represent the frontier of neuro-symbolic AI. They are the hardest to build and the most powerful. The key design principles: 1. **Define the interface precisely.** The neural-to-symbolic boundary must be a well-specified data structure (scene graph, PDDL file, proof context, KG triple). Ambiguity at the interface is the most common source of failure. 2. **Let the symbolic component verify.** The neural component proposes; the symbolic component verifies. Never let neural outputs flow through unchecked to downstream actions. 3. **Use symbolic feedback for neural improvement.** The symbolic system generates training signal (verified proofs, correct plans, consistent KG triples) that improves the neural system — no human labeling required. 4. **Co-design the world model with the planner.** Model accuracy in the wrong regions of state space does not help. Design the world model to be accurate where the planner needs it. 5. **Measure task success, not model accuracy.** A world model that scores 99% on next-state prediction may produce a worse planner than one that scores 95% but is accurate in the critical decision regions. *** ## Open Problems **The interface bottleneck.** The quality of a neuro-symbolic hybrid is limited by the expressiveness of the neural-to-symbolic interface. Scene graphs lose texture; PDDL loses uncertainty; KG triples lose context.(Krishna et al., 2017) The Visual Genome project (Krishna et al., 2017) catalogued the expressiveness limits of scene graphs at scale — 108,000 images annotated with objects, attributes, and relationships — revealing that even dense annotation misses the relational context that matters for downstream reasoning. Developing richer interfaces — that preserve more of the neural representation while remaining formally manipulable — is a key open problem. **Self-supervised world model acquisition.** AlphaProof's self-play loop works because Lean 4 provides a perfect symbolic oracle. In most real-world domains (robotics, healthcare, business processes), no perfect oracle exists. Learning world models from imperfect, noisy, real-world interaction data — while maintaining enough correctness for reliable planning — is unsolved at scale. **KG temporal dynamics.** Knowledge Graphs are typically treated as static. Real-world knowledge changes: drugs are recalled, companies merge, regulations update. Maintaining KG correctness over time(Lacroix et al., 2020) — temporal fact versioning, automated update detection, and plan invalidation when relevant facts change — is a significant unsolved engineering and algorithmic challenge. Temporal KG embedding methods (Lacroix et al., 2020) address the *learning* side of this problem, but automated detection of when a deployed KG has become stale remains unsolved at scale. **Compositionality across modalities.** PLOI filters objects based on learned relevance. But relevance is a deeply compositional concept: "the cup is relevant because it can be filled with water, which is needed to water the plant." Neural relevance classifiers struggle with this multi-hop compositional reasoning.(Lake & Baroni, 2018) The SCAN compositional generalization benchmark (Lake & Baroni, 2018) quantifies this failure: sequence-to-sequence models trained to execute commands generalize poorly to novel command compositions, even when all primitives are seen during training. Combining neural perceptual relevance with symbolic compositional reasoning is an open frontier. *** ## Exercises **Exercise 4.3.1 — Interface Design.** Design the neural-to-symbolic interface for a warehouse robot that must navigate and pick items based on camera input. Specify: (a) the data structure passed from the vision system to the planner, (b) how uncertainty in object detection is represented, (c) how the planner handles missing or low-confidence detections. Compare with the CLEVR scene graph interface from Section 4.1. **Exercise 4.3.2 — KG Construction.** Using the KGCNS (knowledge graph construction, normalization, storage) pipeline sketched in Section 4.3.2, design a medical KG for a hospital's pharmacy system. Identify: (a) source documents, (b) ontologies to use (SNOMED-CT, RxNorm, etc.), (c) relations to extract, (d) consistency constraints to enforce. What happens when two sources disagree on a drug interaction? **Exercise 4.3.3 — PLOI Extension.** PLOI prunes irrelevant *objects*. Design an analogous system for pruning irrelevant *actions* — a neural classifier that predicts which action schemas are relevant to a given goal. What training data would you use? How would you implement the progressive refinement fallback for action pruning? What are the computational tradeoffs vs. object pruning? **Exercise 4.3.4 — AlphaProof Architecture Audit.** Review the AlphaProof architecture described in Section 4.3.1. Identify three specific points where failure can occur in the self-improvement loop (from pre-training through MCTS to policy update). For each failure point, describe: (a) what goes wrong, (b) what the symptom would be, (c) how you would diagnose it empirically. **Exercise 4.3.5 — GraphRAG vs. Standard RAG.** Implement (or sketch the implementation of) both standard RAG and GraphRAG for a legal document corpus (e.g., 1000 contract documents). For the query "Under what conditions can the contract be terminated early?", trace through what each system retrieves, how the context is constructed, and what answer is generated. Identify two query types where GraphRAG provides a systematic advantage over standard RAG. *** ## References 1. Anon. "Neurosymbolic AI: A Survey." *arXiv preprint* arXiv:2508.13678 (2025a). 2. Booch, Grady, et al. "Thinking Fast and Slow in AI." *Proceedings of AAAI 2021*. 3. Marcus, Gary. "The Next Decade in AI: Four Steps Towards Robust Artificial Intelligence." *arXiv preprint* arXiv:2002.06177 (2020). 4. Kahneman, Daniel. *Thinking, Fast and Slow*. Farrar, Straus and Giroux, 2011. ISBN: 978-0374533557. 5. AlphaProof Team and AlphaGeometry Team, DeepMind. "AI Achieves Silver-Medal Standard Solving International Mathematical Olympiad Problems." *DeepMind Technical Report*, 2024. 6. Pan, Shirui, et al. "Unifying Large Language Models and Knowledge Graphs: A Roadmap." *IEEE Transactions on Knowledge and Data Engineering* (2024). 7. Shen, Yongliang, et al. "Multi-Source Knowledge Graph Reasoning for Biomedical Question Answering." *arXiv preprint* arXiv:2502.11269 (2025). 8. Hitzler, Pascal, and Md Kamruzzaman Sarker, eds. *Neuro-Symbolic Artificial Intelligence: The State of the Art*. IOS Press, 2022. 9. Bordes, Antoine, et al. "Translating Embeddings for Modeling Multi-Relational Data." *NeurIPS 2013*. 10. Sun, Zhiqing, et al. "RotatE: Knowledge Graph Embedding by Relational Rotation in Complex Space." *ICLR 2019*. | Code: 10a. Trouillon, Théo, et al. "Complex Embeddings for Simple Link Prediction." *Proceedings of the 33rd International Conference on Machine Learning (ICML)*, 2016. | Code: 10b. Schlichtkrull, Michael, et al. "Modeling Relational Data with Graph Convolutional Networks." *European Semantic Web Conference (ESWC)*, 2018. | Code: 11. Logan, Robert, et al. "Barack's Wife Hillary: Using Knowledge Graphs for Fact-Aware Language Modeling." *ACL 2019*. 12. Zhang, Xikun, et al. "GreaseLM: Graph REASoning Enhanced Language Models." *ICLR 2022*. | Code: 13. Li, Yujia, et al. "Competition-Level Code Generation with AlphaCode." *Science* 378.6624 (2022): 1092–1097. | Dataset: 14. Maes, Lucas, Quentin Le Lidec, Luiz Facury, Nassim Massaudi, Ayush Chaurasia, Francesco Capuano, Richard Gao, Taj Gillin, Dan Haramati, Damien Scieur, Yann LeCun, and Randall Balestriero. "stable-worldmodel: A Platform for Reproducible World Modeling Research and Evaluation." *arXiv preprint* arXiv:2605.21800 (2026). 15. Edge, Darren, et al. "From Local to Global: A Graph RAG Approach to Query-Focused Summarization." *arXiv preprint* arXiv:2404.16130 (2024). | Code: 16. Chitnis, Rohan, et al. "PLOI: Planning with Learned Object Importance." *Proceedings of AAAI*, 2021. | Code: 17. Trinh, Trieu H., et al. "Solving Olympiad Geometry Without Human Demonstrations." *Nature* 625 (2024): 476–482. | Code: 18. Romera-Paredes, Bernardino, et al. "Mathematical Discoveries from Program Search with Large Language Models." *Nature* 625 (2024): 468–475. | Code: 19. Garrett, Caelan Reed, et al. "PDDLStream: Integrating Symbolic Planners and Blackbox Samplers via Optimistic Adaptive Planning." *Proceedings of ICAPS*, 2020. | Code: 20. Chitnis, Rohan, et al. "Learning Neuro-Symbolic Skills for Bilevel Planning." *Proceedings of CoRL*, 2022. 21. Hafner, Danijar, et al. "Mastering Diverse Domains through World Models." *International Conference on Learning Representations (ICLR)*, 2024. | Code: 22. Zhang, Zhengyan, et al. "ERNIE: Enhanced Language Representation with Informative Entities." *Proceedings of ACL*, 2019. | Code: 23. Yasunaga, Michihiro, et al. "QA-GNN: Reasoning with Language Models and Knowledge Graphs for Question Answering." *Proceedings of NAACL*, 2021. | Code: 24. Yasunaga, Michihiro, et al. "Deep Bidirectional Language-Knowledge Graph Pretraining." *Advances in Neural Information Processing Systems (NeurIPS)* 35 (2022). | Code: 25. Speer, Robyn, Joshua Chin, and Catherine Havasi. "ConceptNet 5.5: An Open Multilingual Graph of General Knowledge." *Proceedings of AAAI*, 2017. | Data: 26. Sap, Maarten, et al. "ATOMIC: An Atlas of Machine Commonsense for If-Then Reasoning." *Proceedings of AAAI*, 2019. | Data: 27. Bosselut, Antoine, et al. "COMET: Commonsense Transformers for Automatic Knowledge Graph Construction." *Proceedings of ACL*, 2019. | Code: 28. Hwang, Jena D., et al. "COMET-ATOMIC 2020: On Symbolic and Neural Commonsense Knowledge Graphs." *Proceedings of AAAI*, 2021. 29. Krishna, Ranjay, et al. "Visual Genome: Connecting Language and Vision Using Crowdsourced Dense Image Annotations." *International Journal of Computer Vision* 123.1 (2017): 32–73. | Data: 30. Lacroix, Timothée, Guillaume Obozinski, and Nicolas Usunier. "Tensor Decompositions for Temporal Knowledge Base Completion." *International Conference on Learning Representations (ICLR)*, 2020. 31. Lake, Brenden M., and Marco Baroni. "Generalization without Systematicity: On the Compositional Skills of Sequence-to-Sequence Recurrent Networks." *Proceedings of ICML*, 2018. 32. Ma, Yecheng Jason, et al. "Eureka: Human-Level Reward Design via Coding Large Language Models." *Proceedings of ICLR*, 2024. | Code: 33. Jimenez, Carlos E., et al. "SWE-bench: Can Language Models Resolve Real-World GitHub Issues?" *Proceedings of ICLR*, 2024. | Benchmark: 34. Yang, John, et al. "SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering." *arXiv preprint* arXiv:2405.15793 (2024). | Code: 35. Creswell, Antonia, et al. "Selection-Inference: Exploiting Large Language Models for Interpretable Logical Reasoning." *Proceedings of ICLR*, 2023. 36. Singh, Ishika, et al. "ProgPrompt: Generating Situated Robot Task Plans Using Large Language Models." *Proceedings of ICRA*, 2023. | Code: 37. Asai, Masataro, and Alex Fukunaga. "Classical Planning in Deep Latent Space." *Journal of Artificial Intelligence Research* 71 (2021): 1009–1050. arXiv:2107.00110. Code: 38. Asai, Masataro. "Unsupervised Grounding of Plannable First-Order Logic Representation from Images." *Proceedings of the International Conference on Automated Planning and Scheduling (ICAPS)*, 2019. arXiv:1902.08093. 39. Geffner, Tomas, et al. "Deep End-to-end Causal Inference." *Advances in Neural Information Processing Systems* 35 (NeurIPS 2022). arXiv:2202.02195. Code: 40. Lippe, Phillip, et al. "CITRIS: Causal Identifiability from Temporal Interventions in Latent Spaces." *Proceedings of the International Conference on Machine Learning (ICML)*, 2022. arXiv:2202.03169. Code: 41. Pearl, Judea, and Dana Mackenzie. *The Book of Why: The New Science of Cause and Effect*. Basic Books, 2018. ISBN: 978-0465097609. 42. Lightman, Hunter, et al. "Let's Verify Step by Step." *Advances in Neural Information Processing Systems* 37 (NeurIPS 2024). arXiv:2305.20050. Data: 43. Zelikman, Eric, et al. "STaR: Bootstrapping Reasoning With Reasoning." *Advances in Neural Information Processing Systems* 35 (NeurIPS 2022). arXiv:2203.14465. --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://neurosymbolicai.gitbook.io/neuro-symbolic-ai-in-practice/part-iii-core-approaches/chapter-4/4-3-hybrid-architectures/4-3-applications.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.