Pith. sign in

REVIEW 3 major objections 4 minor 299 references

Requiring a separate domain-knowledge graph to entail every step of an LLM-proposed vulnerability path lifts pooled entailment from 78% to 98% across three CWE classes, four LLMs, three prompting strategies, and seven binaries.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

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

T0 review · deepseek-v4-flash

2026-08-04 21:26 UTC pith:Y7UXWLAN

load-bearing objection Genuinely new formalization of LLM path verification, but the headline 78→98% gain is heavily confounded by the +DK condition injecting the verifier's own vocabulary into the prompt; deserves a serious referee though the experimental design needs rework. the 3 major comments →

arxiv 2608.01763 v1 pith:Y7UXWLAN submitted 2026-08-03 cs.CR cs.AIcs.LOcs.SE

EntailLLM: Verifying LLM-Generated Vulnerability Discovery Paths with Domain Knowledge via Logic Programming

Kaustuv Mukherji , Jaikrishna Manojkumar Patil , Colton Payne , Paulo Shakarian , Dana Warmsley , Nigel Stepp , Evelyn Kim This is my paper
classification cs.CR cs.AIcs.LOcs.SE
keywords LLM vulnerability analysisentailment checkingtemporal annotated logicdomain knowledge graphbinary decompilation analysismedical device firmware securitylogic programming verificationCWE weakness classes
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

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

EntailLLM claims that the way to make large language models reliable in vulnerability discovery is not to score or clean their output, but to treat each proposed analyst path as a hypothesis that a logic-based reasoner must prove. The path is a chain of code blocks in the binary's call graph; the proof is checked against a separate domain-knowledge graph encoding what is known about the vulnerability class, under temporal annotated logic whose deduction is exact and polynomial-time. Across three CWE classes, four LLMs, three prompting strategies, and seven binaries from 405 to 12,696 call-graph nodes, domain knowledge raises pooled entailment from 78% to 98%, decreasing in only 3 of 94 configurations. The strongest configuration, self-refinement paired with domain knowledge, raises the entailment rate from 71% to 97.4% while increasing the number of entailed paths by 37%. Because the system is deployed on real medical-device firmware and reaches 98% entailment without per-device tuning, the claim matters for safety-critical settings where a plausible-sounding but unsupported LLM inference can send an analyst or a fuzzer down the wrong path.

Core claim

The central claim is that each LLM-proposed analyst path through a binary should be verified as a hypothesis before use: the path is encoded as temporal annotated facts, and a step is entailed only if the domain-knowledge program, a fixed set of 42 rules over graphs of 105–188 entities and 232–403 relations per weakness class, can chain from observed libc labels through knowledge-graph relations to license the analyst's move at that time point. Because generalized annotated logic computes its minimal model exactly in polynomial time, entailment is a proof, not a heuristic score: every accepted path is logically entailed by the encoded domain knowledge, and every rejection reports the first u

What carries the argument

Cross-graph entailment under temporal annotated logic. Generalized annotated logic attaches an interval [l, u] ⊆ [0,1] to each literal and treats unobserved literals as merely uncertain rather than false, so the partial, noisy observations a decompiler recovers from a stripped binary need not be forced to true or false. Time is explicit: the analyst is asserted at a code block at a time point, and rules carry a delay Δt. The path under test is a chain in the binary's call graph; the constraints live in a separate domain-knowledge graph of 105–188 entities and 232–403 relations per weakness class. Verification aligns the two: one of six traversal rules licenses a step only when a knowledge-gr

Load-bearing premise

The load-bearing premise, stated explicitly in the paper, is that the domain-knowledge graphs and the 42 hand-written logic rules are correct and fixed; if that semantics is wrong or incomplete, a high entailment rate only measures conformance to the authors' model, not real-world vulnerability behavior.

What would settle it

The decisive test is ground-truth reach: run the pipeline on a labeled corpus with confirmed vulnerabilities and compare how often entailed versus rejected paths actually arrive at a vulnerable function or call site. Matching rates would show that the 98% measures consistency with the authors' domain model, not real discovery. A cheaper check: randomize the domain graph's relation edges while keeping its structure and see whether the +DK gain survives; if a random graph still entails most paths, the filter is mostly structural.

Watch this falsifier. Get emailed when new claim-graph text bears on it.

Share X Bluesky LinkedIn Reddit HN

