Pith. sign in

REVIEW 3 major objections 5 minor 1 cited by

Answer Set Networks: Casting Answer Set Programming into Deep Learning

T0 review · 3 major / 5 minor · reviewed 2026-08-11 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read Answer Set Networks compile grounded, tight answer set programs into Reasoning Graphs and solve them with GPU-parallel message passing, outperforming CPU-bound neural-symbolic systems and enabling logic-guided LLM fine-tuning and…

desk verdict The GPU compilation idea is promising, but the model reduction in Eq. 7 is backwards, so the paper's core claim of solving ASP is unsupported. read the letter →

arxiv 2412.14814 v1 pith:LMYJ236P submitted 2024-12-19 cs.AI cs.LGcs.SC

Arseny Skryagin , Daniel Ochs , Phillip Deibert , Simon Kohaut , Devendra Singh Dhami , Kristian Kersting This is my paper · ORCID
classification cs.AIcs.LGcs.SC
keywords AnswerSetProgrammingGraphNeuralNetworksNeural-SymbolicAIDeepProbabilisticLogicReasoningGraphsModelReductionLLMFine-tuningUAVNavigation
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Answer set programming (ASP) lets neural-symbolic systems encode constraints declaratively, but computing stable models is slow and confines the symbolic part to the CPU. The paper proposes Answer Set Networks (ASNs), which compile grounded, tight ASP programs into heterogeneous graphs called Reasoning Graphs, then solve them by batched, GPU-parallel message passing. The authors claim that the fixed point of this message passing, followed by a subset-minimality filter, recovers exactly the program's stable models, and that ASNs outperform CPU-bound neural-symbolic solvers on multiple tasks. They also demonstrate two new applications: logic-guided fine-tuning of large language models that mitigates the Reversal Curse, and large-scale UAV routing under aviation law that renders a $169\,\mathrm{km}^2$ map of Paris. If the claims hold, ASNs would make ASP-based neural-symbolic AI both faster and better integrated with deep learning on modern hardware.

What carries the argument

The central objects are Reasoning Graphs (RGs): heterogeneous graphs with node types for conjunctions, disjunctions, counts, sums, minima, maxima, and the constant nodes $\top$ and $\bot$, with edge weights in $\{-1, 1\}$ for logical edges or term weights for aggregate edges. A grounded ASP program is compiled into an RG element-by-element following the ASP-Core-2 syntax. Solving proceeds in three steps: choice definitization, which instantiates separate graph copies for every combination of disjunctive and choice selections; message passing, in which each node updates its Boolean value from its incoming neighbors according to its type, with aggregate nodes comparing weighted sums or counts against their guards; and model reduction, which filters the resulting interpretations by subset-minimality using bitwise operations so that only the program's stable models remain. The same framework also embeds Neural-Probabilistic Predicates (NPPs) from SLASH, letting neural networks or probabilistic circuits supply atom probabilities inside the program.

What would settle it

Encode a suite of grounded tight answer set programs—including aggregates and choice rules—as Reasoning Graphs, run ASN, and compare its output against a trusted solver such as clingo; any program where ASN returns a non-stable model, misses a stable model, or fails to converge would refute the claimed equivalence.

Watch

Extended reading notes

Core claim

The paper's central claim is that any grounded, tight answer set program can be 'neurally compiled' into a Reasoning Graph—a heterogeneous graph whose nodes stand for atoms, conjunctions, disjunctions, and aggregate literals, with special source and sink nodes $\top$ and $\bot$—and that stable models can be extracted by iterating a Boolean message-passing update until it reaches a fixed point, then discarding all interpretations that are not subset-minimal. Choice and disjunctive rules are handled by 'definitization': generating copies of the graph for each possible selection of disjuncts and solving them all in parallel on the GPU. The authors further claim that this approach is not only a faithful solver but a fast one: on MNIST-Addition it trains epochs up to $3.4\times$ faster than SAME, on the ProMis UAV mission-design problem it is $137\times$ faster than SLASH and $194\times$ faster than ProbLog, and it can fine-tune Llama2-7B with logical constraints to overcome the Reversal Curse.

