> 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-iv-synthesis/chapter-5/5-4-practitioners-guide.md).

# 5.4 Practitioner's Guide: Where to Start

This section provides concrete starting points for practitioners working in different settings.

## If You Are Starting from a Neural Model

You have a working neural model and want to add neuro-symbolic guarantees.

**Step 1:** Identify what the model gets wrong. Audit failure cases: are violations of domain knowledge (physical impossibility, logical inconsistency, constraint violation) present? If yes, proceed to Step 2.

**Step 2:** Encode the violated knowledge as symbolic constraints. Use the Semantic Loss framework (Section 4.1.1) for soft constraints, or a projection layer for hard constraints. If the constraints are physical laws, use PINNs.

**Step 3:** Evaluate the constraint satisfaction rate and downstream task performance. Iterate on constraint specification.

**Tools:** PyTorch + Semantic Loss library (<https://github.com/UCLA-StarAI/Semantic-Loss>), LTN (<https://github.com/logictensornetworks/logictensornetworks>).

## If You Are Starting from a Symbolic System

You have a working formal planner, theorem prover, or constraint solver and want to improve its performance with neural components.

**Step 1:** Profile the solver. Identify the computational bottleneck: is it heuristic computation? Search tree pruning? Variable ordering? If yes to any, proceed to Step 2.

**Step 2:** Generate training data by running the symbolic system on representative problem instances. Train a neural network (GNN for graph-structured problems, MLP for feature-vector problems) to predict the bottleneck function (heuristic value, variable importance, etc.).

**Step 3:** Replace the symbolic bottleneck with the neural approximation, with the symbolic oracle still running in the background for correctness checking. Evaluate speedup vs. quality degradation.

**Tools:** Fast Downward (fast-downward.org) + custom neural heuristic integration, Lean 4 + Tactician (supervised learning over proof state embeddings for tactic suggestion), SHOP3 for HTN.

## If You Are Starting from Scratch

You are designing a new system and want to choose the right neuro-symbolic architecture.

Use the decision guide in **Chapter 6**. The four qualifying questions, answered in order:

| Question                                                            | YES                                                           | NO                                                           |
| ------------------------------------------------------------------- | ------------------------------------------------------------- | ------------------------------------------------------------ |
| Do you need provably correct outputs?                               | You need a symbolic verifier in the loop — proceed to Q2      | Pure neural may suffice — evaluate §4.4.2 or standard DL     |
| Is your symbolic component the bottleneck?                          | §4.2 Neural Helps Symbolic — accelerate the oracle            | Proceed to Q3                                                |
| Can domain knowledge be expressed as constraints on neural outputs? | §4.1 Symbolic Helps Neural — add constraint layers            | §4.3 Hybrid Co-Processing — bidirectional loop required      |
| Is the domain safety-critical?                                      | Hard constraint layers are mandatory (projection layers, CBF) | Soft constraints (Semantic Loss, regularization) may suffice |

## Recommended Starting Tools and Libraries

| Task                                   | Tool                                | URL                                                                                                              |
| -------------------------------------- | ----------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
| PDDL planning                          | Fast Downward                       | [fast-downward.org](https://fast-downward.org)                                                                   |
| Python-native planning                 | Pyperplan                           | [github.com/aibasel/pyperplan](https://github.com/aibasel/pyperplan)                                             |
| HTN planning                           | SHOP3                               | [github.com/shop-planner/shop3](https://github.com/shop-planner/shop3)                                           |
| Differentiable reasoning               | LTN                                 | [github.com/logictensornetworks/logictensornetworks](https://github.com/logictensornetworks/logictensornetworks) |
| Neural-probabilistic logic             | DeepProbLog                         | [github.com/ML-KULeuven/deepproblog](https://github.com/ML-KULeuven/deepproblog)                                 |
| Semantic loss                          | UCLA StarAI                         | [github.com/UCLA-StarAI/Semantic-Loss](https://github.com/UCLA-StarAI/Semantic-Loss)                             |
| KG construction + RAG                  | GraphRAG                            | [github.com/microsoft/graphrag](https://github.com/microsoft/graphrag)                                           |
| Formal proof assistant                 | Lean 4                              | [leanprover.github.io](https://leanprover.github.io)                                                             |
| LLM-to-PDDL                            | LLM+P                               | [github.com/Cranial-XIX/llm-pddl](https://github.com/Cranial-XIX/llm-pddl)                                       |
| Autonomous agent pattern               | ReAct                               | [github.com/ysymyth/ReAct](https://github.com/ysymyth/ReAct)                                                     |
| Scalable differentiable reasoning      | Scallop                             | [github.com/scallop-lang/scallop](https://github.com/scallop-lang/scallop)                                       |
| Classical ILP (interpretable programs) | Popper                              | [github.com/logic-and-learning-lab/Popper](https://github.com/logic-and-learning-lab/Popper)                     |
| ASP + neural integration               | NeurASP                             | [github.com/azreasoners/NeurASP](https://github.com/azreasoners/NeurASP)                                         |
| TAMP (task + motion planning)          | PDDLStream                          | [github.com/caelan/pddlstream](https://github.com/caelan/pddlstream)                                             |
| World model planning                   | DreamerV3                           | [github.com/danijar/dreamerv3](https://github.com/danijar/dreamerv3)                                             |
| LLM agent tree search                  | LATS                                | [github.com/andyz245/LanguageAgentTreeSearch](https://github.com/andyz245/LanguageAgentTreeSearch)               |
| Verbal RL agent loop                   | Reflexion                           | [github.com/noahshinn/reflexion](https://github.com/noahshinn/reflexion)                                         |
| Differentiable abstract interpretation | LDT (Lattice Deduction Transformer) | [arxiv.org/abs/2605.08605](https://arxiv.org/abs/2605.08605)                                                     |

***

## Further Reading

The following resources provide depth beyond this book's scope, organized by practitioner track:

**Track 1 — Neuro-Symbolic AI Foundations**

* Hitzler, Pascal, and Md Kamruzzaman Sarker, eds. *Neuro-Symbolic Artificial Intelligence: The State of the Art*. IOS Press, 2022. — The definitive academic reference; covers probabilistic logic, differentiable reasoning, and KG-neural integration in depth.
* Garcez, Artur d'Avila, and Luís C. Lamb. "Neurosymbolic AI: The 3rd Wave." *Artificial Intelligence Review* 56 (2023). — Accessible survey of the field's intellectual history and current state.
* LAMDA-NeSy Awesome LLM Reasoning with NeSy: <https://github.com/LAMDA-NeSy/Awesome-LLM-Reasoning-with-NeSy> — Community-maintained, continuously updated paper list.

**Track 2 — Classical AI Planning**

* Ghallab, Malik, Dana Nau, and Paolo Traverso. *Automated Planning: Theory and Practice*. Morgan Kaufmann, 2004. — The standard textbook; covers STRIPS, PDDL, HTN, and MDP planning in full technical depth.
* planning.wiki: <https://planning.wiki> — Community reference for planners, competition results, and domain libraries.

**Track 3 — World Models and Physical AI**

* LeCun, Yann. "A Path Towards Autonomous Machine Intelligence." *OpenReview*, 2022. — The JEPA program's foundational manifesto; essential for understanding §4.4.2.
* Terver, Basile, et al. "What Drives Success in Physical Planning with JEPA World Models." *TMLR*, 2026. — The engineering design guide for JEPA-WM practitioners.

**Track 4 — Formal Verification**

* Lean 4 community documentation: <https://leanprover.github.io> — Starting point for Lean 4 and mathlib.
* Marabou neural network verifier: <https://github.com/NeuralNetworkVerification/Marabou> — Tool for verifying neural component safety properties before deployment.

**Track 5 — Mathematical Reasoning and Self-Improvement**

* Zelikman, Eric, et al. "STaR: Bootstrapping Reasoning With Reasoning." *NeurIPS 2022*. arXiv:2203.14465. — The foundational self-improvement loop: generate rationales, filter by correctness oracle, fine-tune; see §4.1.
* Lightman, Hunter, et al. "Let's Verify Step by Step." *NeurIPS 2024*. arXiv:2305.20050. — Establishes that step-level process supervision (PRM) significantly outperforms outcome supervision on the MATH dataset; releases the PRM800K dataset; see §4.3.14.

***

## 5.5 Closing Argument

The history of AI is punctuated by pendulum swings between neural and symbolic approaches. Each swing leaves the field stronger, because each approach reveals the inadequacies that the other addresses.

The neuro-symbolic synthesis described in this book is not another swing of the pendulum. It is the recognition that both approaches are correct — in different regimes, at different levels of the system stack, for different problem properties. The right question is not "neural or symbolic?" but "which component handles which subproblem, and what is the interface between them?"

The systems described in this book — from Remote Agent's 1999 mission to AlphaProof's 2024 IMO performance, from STRIPS-HGN to GraphRAG, from Voyager's skill library to PLOI's learned relevance filters — share a common principle: *formal structure enables reliable behavior*. The neural component can be powerful and approximate; the symbolic component verifies that what matters is correct.

This is the engineering principle that makes neuro-symbolic AI not a research curiosity but a deployment necessity. As AI systems take on tasks where failure is costly — medical diagnosis, infrastructure control, autonomous vehicles, scientific discovery — the combination of neural flexibility and symbolic rigor is not optional. It is the architecture of trustworthy intelligence.

***

## References

1. Kambhampati, Subbarao. "Can Large Language Models Reason and Plan?" *Annals of the New York Academy of Sciences* 1534 (2024): 15–18. <https://arxiv.org/abs/2403.04121>
2. Valmeekam, Karthik, et al. "PlanBench: An Extensible Benchmark for Evaluating Large Language Models on Planning and Reasoning about Change." *NeurIPS 2023*. <https://arxiv.org/abs/2206.10498> | Benchmark: <https://github.com/karthikv792/LLMs-Planning>
3. Garcez, Artur d'Avila, and Luís C. Lamb. "Neurosymbolic AI: The 3rd Wave." *Artificial Intelligence Review* 56 (2023): 12387–12406. <https://doi.org/10.1007/s10462-023-10448-w>
4. Sheth, Amit, Kaushik Roy, and Manas Gaur. "Neurosymbolic Artificial Intelligence (Why, What, and How)." *IEEE Intelligent Systems* 38.3 (2023): 56–62. <https://doi.org/10.1109/MIS.2023.3234994>
5. Katz, Guy, et al. "The Marabou Framework for Verification and Analysis of Deep Neural Networks." *Computer Aided Verification (CAV)*, 2019. <https://arxiv.org/abs/1903.06243> | Code: <https://github.com/NeuralNetworkVerification/Marabou>
6. Wang, Shiqi, Huan Zhang, et al. "Beta-CROWN: Efficient Bound Propagation with Per-neuron Split Constraints for Complete and Incomplete Neural Network Robustness Verification." *Advances in Neural Information Processing Systems (NeurIPS)* 34 (2021). <https://arxiv.org/abs/2103.06624> | Code: <https://github.com/huanzhang12/alpha-beta-CROWN>
7. Aineto, Diego, Sergio Jiménez, and Eva Onaindia. "Learning STRIPS Action Models with Classical Planning." *Proceedings of ICAPS*, 2019. <https://arxiv.org/abs/1903.09824>
8. Pearl, Judea, and Dana Mackenzie. *The Book of Why: The New Science of Cause and Effect*. Basic Books, 2018.
9. Schölkopf, Bernhard, et al. "Towards Causal Representation Learning." *Proceedings of the IEEE* 109.5 (2021): 612–634. <https://arxiv.org/abs/2102.11107>
10. Sharon, Guni, et al. "Conflict-Based Search for Optimal Multi-Agent Pathfinding." *Artificial Intelligence* 219 (2015): 40–66. <https://doi.org/10.1016/j.artint.2014.11.006>
11. OpenAI. "Learning to Reason with LLMs." *OpenAI Blog*, September 2024. <https://openai.com/index/learning-to-reason-with-llms/>


---

# 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-iv-synthesis/chapter-5/5-4-practitioners-guide.md?ask=<question>&goal=<endgoal>
```

`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.