If this is right

  • Surviving paths are provably entailed by the encoded domain knowledge, so a human auditor gets an exact reasoning trace for every rejection — the first unsupported step plus the rule firings — rather than a confidence score.
  • Domain knowledge helps most where the unaided LLM is weakest: on medical-device binaries, self-refinement alone entails only 60.9% of realized paths, yet paired with domain knowledge it becomes the strongest configuration, raising pooled entailment to 97.4% and increasing the number of entailed paths by 37% (1,054 to 1,445).
  • The gain transfers without per-device tuning: real-device binaries start lower unaided (71.4% vs 84.4%) but converge to 98.0%, statistically indistinguishable from the 97.8% of standard binaries; a one-sided Wilcoxon test over 94 paired configurations gives p < 10^-10.
  • The filter is selective but not destructive: entailment improves in 59 of 94 configurations, is unchanged in the 32 that were already at 100%, and decreases in only 3, so requiring domain entailment removes spurious paths without discarding much useful output.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The same alignment machinery could be pointed at source-level call graphs and at organizational security rules or coding standards instead of CWE classes; the authors name source-code analysis as future work, and nothing in the logic binds it to binaries.
  • If rejected paths are fed to a corrector that produces minimal-edit entailed alternatives — a module the authors list as planned — the reasoner would act as a teacher, letting the model internalize the domain vocabulary from its own concrete mistakes.
  • The appendix observes that unaided LLM entailment is ordered almost exactly like random sampling, hinting that permissiveness of the domain graph may shape baseline scores; a way to test this is to replace the DKG's relation edges with randomized ones and ask whether the +DK gain survives.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

3 major / 4 minor

Summary. EntailLLM proposes to verify LLM-generated analyst traversal paths through a binary's function call graph by checking entailment against a separate CWE-specific domain-knowledge graph in temporal annotated logic. The system consists of a Ghidra-based labeled call graph, prompt-based LLM path-template generation, beam-search realization, and a PyReason logical verifier using 42 hand-written rules and DKG graphs. The evaluation reports that adding domain knowledge to the generator (+DK) raises pooled entailment from 78.0% to 97.9% across four LLMs, three prompting strategies, and seven/eight binaries, with decreases in only 3 of 94 configurations; the effect is accompanied by a random baseline and stability runs. The paper also describes deployment on three medical-device firmware binaries. The main quantitative claim is confounded because +DK injects into the prompt the same derived DKG vocabulary that the verifier's traversal rules use to establish entailment.

Significance. If the 78→98% effect were attributable to the logical verification layer, the contribution would be significant: it would be a deployable, explainable mechanism for rejecting LLM-proposed vulnerability exploration paths, with formal generalized-annotated-logic semantics, exact polynomial-time deduction inherited from prior work, per-configuration tables, a random baseline showing LLM paths exceed chance, full prompt templates and logic rules in the appendix, and an open-source reasoner (PyReason). Those strengths are real and should be preserved. However, as it stands the headline comparison does not isolate the verifier's contribution. Entailment is defined relative to the authors' own DKG and rules, which are assumed correct, so high entailment is internal consistency, not validated vulnerability relevance. The paper is honest about this limitation. With additional controlled experiments and external validation, the framework could be a useful contribution; the current evidence is insufficient.

major comments (3)
  1. [Section 3 (Step 1), Appendix J.5, Appendix H.1] The +DK manipulation changes the generator rather than isolating the verifier. Appendix J.5 states that +DK appends to each label group the DKG concepts derived by running the mapping rules over that block's raw libc labels. The six traversal rules in Appendix H.1 then entail a step whenever hasLabel(CB1,Lc), hasLabel(CB2,Le), stepFrom(CB1,CB2), and any one of six relations connects Lc and Le. Consequently, if the LLM writes a stage using an injected concept such as missing_bounds_check, the reasoner will derive that same hasLabel fact from the block's raw labels (provided the mapping rule fires), and with DKG graphs of 232-403 relations plus transitive closure, most adjacent injected pairs will have some connecting relation. A path that reuses the injected vocabulary is therefore entailed almost by construction. The J.5 remark that injected labels are 'not entailment verdicts' is techni
  2. [Section 2, Section 3 (Domain Knowledge), Appendix K, Section 6] Entailment is a relation to the authors' own program: the 42 rules and the 105-188-entity DKG graphs are assumed correct and fixed, as stated in Section 3 and Appendix K. Thus a 98% entailment rate establishes that paths conform to the authors' model of CWE-121/415/416, not that they correspond to real vulnerability-relevant behavior. Since Section 6 states that only logical entailment is measured and that validated vulnerability labels for the device firmware are scarce, the paper cannot currently support the abstract's 'improves correctness' or the safety-critical motivation. A concrete test would be to compare entailed vs rejected paths against known CVEs in BinPool (e.g., the functions implicated in each CVE) or to have expert reverse engineers judge a sample; without such grounding, the headline metric is internal.
  3. [Section 4, Tables 3-4] The paired Wilcoxon test and the 'only 3 of 94 configurations decrease' claim treat per-configuration entailment percentages with no weighting by #Total. Several cells have one or two realized paths (e.g., Table 3, GPT-5.5 gpac zero-shot has 12 total but +DK 1/1; Llama-4 Scout gpac zero-shot has 5/1), and +DK often reduces #Total substantially (e.g., Kimi K2.5 insulininject zero-shot 158→11). A change from 0/1 to 1/1 contributes +100 percentage points, the same as a change from 90/100 to 100/100. The pooled percentages are more meaningful, but the per-configuration significance test should at least be accompanied by a denominator-aware analysis, and the '3/94' count should be reported with the distribution of #Total.