Load-bearing premise

The load-bearing premise is that the fixed point of the message-passing update, together with the subset-minimal reduction, exactly reproduces the stable-model semantics of every grounded tight answer set program; this equivalence is asserted but not proved.

Editorial extensions

If this is right

  • ASN provides a GPU-parallel path from ASP to neural learning, so neural-symbolic systems can keep the symbolic solver on the same accelerator as the neural network instead of shuttling between CPU and GPU.
  • The ProMis speedups (137× over SLASH, 194× over ProbLog) indicate that large-scale, legal-constraint-aware planning—such as the Paris UAV map rendered in 56 minutes—becomes practical and could extend to real-time re-planning.
  • Logic-guided fine-tuning with ASN reduces the Reversal Curse in LLMs, converging in 9 epochs where an unguided baseline needs 72–96 epochs, suggesting that symbolic constraints can act as a training signal for language models.
  • Because all choice definitives are solved in parallel batches, ASN's speed scales with GPU width, and the paper shows a clear batch-size trade-off between per-epoch time and convergence on MNIST-Addition.
  • The compilation covers the full ASP-Core-2 language, so any tight grounded program expressible in that standard can in principle be solved by ASN.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • If the fixed-point equivalence is formally proved, ASN could serve as a drop-in GPU replacement for traditional solvers on tight ASP domains, enabling high-throughput query answering for robotics, planning, and constraint satisfaction.
  • The same graph construction may be made fully differentiable by replacing Boolean updates with soft logic, allowing end-to-end gradient flow from a loss through the solver into the neural predicates—a direction the paper lists as future work.
  • Choice definitization enumerates all combinations and grows combinatorially with the number of choice rules; sampling or pruning definitives would trade completeness for speed in programs with many choices.
  • The Reversal Curse result is tested only on family relations, so tests on other domains—geographic, scientific, or common-sense knowledge—would show whether logic-guided fine-tuning transfers beyond the paper's setting.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 5 minor

Summary. The paper introduces Answer Set Networks (ASN), a graph-neural-network-based solver for grounded, tight answer set programs. The authors propose a compilation from ASP-Core-2 programs into heterogeneous 'Reasoning Graphs,' a choice-definitization step for disjunctive and choice rules, iterative message passing over the graph, and a model-reduction step intended to select subset-minimal models. The resulting solver is embedded in the SLASH neural-probabilistic programming framework and evaluated on three tasks: abductive fine-tuning of an LLM, probabilistic mission design for UAVs over Paris, and MNIST-Addition. The main claims are that ASN provides GPU-parallel ASP solving and outperforms existing CPU-bound NeSy systems.

Significance. If the central correctness claim were established, the paper would make a useful contribution: a GPU-batched, parallelizable approach to solving tight ground ASP programs within neural-symbolic pipelines, with a concrete implementation, code release, and a first demonstration of DPPL-guided LLM fine-tuning. The experimental results on MNIST-Addition and the Paris-scale ProMis map are suggestive of real practical speedups. However, the paper currently lacks a proof of the equivalence between the proposed message-passing/model-reduction pipeline and stable-model semantics, and the model-reduction formula as written is demonstrably backwards. The strengths are the breadth of the evaluation and the clear presentation of the compilation scheme, but the central solver semantics must be corrected and proven before the performance claims can be accepted.

major comments (3)
  1. [Model Reduction, Eq. (7)] The subset-minimal reduction in Eq. (7) is stated backwards. For two interpretations I_i ⊂ I_j, element-wise conjunction (Eq. (6)) gives m_i ⊗ m_j = m_i, so the retention condition m_i ⊗ m_j ≠ m_i is false and I_i is removed while the superset I_j is kept. For example, on the program `a | b. b.`, the candidates after definitization and message passing include {b} and {a,b}; Eq. (7) drops {b} and returns {a,b}, although the unique stable model is {b}. The correct condition for keeping a model that is not a superset of any other candidate model is m_i ⊗ m_j ≠ m_j for all j (or an equivalent formulation over all pairs, not only j > i). As written, the central claim that ASN returns answer sets is invalidated; the formula must be corrected and a proof supplied that the corrected reduction together with the message-passing fixed points yields exactly the stable models.
  2. [Choice definitization and Message-Passing] There is no theorem or formal argument establishing that the pipeline is sound and complete. In particular, the paper does not prove that (a) enumerating all definitives of disjunctive and choice rules covers exactly the answer sets of the original program, and (b) the fixed point of the Eq. (5) update on a definitive's Reasoning Graph equals the unique stable model of that definitive for tight programs. The text asserts these properties ('The RG representing these definitives can be directly constructed...'), but the equivalence is load-bearing: every experimental result depends on ASN returning the correct stable models. This gap should be closed with a precise statement and proof, or by citing an existing theorem that applies verbatim to this construction.
  3. [Experiments, Q2 (ProMis)] The claimed speedup factors of 194x over ProbLog and 137x over SLASH are not measured at full resolution: the baselines were run on a 500^2 grid and their times linearly extrapolated to the 6500^2 grid, while ASN was run on the full grid. Linear extrapolation of CPU solver time with grid size is an assumption, not a measurement, and the resulting 'three orders of magnitude faster' claim should be either supported by a scaling argument with evidence or qualified as an extrapolation. At minimum, report the measured 500^2 times for all systems, the extrapolation formula, and any observed scaling behavior.
minor comments (5)
  1. [Model Reduction] The index range in Eq. (7) says i ∈ {1,...,n}, but the set being filtered is over interpretations {I_1,...,I_k}; the bound should be k, not n.
  2. [Choice definitization] The sentence 'Each answer set of the original program consists of the program definitives' is unclear and should be reworded; presumably each answer set of the original program corresponds to at least one definitive whose models are subsets of it, or similar.
  3. [Message-Passing, Eq. (5)] The notation g_{v,l} = β_{v,l} ⋄_{v,l} is used as a guard, but its type is not defined; clarify whether it is a Boolean predicate or a relation applied to the aggregated value, and define the comparison operators consistently.
  4. [Appendix B, Listing 1] There is a typo in the query atom 'daugther' (line 31), and the query constraints use 'not relation(p1,p2,<relation>)' while the body rules use relation(X1,X2,<relation>); please align the naming and check the spelling.
  5. [Figure 5b] The caption states that ASN 'renders Paris in 56m,' but the color scale and coordinate reference for the map are not described; add a legend and clarify whether the colored areas correspond to probability thresholds.

Circularity Check

0 steps flagged · score 2.0 of 10

No load-bearing circularity; Eq. 7 is a correctness concern, not a circular one, and SLASH self-citations are non-load-bearing.

full rationale

The derivation is not circular. The ASN pipeline is defined against the input ASP program: neural compilation maps ASP-Core-2 constructs into Reasoning Graphs, Eq. 5 is a synchronous fixed-point propagation rule, and Eq. 7 is an attempted subset-minimality filter over the produced interpretations. No parameter is fitted to target answer sets and then renamed as a prediction; experimental runtimes and accuracies are measured against external benchmarks (ProbLog, DeepProbLog, clingo-based SLASH, MNIST-Addition) rather than read back from the method's own definitions. Self-citations are present (SLASH for NPP semantics, SAME and ProMis as baselines) but they supply the surrounding NeSy/DPPL machinery, not the justification for the central solver claim, so they are not load-bearing in the circularity sense. The paper does omit a proof that fixed points of Eq. 5 on the definitives plus the Eq. 7 reduction equal stable-model semantics; moreover, Eq. 7 as written appears to keep supersets rather than minimal subsets, which would be a correctness/completeness flaw. That is distinct from circularity: the reduction is asserted, not derived from itself, and an external clingo comparison could falsify it. Score 2 only marks the minor non-load-bearing self-citations.