minor comments (4)
  1. [Figure 3 vs Appendix J.1] The constraints in Figure 3 say 'one label group per stage, no cross-group mixing', while the shared base prompt in Appendix J.1 says 'Labels can be mixed from different sets within the same stage.' Clarify which constraint was actually enforced; the discrepancy affects reproducibility.
  2. [Section 2] The entailment symbol is overloaded: Π |=_ent τ and I* |=_i analystAt(...) have different meanings. Define the second use explicitly.
  3. [Section 6 and Appendix B.2] The conclusion's self-refinement counts (1,054→1,445) do not match the sums of Tables 3-4 for the self-refinement rows, nor Appendix Table 2's per-type aggregates. Please reconcile the numbers.
  4. [Throughout] Minor language issues: 'contradicts with the domain knowledge' should be 'contradicts the domain knowledge'; 'utilizes that exploration into verified output' should be 'converts that exploration into verified output'.

Circularity Check

1 steps flagged

The +DK condition hands the LLM the verifier's own derived labels, so the headline 78→98% entailment gain is partly by construction; the paper's own Appendix B.1 shows the metric tracks DK permissiveness.

specific steps
  1. fitted input called prediction [Section 3 (Domain Knowledge); Appendix J.5 (Domain-Knowledge Enrichment); Appendix H.1]
    "DK also supplies the mapping rules that lift raw libc labels onto its own vocabulary during reasoning, so the labels attached to code blocks are expressed in the terms against which paths are later checked for entailment. For the +DK experimental setting, we pre-run the mapping rules and provide the LLM with additional labels."

    The +DK prompt is built by running the same mapping rules that the verifier uses to derive hasLabel facts, and the traversal rule then 'entails' a step whenever a DK relation links a label on CB1 to a label on CB2. Any realized path that reuses the injected DK vocabulary therefore satisfies the verifier's hasLabel precondition by construction (assuming the DKG contains a relevant edge), so the 78→98% gain largely measures the LLM's echo of the supplied labels, not the reasoner's independent rejection of bad paths. The paper's own Appendix B.1 notes unaided entailment is ordered like random sampling and +DK collapses all binaries to ~91–100%, consistent with near-trivial entailment once the vocabulary is provided. No scrambled-label or post-hoc-only control separates prompt enrichment from

full rationale

EntailLLM's logical core is self-contained: given a fixed DKG and rule set, PyReason computes entailment exactly, and the random-sampling baseline shows the verifier is not vacuous (18–46% for random paths). The formal guarantees cited from Shakarian et al. are published theorems, not results fabricated for this paper. However, the headline 78→98% gain is measured under a +DK condition in which the LLM prompt is augmented with labels produced by the very mapping rules the verifier uses to define entailment. The paper states this openly (Section 3, Appendix J.5), and its own Appendix B.1 observes that unaided entailment tracks random sampling and that +DK makes all binaries converge to ~91–100%. Thus the independent contribution of the reasoner is not isolated: a control that injects scrambled labels, or that verifies baseline generations post hoc, is absent. The improvement is therefore partially by construction—the generator is handed the verifier's vocabulary—so the magnitude of the reported effect cannot be read as evidence that the logic layer catches erroneous paths. The paper also explicitly assumes the DK is accurate and reports no external ground-truth validation, which is a correctness/external-validity limitation rather than a circular step; it amplifies the concern because 98% entailment is conformance to the authors' own model. I find no additional circularity: the PyReason engine is open-source, the logic-program rules are stated in the appendix, and the complexity citations are to prior published work.

Axiom & Free-Parameter Ledger

3 free parameters · 4 axioms · 1 invented entities

The central claimed improvement depends on the authors' hand-built DK graphs, hand-set rule thresholds, and the chosen N_sol parameter. The logic engine is standard, but the knowledge content is assumed correct without external validation.

free parameters (3)
  • mu_min (minimum admissible annotation bound) = [0.25, 1]
    Hand-set threshold for considering an analyst present at a block; gates the traversal rules and thus the entailment verdict.
  • N_sol (realized chains kept per surviving template) = 5
    Tuned over {1,2,5,10} on the evaluation set; smaller values degraded results and larger ones raised runtime/cost.
  • Rule annotation bounds (0.1, 0.25, 0.6, 0.7, etc.) = multiple hand-set values in 42 rules
    Hand-set thresholds in the logic program body clauses; they control which label combinations fire, affecting the measured entailment rate.
axioms (4)
  • domain assumption The domain-knowledge graphs are accurate and complete for the target CWEs
    Stated explicitly: 'We assume the domain knowledge itself is accurate.' If false, high entailment does not reflect real vulnerability behavior.
  • domain assumption Ghidra's recovered call graph and libc labels are correct and sufficient
    The entire pipeline consumes Ghidra output as ground truth for structure and labels; no error model is provided.
  • standard math Generalized annotated logic semantics and polynomial-time fixpoint theorems (Kifer and Subrahmanian 1992; Shakarian et al. 2011)
    The formal guarantee of exact entailment relies on these prior results, cited but not proved in the paper.
  • ad hoc to paper The 42 hand-written rule templates correctly encode vulnerability reasoning
    The rules are authored for this system, not derived from a standard or externally validated source; their correctness is assumed.