Assumptions & free parameters 0 free parameters · 4 assumptions · 0 invented entities

The solver relies on four assumptions: programs must be grounded and tight, message passing computes stable-model semantics (unproved), choice definitization enumerates all alternatives, and SLASH's NPP semantics are inherited. The first and third bound applicability; the second is the main correctness risk.

assumptions (4)
  • domain assumption Grounded tightness is required: ASN only solves variable-free, acyclic ASP programs.
    Section "Casting Answer Set Programs into GNNs": "ASN expects a grounded, i.e., variable-free and tight (acyclic) ASP-program, Π." This excludes most real-world ASP programs unless an external grounder and tightness check are applied, and the paper does not evaluate grounding cost.
  • ad hoc to paper Message-passing fixed point equals stable-model semantics.
    The update equations (Eq. 5) and model reduction (Eq. 7) are claimed to yield stable models, but no theorem or proof is supplied. This is the central correctness assumption of the solver.
  • ad hoc to paper Choice definitization enumerates all possible choices and is complete.
    Section "Choice definitization" states all combinations of disjunctive, choice, and NPP rules must be considered; the paper does not prove completeness or bound the number of instances. The method's scalability depends on this enumeration not exploding.
  • domain assumption NPP semantics from SLASH are inherited unchanged.
    The paper imports Neural-Probabilistic Predicates from prior work by the same group (Skryagin et al. 2022, 2023) and relies on that semantics for probabilistic inference; no independent re-derivation is given.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Answer Set Networks: Casting Answer Set Programming into Deep Learning." pith.science (2026). https://pith.science/paper/LMYJ236P

@misc{pith2026241214814,
  author       = {Pith},
  title        = {Pith review of: Answer Set Networks: Casting Answer Set Programming into Deep Learning},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/LMYJ236P}},
  note         = {Machine review of arXiv:2412.14814}
}
read the original abstract

Although Answer Set Programming (ASP) allows constraining neural-symbolic (NeSy) systems, its employment is hindered by the prohibitive costs of computing stable models and the CPU-bound nature of state-of-the-art solvers. To this end, we propose Answer Set Networks (ASN), a NeSy solver. Based on Graph Neural Networks (GNN), ASNs are a scalable approach to ASP-based Deep Probabilistic Logic Programming (DPPL). Specifically, we show how to translate ASPs into ASNs and demonstrate how ASNs can efficiently solve the encoded problem by leveraging GPU's batching and parallelization capabilities. Our experimental evaluations demonstrate that ASNs outperform state-of-the-art CPU-bound NeSy systems on multiple tasks. Simultaneously, we make the following two contributions based on the strengths of ASNs. Namely, we are the first to show the finetuning of Large Language Models (LLM) with DPPLs, employing ASNs to guide the training with logic. Further, we show the "constitutional navigation" of drones, i.e., encoding public aviation laws in an ASN for routing Unmanned Aerial Vehicles in uncertain environments.

Figures

Figures reproduced from arXiv: 2412.14814 by the authors.

Figure 1
Figure 1. ASN solving process: ASN takes a grounded ASP program as input and translates it into an equivalent Reasoning Graph via neural compilation. The RG instances representing all possible choice selections are constructed in the definitization stage, to be iteratively solved in parallel using message passing. Finally, the resulting models are reduced to yield the ASP’s stable models. swer Set Networks (ASN)12. Within ASN… view at source ↗
Figure 2
Figure 2. Building Blocks of any Reasoning Graph: We depict nine distinct elements to compile any ground ASP program into an RG. In the following, we introduce ASNs and how every el￾ement of the ASP-Core-2 language (Calimeri et al. 2020) can, by our neural-compilation process, be translated into an equivalent RG. Afterward, we explain how truth value propagation via message passing is used to obtain the stable models from the… view at source ↗
Figure 3
Figure 3. Neural Compilation of ASP-Core-2 Elements into RG: For each element of the ASP syntax, we generate the equivalent Reasoning Graph (RG) representation encoded as GNN. The graphs are generated automatically from grounded ASP-programs. From left to right, some building-blocks of the overall RG are: i) facts, ii) disjunctive facts, iii) aggregate literal, iv) rule, v) constraint, vi) classical negation, vii) choice rule… view at source ↗
Figures from the paper (6 more)
Figure 4
Figure 4. Figure 4: Example of Neural-Probabilistic Predicate: img(i). #npp(digit(i), [0, 1, 2]) :− img(i). classical atoms. If ⊥ is true for some graph instance, then the corresponding interpretation is not a model. However, the interpretation does not equate to a stable model of the ori…
Figure 5
Figure 5. Figure 5: ASN on Abductive Fine-Tuning of LLMs and ProMis over Paris during the Olympics. [PITH_FULL_IMAGE:figures/full_fig_p006_5.png]
Figure 6
Figure 6. Figure 6: Visualization ProMis Paris in full size [PITH_FULL_IMAGE:figures/full_fig_p010_6.png]
Figure 7
Figure 7. Figure 7: Reasoning Graph for LLM Fine-Tuning with ASN: We query for all four possible relationship types among two persons and pick the one with the highest probability [PITH_FULL_IMAGE:figures/full_fig_p012_7.png]
Figure 8
Figure 8. Figure 8: Reasoning Graph for ProMis on Paris: Only one grid point is listed as query for the RG to become easily displayable [PITH_FULL_IMAGE:figures/full_fig_p013_8.png]
Figure 9
Figure 9. Figure 9: Reasoning Graph for MNIST-Addition: The number of classes was restricted to [0, 1, 2] for the RG to become easily displayable [PITH_FULL_IMAGE:figures/full_fig_p014_9.png]

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. Streamliners for Answer Set Programming

    cs.LO 2026-04 unverdicted novelty 7.0 of 10

    LLM-proposed streamliner constraints for ASP encodings, filtered and combined via virtual best selection, deliver up to 4-5x speedups on three competition benchmarks.

Reference graph

Works this paper leans on