invented entities (1)
  • Domain-knowledge graph concepts (e.g., missing_bounds_check, unchecked_memory_write, stack_pointer_overwrite) no independent evidence
    purpose: Bridge raw libc labels and CWE-level vulnerability classes so the entailment rules can justify analyst steps
    These concepts are constructed by the authors via automated extraction and manual review; they are assumed correct and not validated against external benchmarks.

pith-pipeline@v1.3.0-daily-deepseek · 27613 in / 10010 out tokens · 108341 ms · 2026-08-04T21:26:39.227557+00:00 · methodology

0 comments
Cite this review

Pith. "Pith review of EntailLLM: Verifying LLM-Generated Vulnerability Discovery Paths with Domain Knowledge via Logic Programming." pith.science (2026). https://pith.science/paper/Y7UXWLAN

@misc{pith2026260801763,
  author       = {Pith},
  title        = {Pith review of: EntailLLM: Verifying LLM-Generated Vulnerability Discovery Paths with Domain Knowledge via Logic Programming},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/Y7UXWLAN}},
  note         = {Machine review of arXiv:2608.01763}
}
Share X Bluesky LinkedIn Reddit HN
read the original abstract

Large language models are increasingly used to reason about software vulnerabilities, but their outputs can silently violate domain knowledge, limiting their reliability in safety-critical settings such as medical devices. Prior work either treats that output as a prediction to be scored or constrains it to walks within a single knowledge graph; neither checks whether reasoning over a binary is consistent with an independent body of domain knowledge. We present EntailLLM, which validates each LLM-proposed analyst path by entailment: the path is a traversal of the binary's function call graph, the domain knowledge is represented in a separate graph, and verification aligns the two under temporal annotated logic. Across three CWE classes, four LLMs, three prompting strategies, and seven binaries varying in size from 405 to 12,696 function call-graph nodes, domain knowledge raises pooled entailment from 78% to 98%, with entailment decreasing in only 3% of the experiments. EntailLLM is deployed end-to-end on real medical-device binaries, reaching 98% pooled entailment without per-device tuning. Our system inherits the formal guarantees of generalized annotated logic, providing logical verification of LLM output that is both explainable and grounded in well-defined semantics.

Figures

Figures reproduced from arXiv: 2608.01763 by Colton Payne, Dana Warmsley, Evelyn Kim, Jaikrishna Manojkumar Patil, Kaustuv Mukherji, Nigel Stepp, Paulo Shakarian.