36 extracted references · 31 canonical work pages · cited by 1 Pith paper

  1. [1]

    , " * write output.state after.block = add.period write newline

    ENTRY address archivePrefix author booktitle chapter edition editor eid eprint howpublished institution isbn journal key month note number organization pages publisher school series title type volume year label extra.label sort.label short.list INTEGERS output.state before.all mid.sentence after.sentence after.block FUNCTION init.state.consts #0 'before.a...

  2. [2]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION word.in bbl.in capitalize " " * FUNCT...

  3. [3]

    Alviano, M.; Calimeri, F.; Dodaro, C.; Fusc \`a , D.; Leone, N.; Perri, S.; Ricca, F.; Veltri, P.; and Zangari, J. 2017. The ASP System DLV2. In Logic Programming and Nonmonotonic Reasoning

    work page 2017

  4. [4]

    Antol, S.; Agrawal, A.; Lu, J.; Mitchell, M.; Batra, D.; Lawrence Zitnick, C.; and Parikh, D. 2015. VQA: Visual Question Answering. CVPR

    work page 2015

  5. [5]

    C.; Korbak, T.; and Evans, O

    Berglund, L.; Tong, M.; Kaufmann, M.; Balesni, M.; Stickland, A. C.; Korbak, T.; and Evans, O. 2024. The Reversal Curse: LLMs trained on ``A is B'' fail to learn ``B is A'' . arXiv:2309.12288

    arXiv 2024

  6. [6]

    Calimeri, F.; Faber, W.; Gebser, M.; Ianni, G.; Kaminski, R.; Krennwallner, T.; Leone, N.; Maratea, M.; Ricca, F.; and Schaub, T. 2020. ASP-Core-2 Input Language Format. Theory and Practice of Logic Programming, 20: 294--309

    work page 2020

  7. [7]

    Choi, Y.; Vergari, A.; and Van den Broeck, G. 2020. Probabilistic Circuits: A Unifying Framework for Tractable Probabilistic Models. In AAAI

    work page 2020

  8. [8]

    Darwiche, A. 2011. SDD: A New Canonical Representation of Propositional Knowledge Bases. In IJCAI

    work page 2011

Show all 36 references
  1. [9]

    Davis, M.; Logemann, G.; and Loveland, D. 1962. A machine program for theorem-proving. Communications of the ACM

    1962

  2. [10]

    Dechter, R.; and Meiri, I. 1990. Network-based heuristics for constraint-satisfaction problems. Artificial Intelligence

    1990

  3. [11]

    Fazekas, K.; Bacchus, F.; and Biere, A. 2018. Implicit Hitting Set Algorithms for Maximum Satisfiability Modulo Theories. IJCAR

    2018

  4. [12]

    V.; Renkens, J.; Shterionov, D

    Fierens, D.; den Broeck, G. V.; Renkens, J.; Shterionov, D. S.; Gutmann, B.; Thon, I.; Janssens, G.; and Raedt, L. D. 2015. Inference and learning in probabilistic logic programs using weighted Boolean formulas. Theory Pract. Log. Program., 15(3): 358--401

    2015

  5. [13]

    Flade, B.; Kohaut, S.; and Eggert, J. 2021. Error Decomposition for Hybrid Localization Systems. In 2021 IEEE International Intelligent Transportation Systems Conference (ITSC), 149--156. IEEE

    2021

  6. [14]

    Gebser, M.; Kaufmann, B.; Kaminski, R.; Ostrowski, M.; Schaub, T.; and Schneider, M. 2011. Potassco: The Potsdam Answer Set Solving Collection. AI C ommunications

    2011

  7. [15]

    Gutmann, B.; Jaeger, M.; and Raedt, L. D. 2010. Extending ProbLog with Continuous Distributions. In Inductive Logic Programming - 20th International Conference, ILP 2010, Florence, Italy, June 27-30, 2010. Revised Papers , volume 6489 of Lecture Notes in Computer Science, 76--...

    2010

  8. [16]

    J.; Kullmann, O.; and Marek, V

    Heule, M. J.; Kullmann, O.; and Marek, V. W. 2015. Solving and Verifying the Boolean Pythagorean Triples Problem via Cube-and-Conquer. SAT

    2015

  9. [17]

    J.; Shen, Y.; Wallis, P.; Allen-Zhu, Z.; Li, Y.; Wang, S.; Wang, L.; and Chen, W

    Hu, E. J.; Shen, Y.; Wallis, P.; Allen-Zhu, Z.; Li, Y.; Wang, S.; Wang, L.; and Chen, W. 2021. LoRA: Low-Rank Adaptation of Large Language Models. arXiv:2106.09685

    2021 arXiv

  10. [18]

    Huang, J.; Li, Z.; Chen, B.; Samel, K.; Naik, M.; Song, L.; and Si, X. 2021. Scallop: From Probabilistic Deductive Databases to Scalable Differentiable Reasoning. In Advances in Neural Information Processing Systems 34: Annual Conference on Neural Information Processing Systems

    2021

  11. [19]

    Johnson, J.; Hariharan, B.; van der Maaten, L.; Fei-Fei, L.; Lawrence Zitnick, C.; and Girshick, R. 2017. CLEVR: A Diagnostic Dataset for Compositional Language and Elementary Visual Reasoning. CVPR

    2017

  12. [20]

    Kimmig, A.; Van den Broeck, G.; and De Raedt, L. 2017. Algebraic model counting. Journal of Applied Logic

    2017

  13. [21]

    S.; Eggert, J.; and Kersting, K

    Kohaut, S.; Flade, B.; Dhami, D. S.; Eggert, J.; and Kersting, K. 2023. Mission Design for Unmanned Aerial Vehicles using Hybrid Probabilistic Logic Programs. In 26th IEEE International Intelligent Transportation Systems Conference (ITSC)

    2023

  14. [22]

    LeCun, Y.; Bottou, L.; Bengio, Y.; and Haffner, P. 1998. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86: 2278--2324

    1998

  15. [23]

    Li, F. 2021. Graph Based Answer Set Programming Solver Systems. In Proceedings 37th International Conference on Logic Programming (Technical Communications), ICLP Technical Communications 2021, Porto (virtual event), 20-27th September 2021 , 276--285

    2021

  16. [24]

    Manhaeve, R.; Dumancic, S.; Kimmig, A.; Demeester, T.; and Raedt, L. D. 2018. Deep P rob L og: Neural Probabilistic Logic Programming. In Advances in Neural Information Processing Systems 31: Annual Conference on Neural Information Processing Systems

    2018

  17. [25]

    Marino, K.; Rastegari, M.; Farhadi, A.; and Mottaghi, R. 2019. OK-VQA: A Visual Question Answering Benchmark Requiring External Knowledge. CVPR

    2019

  18. [26]

    P.; and Sakallah, K

    Marques-Silva, J. P.; and Sakallah, K. A. 1996. GRASP—a new search algorithm for satisfiability. In ICCAD

    1996

  19. [27]

    Nerdimite. 2022. Neuro-Symbolic AI for Visual Question Answering. GitHub Repository

    2022

  20. [28]

    Patrinopoulou, N.; Lappas, V.; Daramouskas, I.; Meimetis, D.; and Kostopoulos, V. 2023. Autonomy in UAV Civilian Applications. In Autonomous Vehicles. IntechOpen

    2023

  21. [29]

    Sang, T.; Beame, P.; and Kautz, H. 2005. Performing Bayesian inference by weighted model counting. NCAI

    2005

  22. [30]

    Schwenk, D.; Khandelwal, A.; Clark, C.; Marino, K.; and Mottaghi, R. 2022. A-OKVQA: A Benchmark for Visual Question Answering Using World Knowledge. CVPR

    2022

  23. [31]

    Skryagin, A.; Ochs, D.; Singh Dhami, D.; and Kersting, K. 2023. Scalable Neural-Probabilistic Answer Set Programming. In Journal of Artificial Intelligence Research, volume 78, 579--617

    2023

  24. [32]

    S.; and Kersting, K

    Skryagin, A.; Stammer, W.; Ochs, D.; Dhami, D. S.; and Kersting, K. 2022. Neural-Probabilistic Answer Set Programming. In Proceedings of the 19th International Conference on Principles of Knowledge Representation and Reasoning

    2022

  25. [33]

    Stenger, A.; Fernando, B.; and Heni, M. 2013. Route Planning for Unmanned Aerial Vehicles. Deutscher Luft- und Raumfahrtkongress

    2013

  26. [34]

    Touvron, H.; Martin, L.; Stone, K.; Albert, P.; Almahairi, A.; Babaei, Y.; Bashlykov, N.; Batra, S.; Bhargava, P.; Bhosale, S.; Bikel, D.; Blecher, L.; Canton, C.; Chen, M.; Cucurull, G.; Esiobu, D.; Fernandes, J.; Fu, J.; Fu, W.; Fuller, B.; Gao, C.; Goswami, V.; Goyal, N.; H...

    2023 arXiv

  27. [35]

    H.; Wu, Y.; Le, Q

    Trinh, T. H.; Wu, Y.; Le, Q. V.; He, H.; and Luong, T. 2024. AlphaGeometry: Solving Olympiad Geometry without Human Demonstrations. Nature

    2024

  28. [36]

    Yang, Z.; Ishay, A.; and Lee, J. 2020. NeurASP : Embracing Neural Networks into Answer Set Programming. In Proceedings of the Twenty-Ninth International Joint Conference on Artificial Intelligence

    2020

Pith tools

Reviewed August 11, 2026 · model on record in the stance chip above.