Figure 1
Figure 1. Figure 1: An LLM mistake caught by domain knowledge. [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: The end-to-end EntailLLM pipeline. Solid boxes [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Structured prompt template for CWE-121. Full [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figure 5
Figure 5. Figure 5: Plots showing how (a) reasoning time and (b) peak [PITH_FULL_IMAGE:figures/full_fig_p006_5.png] view at source ↗
Figure 6
Figure 6. Figure 6: The explainable trace showing entailment (first two, [PITH_FULL_IMAGE:figures/full_fig_p007_6.png] view at source ↗
Figure 1
Figure 1. Figure 1: Zero-shot on insulininject (CWE-121). Each box is ten independent runs: grey is random sampling, blue unaided generation, orange the same model with domain knowledge (+DK). Random sampling attains 18.0± 8.5% entailment. A box collapsed to a single line indicates zero variance across runs [PITH_FULL_IMAGE:figures/full_fig_p010_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: Chain-of-thought on insulininject (CWE-121). Conventions as in [PITH_FULL_IMAGE:figures/full_fig_p010_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Self-refinement on insulininject (CWE-121) [PITH_FULL_IMAGE:figures/full_fig_p011_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: Zero-shot on mupdf-x11 (CWE-416). Conventions as in [PITH_FULL_IMAGE:figures/full_fig_p011_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Chain-of-thought on mupdf-x11 (CWE-416). Conventions as in [PITH_FULL_IMAGE:figures/full_fig_p012_5.png] view at source ↗
Figure 6
Figure 6. Figure 6: Self-refinement on mupdf-x11 (CWE-416). Conventions as in [PITH_FULL_IMAGE:figures/full_fig_p012_6.png] view at source ↗
Figure 7
Figure 7. Figure 7: Reasoning runtime versus number of reasoning time steps for all CWE-121 (solid) and CWE-416 (dashed) [PITH_FULL_IMAGE:figures/full_fig_p016_7.png] view at source ↗
Figure 8
Figure 8. Figure 8: Peak resident set size (RSS) after reasoning versus number of reasoning time steps for all CWE-121 (solid) [PITH_FULL_IMAGE:figures/full_fig_p017_8.png] view at source ↗
Figure 9
Figure 9. Figure 9: The reasoning trace behind a non-entailment inference, for the analyst path of the running example in the [PITH_FULL_IMAGE:figures/full_fig_p026_9.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

299 extracted references · 63 canonical work pages · 8 internal anchors

  1. [1]

    Artificial intelligence , volume=

    Circumscription—a form of non-monotonic reasoning , author=. Artificial intelligence , volume=. 1980 , publisher=

    1980

  2. [2]

    ACM Comput

    Sheng, Ze and Chen, Zhicheng and Gu, Shuning and Huang, Heqing and Gu, Guofei and Huang, Jeff , title =. ACM Comput. Surv. , month = nov, articleno =. 2025 , issue_date =. doi:10.1145/3769082 , abstract =

    doi:10.1145/3769082 2025

  3. [3]

    2024 IEEE symposium on security and privacy (SP) , pages=

    Llms cannot reliably identify and reason about security vulnerabilities (yet?): A comprehensive evaluation, framework, and benchmarks , author=. 2024 IEEE symposium on security and privacy (SP) , pages=. 2024 , organization=

    2024

  4. [4]

    Karonte: Detecting Insecure Multi-binary Interactions in Embedded Firmware , year=

    Redini, Nilo and Machiry, Aravind and Wang, Ruoyu and Spensky, Chad and Continella, Andrea and Shoshitaishvili, Yan and Kruegel, Christopher and Vigna, Giovanni , booktitle=. Karonte: Detecting Insecure Multi-binary Interactions in Embedded Firmware , year=

  5. [5]

    Logic- LM : Empowering Large Language Models with Symbolic Solvers for Faithful Logical Reasoning

    Pan, Liangming and Albalak, Alon and Wang, Xinyi and Wang, William. Logic- LM : Empowering Large Language Models with Symbolic Solvers for Faithful Logical Reasoning. Findings of the Association for Computational Linguistics: EMNLP 2023. 2023. doi:10.18653/v1/2023.findings-emnlp.248

    doi:10.18653/v1/2023.findings-emnlp.248 2023

  6. [6]

    Proceedings of the 33rd ACM international conference on information and knowledge management , pages=

    Realtcd: Temporal causal discovery from interventional data with large language model , author=. Proceedings of the 33rd ACM international conference on information and knowledge management , pages=

  7. [7]

    , author=

    Decompiling the Synergy: An Empirical Study of Human-LLM Teaming in Software Reverse Engineering. , author=. NDSS , year=

  8. [8]

    The temporal logic of programs , year=

    Pnueli, Amir , booktitle=. The temporal logic of programs , year=

  9. [9]

    Formal aspects of computing , volume=

    A logic for reasoning about time and reliability , author=. Formal aspects of computing , volume=. 1994 , publisher=

    1994

  10. [10]

    2005 , issn =

    Probabilistic temporal logics via the modal mu-calculus , journal =. 2005 , issn =. doi:https://doi.org/10.1016/j.tcs.2005.03.048 , url =

    work page doi:10.1016/j.tcs.2005.03.048 2005

  11. [11]

    arXiv preprint arXiv:2505.19361 , year=

    Consistency-based Abductive Reasoning over Perceptual Errors of Multiple Pre-trained Models in Novel Environments , author=. arXiv preprint arXiv:2505.19361 , year=

    work page arXiv

  12. [12]

    ELECTRONIC PROCEEDINGS IN THEORETICAL COMPUTER SCIENCE , volume=

    Geospatial Trajectory Generation via Efficient Abduction: Deployment for Independent Testing , author=. ELECTRONIC PROCEEDINGS IN THEORETICAL COMPUTER SCIENCE , volume=. 2025 , publisher=

    2025

  13. [13]

    arXiv preprint arXiv:2506.17776 , year=

    Machine Learning Model Integration with Open World Temporal Logic for Process Automation , author=. arXiv preprint arXiv:2506.17776 , year=

    work page arXiv

  14. [14]

    arXiv preprint arXiv:2507.10781 , year=

    Reasoning about Medical Triage Optimization with Logic Programming , author=. arXiv preprint arXiv:2507.10781 , year=

    work page arXiv

  15. [15]

    Logic-LM: Empowering Large Language Models with Symbolic Solvers for Faithful Logical Reasoning , author=

  16. [16]

    Probabilistic circuits: A unifying framework for tractable probabilistic models , author=. UCLA. URL: http://starai. cs. ucla. edu/papers/ProbCirc20. pdf , pages=

  17. [17]

    ACM Transactions on Programming Languages and Systems (TOPLAS) , volume=

    Automatic verification of finite-state concurrent systems using temporal logic specifications , author=. ACM Transactions on Programming Languages and Systems (TOPLAS) , volume=. 1986 , publisher=

    1986

  18. [18]

    2012 , publisher=

    A new introduction to modal logic , author=. 2012 , publisher=

    2012

  19. [19]

    IEEE transactions on knowledge and data engineering , volume=

    What you always wanted to know about Datalog(and never dared to ask) , author=. IEEE transactions on knowledge and data engineering , volume=

  20. [20]

    2021 60th IEEE Conference on Decision and Control (CDC) , pages=

    Non-markovian reinforcement learning using fractional dynamics , author=. 2021 60th IEEE Conference on Decision and Control (CDC) , pages=. 2021 , organization=

    2021

  21. [21]

    Turning 30: New Ideas in Inductive Logic Programming

    Turning 30: New ideas in inductive logic programming , author=. arXiv preprint arXiv:2002.11002 , year=

    work page internal anchor Pith review Pith/arXiv arXiv 2002

  22. [22]

    Advances in Neural Information Processing Systems , volume=

    Bridging machine learning and logical reasoning by abductive learning , author=. Advances in Neural Information Processing Systems , volume=

  23. [23]

    Proceedings of the AAAI conference on artificial intelligence , volume=

    Reinforcement learning with non-markovian rewards , author=. Proceedings of the AAAI conference on artificial intelligence , volume=

  24. [24]

    Journal of Machine Learning Research , volume=

    Reinforcement learning for joint optimization of multiple rewards , author=. Journal of Machine Learning Research , volume=

  25. [25]

    Advances in neural information processing systems , volume=

    Reinforcement learning in Markovian and non-Markovian environments , author=. Advances in neural information processing systems , volume=

  26. [26]

    Systems & Control Letters , volume=

    Reinforcement learning in non-Markovian environments , author=. Systems & Control Letters , volume=. 2024 , publisher=

    2024

  27. [27]

    Advances in Neural Information Processing Systems , volume=

    Rethinking knowledge graph evaluation under the open-world assumption , author=. Advances in Neural Information Processing Systems , volume=

  28. [28]

    On Context and the Open World Assumption , year=

    Moore, Philip and Van Pham, Hai , booktitle=. On Context and the Open World Assumption , year=

  29. [29]

    AMIA annual symposium proceedings , volume=

    UMLS-Interface and UMLS-Similarity: open source software for measuring paths and semantic similarity , author=. AMIA annual symposium proceedings , volume=. 2009 , organization=

    2009

  30. [30]

    J. A. Robinson , doi =. Loveland Donald W.. Automated Theorem Proving. A Logical Basis. Fundamental Studies in Computer Science, Vol. 6. North-Holland Publishing Company, Amsterdam, New York, and Oxford, 1978, Xiii + 405 Pp , volume =. Journal of Symbolic Logic , number =

    1978

  31. [31]

    Temporal Equilibrium Logic: A First Approach

    Cabalar, Pedro and P \'e rez Vega, Gilberto. Temporal Equilibrium Logic: A First Approach. Computer Aided Systems Theory -- EUROCAST 2007. 2007

    2007

  32. [32]

    On the Complexity of Temporal Equilibrium Logic , year=

    Bozzelli, Laura and Pearce, David , booktitle=. On the Complexity of Temporal Equilibrium Logic , year=

  33. [33]

    Ai Magazine , volume=

    Applications of answer set programming , author=. Ai Magazine , volume=

  34. [34]

    , title =

    Kowalski, Robert A. , title =. Commun. ACM , month = jan, pages =. 1988 , issue_date =. doi:10.1145/35043.35046 , abstract =

    work page arXiv 1988

  35. [35]

    Communications of the ACM , volume=

    Answer set programming at a glance , author=. Communications of the ACM , volume=. 2011 , publisher=

    2011

  36. [36]

    Annals of Mathematics and Artificial Intelligence , month = jun, pages =

    Pearce, David , title =. Annals of Mathematics and Artificial Intelligence , month = jun, pages =. 2006 , issue_date =. doi:10.1007/s10472-006-9028-z , abstract =

    doi:10.1007/s10472-006-9028-z 2006

  37. [37]

    and Kasneci, Gjergji and Weikum, Gerhard , title =

    Suchanek, Fabian M. and Kasneci, Gjergji and Weikum, Gerhard , title =. Proceedings of the 16th International Conference on World Wide Web , pages =. 2007 , isbn =. doi:10.1145/1242572.1242667 , abstract =

    arXiv 2007

  38. [38]

    International Conference on Knowledge Engineering and Ontology Development , volume=

    Meaning-preserving skolemization , author=. International Conference on Knowledge Engineering and Ontology Development , volume=. 2011 , organization=

    2011

  39. [39]

    Answer set programming at a glance , year =

    Brewka, Gerhard and Eiter, Thomas and Truszczy\'. Answer set programming at a glance , year =. Commun. ACM , month = dec, pages =. doi:10.1145/2043174.2043195 , abstract =

    work page arXiv

  40. [40]

    The logic programming paradigm: A 25-year perspective , pages=

    Stable models and an alternative logic programming paradigm , author=. The logic programming paradigm: A 25-year perspective , pages=

  41. [41]

    The stable model semantics for logic programming , author=. Proc. 5'h International Conference and Symposium on Logic Programming , pages=

  42. [42]

    Logic Programs with Stable Model Semantics as a Constraint Programming Paradigm , volume =

    Niemelä, Ilkka , year =. Logic Programs with Stable Model Semantics as a Constraint Programming Paradigm , volume =. Ann. Math. Artif. Intell. , doi =

  43. [43]

    Translating Embeddings for Modeling Multi-relational Data , url =

    Bordes, Antoine and Usunier, Nicolas and Garcia-Duran, Alberto and Weston, Jason and Yakhnenko, Oksana , booktitle =. Translating Embeddings for Modeling Multi-relational Data , url =

  44. [44]

    Making Sense of Conflicting (Defeasible) Rules in the Controlled Natural Language ACE : Design of a System with Support for Existential Quantification Using Skolemization

    Diller, Martin and Wyner, Adam and Strass, Hannes. Making Sense of Conflicting (Defeasible) Rules in the Controlled Natural Language ACE : Design of a System with Support for Existential Quantification Using Skolemization. Proceedings of the 13th International Conference on Computational Semantics - Short Papers. 2019. doi:10.18653/v1/W19-0505

    work page doi:10.18653/v1/w19-0505 2019

  45. [45]

    Computing Meaning: Volume 1 , pages=

    Dynamic Skolemization , author=. Computing Meaning: Volume 1 , pages=. 1999 , publisher=

    1999

  46. [46]

    SIAM Review , volume=

    Symbolic Logic and Mechanical Theorem Proving (Chin-Liang Chang and Richard Char-Tung Lee) , author=. SIAM Review , volume=. 1974 , publisher=

    1974

  47. [47]

    New York , pages=

    Automated Theorem Proving: A Logical Basis North Holland , author=. New York , pages=

  48. [48]

    2012 , isbn =

    Ginsberg, Matt , title =. 2012 , isbn =

    2012

  49. [49]

    Proceedings of the 21th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining , pages=

    Mining for causal relationships: A data-driven study of the islamic state , author=. Proceedings of the 21th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining , pages=

  50. [50]

    and Subrahmanian, V

    Paulo Shakarian and Simari, Gerardo I. and Subrahmanian, V. S. Annotated Probabilistic Temporal logic: Approximate fixpoint implementation. ACM Transactions on Computational Logic. 2012. doi:10.1145/2159531.2159535

    work page arXiv 2012

  51. [51]

    and Subrahmanian, Venkatramana V

    Shakarian, Paulo and Parker, Austin and Simari, Gerardo I. and Subrahmanian, Venkatramana V. S. , title =. ACM Trans. Comput. Logic , month =. 2011 , issue_date =. doi:10.1145/1877714.1877720 , abstract =

    work page arXiv 2011

  52. [52]

    Quo Vadis, Action Recognition?

    Jo. Quo Vadis, Action Recognition?. CoRR , volume =. 2017 , url =. 1705.07750 , timestamp =

    Pith/arXiv arXiv 2017

  53. [53]

    ImageNet Classification with Deep Convolutional Neural Networks , url =

    Krizhevsky, Alex and Sutskever, Ilya and Hinton, Geoffrey E , booktitle =. ImageNet Classification with Deep Convolutional Neural Networks , url =

  54. [54]

    MAGNN: Metapath Aggregated Graph Neural Network for Heterogeneous Graph Embedding

    Xinyu Fu and Jiani Zhang and Ziqiao Meng and Irwin King , title =. CoRR , volume =. 2020 , url =. 2002.01680 , timestamp =

    work page internal anchor Pith review Pith/arXiv arXiv 2020

  55. [55]

    2022 , eprint=

    The Impact of Feature Quantity on Recommendation Algorithm Performance: A Movielens-100K Case Study , author=. 2022 , eprint=

    2022

  56. [56]

    A Novel Framework for Constructing Multimodal Knowledge Graph from MuSe-CaR Video Reviews , year=

    Usmani, Atiya and Alsamhi, Saeed Hamood and Breslin, John and Curry, Edward , booktitle=. A Novel Framework for Constructing Multimodal Knowledge Graph from MuSe-CaR Video Reviews , year=

  57. [57]

    XR4DRAMA Knowledge Graph: A Knowledge Graph for Disaster Management , year=

    Vassiliades, Alexandros and Symeonidis, Spyridon and Diplaris, Sotiris and Tzanetis, Georgios and Vrochidis, Stefanos and Bassiliades, Nick and Kompatsiaris, Ioannis , booktitle=. XR4DRAMA Knowledge Graph: A Knowledge Graph for Disaster Management , year=

  58. [58]

    Ontology Modeling for Probabilistic Knowledge Graphs , year=

    Freedman, Hayden and Abolhassani, Neda and Metzger, Jacob and Paul, Sanjoy , booktitle=. Ontology Modeling for Probabilistic Knowledge Graphs , year=

  59. [59]

    DocSemMap: Leveraging Textual Data Documentations for Mapping Structured Data Sets into Knowledge Graphs , year=

    Burgdorf, Andreas and Paulus, Alexander and Pomp, André and Meisen, Tobias , booktitle=. DocSemMap: Leveraging Textual Data Documentations for Mapping Structured Data Sets into Knowledge Graphs , year=

  60. [60]

    Subrahmanian , title =

    Michael Kifer and V.S. Subrahmanian , title =. J. Log. Program. , volume =. 1992 , pages =

    1992

  61. [61]

    Interpretable and Explainable Logical Policies via Neurally Guided Symbolic Abstraction

    Interpretable and Explainable Logical Policies via Neurally Guided Symbolic Abstraction , author=. arXiv preprint arXiv:2306.01439 , year=

    work page internal anchor Pith review Pith/arXiv arXiv

  62. [62]

    arXiv preprint arXiv:1708.04782 , year=

    Starcraft ii: A new challenge for reinforcement learning , author=. arXiv preprint arXiv:1708.04782 , year=

    Pith/arXiv arXiv

  63. [63]

    Proceedings of the international conference on scientific computing (CSC) , pages=

    Advanced framework for simulation, integration and modeling (AFSIM)(Case Number: 88ABW-2015-2258) , author=. Proceedings of the international conference on scientific computing (CSC) , pages=. 2015 , organization=

    2015

  64. [64]

    Proceedings of the AAAI conference on artificial intelligence , volume=

    Safe reinforcement learning via shielding , author=. Proceedings of the AAAI conference on artificial intelligence , volume=

  65. [65]

    Proceedings of the 20th International Conference on Autonomous Agents and MultiAgent Systems , pages=

    Safe Multi-Agent Reinforcement Learning via Shielding , author=. Proceedings of the 20th International Conference on Autonomous Agents and MultiAgent Systems , pages=

  66. [66]

    Proceedings of the AAAI Conference on Artificial Intelligence , volume=

    Safe reinforcement learning via shielding under partial observability , author=. Proceedings of the AAAI Conference on Artificial Intelligence , volume=

  67. [67]

    AAAI Spring Symposium: MAKE , year=

    PyReason: Software for Open World Temporal Logic , author=. AAAI Spring Symposium: MAKE , year=

  68. [68]

    hostile decision dynamics in MDO , author=

    Battlespace: using AI to understand friendly vs. hostile decision dynamics in MDO , author=. Artificial Intelligence and Machine Learning for Multi-Domain Operations Applications III , volume=. 2021 , organization=

    2021

  69. [69]

    nature , volume=

    Human-level control through deep reinforcement learning , author=. nature , volume=. 2015 , publisher=

    2015

  70. [70]

    Alegre , title =

    Lucas N. Alegre , title =. GitHub repository , howpublished =. 2019 , publisher =

    2019

  71. [71]

    2019 , Eprint =

    Nestor Gonzalez Lopez and Yue Leire Erro Nuin and Elias Barba Moral and Lander Usategui San Juan and Alejandro Solano Rueda and Víctor Mayoral Vilches and Risto Kojcev , Title =. 2019 , Eprint =

    2019

  72. [72]

    arXiv preprint arXiv:1910.01708 , volume=

    Benchmarking safe exploration in deep reinforcement learning , author=. arXiv preprint arXiv:1910.01708 , volume=

    Pith/arXiv arXiv 1910

  73. [73]

    Workshop on Language and Robotics at CoRL 2022 , year=

    Lang2ltl: Translating natural language commands to temporal specification with large language models , author=. Workshop on Language and Robotics at CoRL 2022 , year=

    2022

  74. [74]

    Hybrid Machine Learning/Knowledge Base Systems Learning through Natural Language Dialogue with Deep Learning Models , author=

  75. [75]

    Physica D: Nonlinear Phenomena , author =

    The symbol grounding problem , volume =. Physica D: Nonlinear Phenomena , author =

  76. [76]

    Conference on Empirical Methods in Natural Language Processing , pages=

    Logical Neural Networks for Knowledge Base Completion with Embeddings & Rules , author=. Conference on Empirical Methods in Natural Language Processing , pages=

  77. [77]

    2021 ACM/IEEE International Conference on Model Driven Engineering Languages and Systems Companion (MODELS-C) , pages=

    From conceptual models to knowledge graphs: a generic model transformation platform , author=. 2021 ACM/IEEE International Conference on Model Driven Engineering Languages and Systems Companion (MODELS-C) , pages=. 2021 , organization=

    2021

  78. [78]

    , author=

    Fast discovery of association rules. , author=. Advances in knowledge discovery and data mining , volume=. 1996 , publisher=

    1996

  79. [79]

    Machine learning , volume=

    Learning logical definitions from relations , author=. Machine learning , volume=. 1990 , publisher=

    1990

  80. [80]

    Journal of Operations Management , volume=

    Unveiling the structure of supply networks: case studies in Honda, Acura, and DaimlerChrysler , author=. Journal of Operations Management , volume=. 2002 , publisher=

    2002

Showing first 80 references.