acceptodds
Under review as a conference paper at ICLR 2027

SLASH: Probabilistic Circuits for Fast Neural Answer Set Programming

Abstract

Exact probabilistic inference is #P-hard and CPU-bound, and current neurosymbolic systems utilizing GPUs are approximate by design. Nonetheless, whether exact inference is cheap, can be read off the program. SLASH compiles an answer-set program into a reasoning graph. It is a directed graph, implemented as a graph neural network and executed alongside deep neural networks on GPUs. Testing the graph for decomposability and determinism confirms it to be a probabilistic circuit. Hence, one message-passing sweep returns the exact query probability and the gradients of weighted model counting. Where the exactness fails, the offending disjunction goes to cutset sampling under a Hoeffding bound, which on visual question answering still beats every approximate baseline at every clause length, by up to percentage points. Further, it surpasses the one second per epoch barrier on neurosymbolic benchmarks being an order of magnitude faster than the exact solvers. SLASH sums MNIST digits representing possible worlds, none of which are enumerated, at digit accuracy on a single GPU

Primary area:
neurosymbolic & hybrid AI systems (physics-informed, logic & formal reasoning, etc.)
Keywords:
neurosymbolic, DPPL, probabilistic circuit, differentiable WMC

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_ziMTOpenReview ↗
Rating
1
Confidence
4
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

Probabilistic neurosymbolic languages parameterize the distributions in probabilistic programming languages with neural networks. However, the probabilistic inference problem is #P-hard, limiting the scalability of these methods. The authors propose ∂\partialSLASH, which targets a subset of programs that are tractable, such that inference remains linear-time. They do this by relying on the decomposability and determinism properties. When not present, they use cutset sampling to approximate, and provide an error bound. They implement their language using GNN message-passing, providing GPU acceleration for inference and learning.

Critical strengths

I like the combination of exact/approximate, by e.g. solving most of the program exactly and only using sampling for an intractable core of the problem. Neurosymbolic languages are too often entirely exact, or fully approximate (e.g. by sampling everything).

Critical weaknesses

Several parts of the paper seem to have limited novelty. For example, Theorem 1 is already what PRISM was built on decades ago. (The authors also do cite this themselves.) So the linear-time exactness contributions seems overstated to me.

The GPU-based implementation also does not seem particularly novel to me, as the authors cite KLay to already do this. The paper states that “KLay accelerates a circuit ∂SLASH never builds.”, but this again overstates the difference. Both methods build circuits and accelerate them (∂SLASH uses different notation with graphs, but these are also circuits). The difference is the language built on top does not perform knowledge compilation (but that’s a difference on the language level, not on the GPU-based acceleration).

This only leaves the sampling-based approximation on non-deterministic nodes. However, this part of the contribution is poorly explained, in my opinion. There are a bunch of vague statements like “the sampling error is certified on demand, and the relaxation bias is the single remaining uncontrolled term”, but it doesn’t actually state what relaxation is used. I have to dig into the appendix to see it’s Gumbel-softmax (which is very well-known, so could’ve easily been mentioned). The rest of the paper never mentions that the approximation is biased (and not bounded).

On the language side, it was also not clear to me why a “new” language was introduced as ∂\partialSLASH. It seemed to me like only the inference side is different, but the language is basically the same as SLASH (with perhaps some small restrictions). I would have like the paper to give more intuition on what subset of programs the inference i linear-time (from what I know, I think this has already for negation-free programs by Winters et al. (2022), which show the correspondence between deterministic+decomposable programs and context-free grammars).

On the experimental side, I also found some results to be overly straightforward. For example, RQ4 (does the encoding matter), is of course true and well-known. (For example, Jiao et al. (2026) apply the same trick, to scale the exact same experiment to N=500.) RQ1 (does our exact method match the accuracy of other exact methods) also seems obviously true.

As a final note, I think the writing in many places is subpar, and the authors could’ve spent more effort cleaning up obvious AI artifacts to improve the presentation.

References

Winters, Thomas, et al. "Deepstochlog: Neural stochastic logic programming." Proceedings of the AAAI Conference on Artificial Intelligence. Vol. 36. No. 9. 2022.

Jiao, Ying, et al. "DeepProofLog: Efficient Proving in Deep Stochastic Logic Programs." Proceedings of the AAAI Conference on Artificial Intelligence. Vol. 40. No. 27. 2026.

Questions for authors
  • The treatement of negation is not fully clear to me. For example, on line 192, it states that the graph is just a probabilistic circuit, however these are NNF. But the paper also says there is stratified negation, so there should be negation present on internal edges? (On a sidenote, i also think it should be an arithmetic circuit and not a probabilistic circuit, as there are no normalized weights on the ∨\lor-nodes.)
  • Why are the exact semantics under sampling? The relaxation uses a softened max operation, so is inference closer to MAP than marginalization?
3 comments

Reply to Reviewer ziMT

We thank the reviewer for a close and specific reading. The hybrid they name as a critical strength is what we take the contribution to be, and several criticisms below are fair consequences of our having framed it less directly than that.

What ∂SLASH claims. Exact DPPLs obtain weighted model counting by enumerating stable models or by knowledge compilation, so a CPU solver sits in the training loop and every gradient step stalls while it runs. ∂SLASH removes it: the program is grounded once, and from there on the reasoning graph which encodes all stable models is the weighted model count. While others pipelines compile a program using Knowledge compilation we syntactically compile the graph and then test where exactness fails and recover it via sampling.

Thm. 1 licenses that substitution, and this is why PRISM's condition matters to us: PRISM used exclusiveness to sum explanations it had already enumerated, and we use it to justify never enumerating them.

W1. Theorem 1 is PRISM's condition

Agreed, and the paper says so and cites PRISM in the same paragraph. The contribution is not the condition but what it gives us: PRISM makes exclusiveness the programmer's obligation and uses it to sum explanations it has already enumerated, whereas we decide it structurally, per node, and use it to avoid enumeration altogether. Sec. 2.3, What this buys over the distribution semantics.

W2. KLay

A fair correction, and the sentence is removed: our reasoning graph is a circuit. What we meant differs in one word, that KLay accelerates a circuit ∂SLASH never compiles — compilation being the step KLay itself amortizes and we never perform, since the graph is read off the ground program in time linear in its size. Sec. 4 now states the difference it rests on: compilation searches for decomposability and exclusiveness, we test for them per node and sample where the test fails. Further, Klay compiles for each query a separate SDD, layerizes them, and finally merges them into a single shared circuit. We ground multiple queries simultaneously and then create a single joint RG for all of them directly from the groundings.

Positioning. Sec. 2.1 says that ∂SLASH inherits SLASH's language constructs and that the fragment is a restriction, not a new language. Sec. 4 corrects the KLay sentence to the claim we meant, that KLay accelerates a circuit ∂SLASH never compiles, and states the difference it rests on: compilation searches for decomposability and exclusiveness, we test for them per node and sample where the test fails. RQ1 is relabelled a control in Sec. 3, RQ4's claim is narrowed to the VRAM budget, and DeepStochLog and DeepProofLog are cited and positioned.

W3. The relaxation, and the bias

We agree that this should have been part of the main text and move it there accordingly. A Gumbel-softmax draw taken once per NPP instance (Eq. 7), and the bias is measured rather than uncontrolled. The bias is observable and is linear in the temperature, ηbias=cτ\eta_{\mathrm{bias}} = c\tau with c∈[0.26,0.38]c \in [0.26, 0.38], so at the published τ=0.1\tau = 0.1 it is at most ≈0.038 per node, and on most programs it sits under the sampling margin we already certify. We added App. C where we emperically dive into different choices of the sampling parameters.

W4. "A new language", and Winters et al. (2022)

The reading is correct, and Sec. 2.1 now says that ∂SLASH inherits SLASH's language constructs and that the fragment is a restriction; a program outside it is partially sampled, not rejected. DeepStochLog is cited in Sec. 4, and the kinship is real, but it distributes over derivations, where summation is correct by construction, and its authors say it avoids the disjoint-sum problem "by resorting to an alternative probabilistic semantics". We keep possible-worlds semantics, where that problem is the one Thm. 1 characterises, and DeepStochLog states no decomposability, exclusiveness or linear-time result.

W5. RQ1 and RQ4

RQ1: agreed, and it is relabelled a control in Sec. 3, since a method computing the same quantity as exact WMC cannot be more accurate than the solvers it replaces. The claim is on the other axis, and Fig. 2 is where it is made: ∂SLASH at the time scale of the approximate methods while remaining exact.

RQ4: We agree that this is well now and dates back to basic algorithms like Variable Elimination. The aim of this experiment was to show though, that we now see this old problem in the new dimension of VRAM which affects the scalability of GPU based methods.

On Jiao et al. (2026) the two MNIST-Addition tasks differ: their App. C.1 takes 2N2N images as two NN-digit numbers, with Table 1's reference accuracy 0.99072N0.9907^{2N}, while we sum NN single-digit images. Positional addition is a carry chain of constant width where our partial sums range over [0,9N][0, 9N], so we draw no comparison between N=500N=500 there and N=100N=100 here, in either direction.

Q1. Negation, NNF, probabilistic vs. arithmetic circuits

Correct on the syntax: a negative literal contributes 1−pv1-p_v at an internal edge, so the graph is not in NNF, and NNF is only sufficient for the property we test per node instead. Our ∨\vee-nodes carry no weights at all. Still the reasoning graph is a probabilistic circuit rather than an arithmetic circuit, since the circuit builds a distribution over total choices via the normalized NPP leaves. All two are now stated in Sec. 2.3, Under these conditions the reasoning graph is a probabilistic circuit, with the per-node test in App. B.7.

Q2. Is this MAP rather than marginalization?

Marginalization: the pass averages the query over sampled worlds, estimating P(Q)=∑ωP(ω)1[ω⊨Q]P(Q) = \sum_\omega P(\omega)\mathbf{1}[\omega \models Q] and not max⁡ωP(ω)\max_\omega P(\omega), and a query satisfied by kk disjoint worlds of probability pp returns kpkp here against pp under MAP. Inside a drawn world the values are 0/1, where max⁡\max is ∨\vee exactly, so the only error is that draws are not perfectly hard at τ>0\tau > 0. We think our terminology invited the question and have renamed the condition exclusiveness after PRISM; see Def. Exclusiveness in Sec. 2.3 and App. B.12 for the identity the average estimates.

Dear Reviewer,

We would like to thank you again for the insightful review. We have provided a detailed answer in the rebuttal as well as the modified paper. We hope to have resolved all your concerns and will be happy to discuss further if any concerns do remain.

Regards,

Authors

Reviewer_q1xFOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
1
Soundness
1
Read review
Paper summary

This paper proposes reasoning graphs constructed from answer-set programs for exact inference and learning through differentiable forward and backward passes on GPUs. It establishes sufficient conditions to be qualified as probabilistic circuits. The paper empirically evaluates ∂SLASH\partial\text{SLASH} in terms of accuracy, sampling performance, training time, and scalability, comparing it to solver-based DPPLs.

Critical strengths

The paper addresses a well-motivated problem in exact inference for answer-set programs. ∂SLASH\partial\text{SLASH} constructs reasoning graphs that qualify as probabilistic circuits, allowing answer-set problems to be solved by tractable probabilistic representations. ∂SLASH\partial\text{SLASH} exploits GPU parallelism to accelerate the message passing through these graphs. The evaluation includes both established and recent solver-based DPPLs approaches across multiple benchmarks.

Critical weaknesses
  1. The paper focuses on two properties, called decomposability and determinism, that can be satisfied in probabilistic circuits. On p4, it is explicitly written "Under these conditions the reasoning graph is a probabilistic circuit. Defs. 1–3 are literally the decomposability and determinism of probabilistic circuits (Choi et al., 2020)." Furthermore, on p9, when comparing their GPU-approach to CPU-approaches, Darwiche's seminal paper on compiling arithmetic circuits is explicitly mentioned.

I don't understand the focus on these two properties (decomposability and determinism). Specifically, I am skeptical of Theorem 1, which states that if the decomposability and determinism properties are satisfied, then exact marginal inference can be conducted in a probabilistic circuit.

Darwiche [1] provides an extensive review of the probabilistic circuit properties and what types of reasoning they provide:

[1] A. Darwiche. Tractable boolean and arithmetic circuits, 2022. URL https://arxiv.org/abs/2202.02942.

In particular, on p11, he states that it has been known for over 10 years that decomposability and smoothness (sometimes called completeness in other probabilistic circuit papers) provide for exact marginal inference. Furthermore, he continues by stating that exact MPE (most probable explanation) inference can be conducted in a probabilistic circuit satisfying decomposability, smoothness, and determinism (such a probabilistic circuit will still provide exact marginal inference, too). The issue is that the submitted paper did not convince me that decomposability and determinism guarantee exact marginal inference.

  1. The paper is hard to understand.

Some sentences are hard to parse. For example, on p1, "Fuzzy approaches relax Boolean satisfiability into real-valued truth degrees combined by t-norms, which are differentiable, cheap, and map directly onto a GPU, but they discard probabilistic semantics, and the resulting gradients often fail to reflect the logic they were derived from (van Krieken et al., 2022)."

Some sentences don't make sense. For example, on p2, "What this buys is measured in time rather than accuracy, and the theory says it must be: a method that computes the same quantity as exact WMC cannot be more accurate than the exact, solver-based DPPLs it reproduces." This selling point seems to be a tautology, since no method can be more accurate than exact inference.

Novelty. The novelty of the paper is limited considering the previous PC implementation on SLASH\text{SLASH} on CPUs positioning ∂SLASH\partial\text{SLASH} as an incremental GPU implementation.

Questions for authors
  1. Why focus on the properties of decomposability and determinism? Answer specifically with respect to p11 in Darwiche's reference [1] above.

  2. Which are the advantages of ∂SLASH\partial\text{SLASH} compared to SLASH\text{SLASH} other than being implemented on GPUs?

2 comments

Dear Reviewer q1xF, we thank you for your thorough and detailed feedback.

  1. Tractability. Decomposability and smoothness are, in fact, necessary for classical PCs to enable MAR and CON queries in poly-time. Here, our sum nodes do not represent mixtures, which require the same variable scope and normalized weights. Rather, our graph encodes all stable models of a program, which we call total choices. We obtain total choices by fixing one outcome for each NPP instance. For example, in MNIST addition, img1=1 and img2=0 or img1=0 and img2=1. When these choices are mutually exclusive (which we called deterministic), we can combine them by summing. This way we can marginalize out the stable models and do not have to enumerate them all as SLASH does with clingo. We chose the word "determinism" because we fix one outcome per instance. We now changed it to "exclusiveness," as in SATO's prism, to emphasize that we are talking about exclusive branches stemming from the NPPs' outcomes. Further, we rewrote/restructured Sec. 2.3 as readability was a major concern for all reviewers, to better explain the idea of total choices our graph encodes.

  2. Readability. We went through the paper and tried to resolve convoluted sentences. Further, we followed the other Reviewers' suggestions to enhance the readability of the ASN section and moved important parts from the appendix to the main paper to make it self-contained.

  3. Novelty. The novelty of the paper is limited considering the previous PC implementation on CPUs positioning as an incremental GPU implementation. We think there is a misunderstanding here. In SLASH, the authors used probabilistic circuits as their NPPs for integrating various probabilistic query types into the logic. Clingo then enumerated all the stable models used for WMC. DiffSLASH does not move the PCs used as NPPs onto the GPU (they were already on the GPU, implemented as EinsumNetworks). It replaces the reasoning engine of the pipeline with PCs, here ASNs under the given conditions. The probabilistic ASNs marginalize all stable models that Clingo would enumerate. Further, this single graph encodes all queries in a batch, making it easy to batch everything to maximize GPU utilization. In contrast, in DeepProblog, each query is compiled into a separate SDD, making it harder to parallelize on the GPU, and KLay requires an additional merging step to combine multiple graphs into a single graph. We ground multiple queries simultaneously and then create a single joint RG for all of them directly from the groundings.

Dear Reviewer,

We would like to thank you again for the insightful review. We have provided a detailed answer in the rebuttal as well as the modified paper. We hope to have resolved all your concerns and will be happy to discuss further if any concerns do remain.

Regards,

Authors

Reviewer_oWwLOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
1
Soundness
2
Read review
Paper summary

The paper proposes a neuro-symbolic method in which knowledge is expressed as an ASP program consisting of normal rules. The program is converted into an Answer Set Network (ASN), enabling GPU computation and making the approach extremely efficient in terms of execution time. The authors prove that, under certain conditions (determinism for OR nodes and decomposability for AND nodes), the ASN computes the exact value of the Weighted Model Counting (WMC), enabling efficient exact probabilistic inference. The proposed method checks whether these conditions are satisfied and, when they are not, approximates the solution through Monte Carlo sampling, using the binary version of the Gumbel-softmax.

I must say that I am quite uncertain about my assessment of this paper. I believe that the proposed contributions are potentially very significant for the community, and the experimental results are convincing. On the other hand, I find that there are substantial issues with the presentation, which make it difficult to properly understand and evaluate several fundamental aspects of the method. I have therefore opted for a Weak Reject, with the possibility of revising my assessment based on the authors’ responses to my questions.

Critical strengths

The proposed method has several strengths. First, the result established in Theorem 1 is particularly relevant to the community. The possibility of testing the determinism and decomposability conditions at runtime is also very interesting. Moreover, these conditions can be checked at the level of individual nodes, allowing approximation to be used only when necessary. Finally, the paper provides an extensive experimental evaluation, with very convincing results.

Critical weaknesses

I did not identify any major issues with the technical contributions of the paper, which I consider potentially very significant. However, there are several problems with the presentation, most notably the fact that much of the relevant content is relegated to the appendices, making it essentially impossible to properly understand and evaluate the method based on the main paper alone.

More specifically:

The paper lacks a sufficiently clear description of ASNs. Although an explanation is provided, it is so compressed that understanding ASNs without consulting the literature is extremely difficult, if not impossible. This is problematic for two reasons: ASNs are an integral part of the method, and therefore understanding them is necessary to understand the proposed approach; moreover, ASNs are not a sufficiently established approach for readers, even those familiar with neuro-symbolic AI, to be expected to be known by them. A more comprehensive explanation of ASNs in the main paper, possibly accompanied by a more detailed background section in the appendices, would be necessary.

The test used to determine whether sampling is necessary is itself described in the appendices. I also find this problematic, as it is an integral part of the proposed method. Furthermore, the sampling mechanism is also described primarily in the appendices, and I find it somewhat unclear. In particular, I do not understand how differentiability is handled, given that Algorithm 1 uses an indicator function (more details in the questions below). This is a concrete example of a fundamental aspect of the method that, in my opinion, is not sufficiently explained.

In general, the main paper should be self-contained enough to allow readers to understand the method, at least in its fundamental aspects. Moreover, having to constantly switch between the main paper and the appendices makes the reading experience fragmented and hinders comprehension. This is further exacerbated by the fact that the text frequently contains convoluted sentences, making it even more difficult to follow.

I understand that, given the amount of material covered in the paper, it is impossible to include everything in the main text. However, I believe the presentation should be more cohesive. Furthermore, while many relevant details are relegated to the appendices, the main paper includes some less relevant material. For example, Figure 1 essentially depicts the standard architecture of neuro-symbolic methods and adds little to the discussion. Similarly, the section on the loss function is fairly straightforward and could be moved to the appendices. Section 2.5, on the other hand, is highly relevant, but I still consider it less important than a more detailed explanation of the method’s pipeline. It could therefore be shortened to make room for other material.

Beyond the structure of the presentation, I also have some questions about Algorithm 1, which may stem either from my own misunderstanding or from an insufficient explanation of certain steps. More details are provided in the questions below.

Minor Comments:

Regarding fuzzy semantics, the authors argue that they do not recover the quantities prescribed by the intended semantics. This claim is not inherently problematic, but I would like to bring to the authors’ attention a recent paper that provides an important qualification to this statement. In (Daniele and van Krieken, 2026), it is shown that a specific fuzzy semantics, namely Gödel semantics, can exactly preserve classical Boolean semantics through the sign function. I believe this work is quite relevant in this context, as it also proposes a mechanism similar to the one introduced by the authors (Equation 7), but combined with Gödel semantics rather than a sigmoid-based approximation.

A. Daniele, E. van Krieken: Gradient-Based Optimization on Gödel Logic as Discrete Local Search. Proceedings of the 23rd International Conference on Principles of Knowledge Representation and Reasoning, KR 2026.

Questions for authors

I have a question about the test for AND nodes performed at line 4 of Algorithm 1. Specifically, in Definition 3, decomposability is tested by checking the intersection between the supports of the atoms in the body, whereas the algorithm uses a different test, replacing supp(bi)supp(b_i) with inst(bi)inst(b_i).

I think I understood the rationale after reading the paragraph at line 887, but I would appreciate confirmation. Let me explain my interpretation with an example: suppose bib_i is the proposition “image 1 contains a 3” and bjb_j corresponds to “image 1 contains a 4”. Now, if I understand correctly, we should have supp(bi)∩supp(bj)=∅supp(b_i) \cap supp(b_j) = \varnothing, but the test would be inadequate because the two propositions are not actually independent. Is my understanding correct? In any case, if the test is performed in practice using instinst rather than suppsupp, why is Definition 3 used in Theorem 1?

I also have another question about Algorithm 1: at line 24, you use an indicator function, which is not differentiable. How does training work in this case? What I would have expected at this point in the algorithm is the use of Equation 7. If Equation 7 is not used here, where is it used? If it is used here, how exactly is it employed to estimate the WMC of a formula? The equation introduces noise into the leaves cc, but the truth value of the formula must then be computed from these leaves using a differentiable function, if the result is to be used during training.

Another question about Equation 7: you use logistic noise and sigmoid function, which is the binary version of Gumbel-softmax. However, in the experiments, there are multiple cases where the neural network returns categorical variables (MNIST digits). In those cases, why don't you use Gumbel noise and softmax function in place of Logistic noise and sigmoid? By using the binary version, you are essentially assuming independence between the different digits, representing nn Bernoulli distributions rather than a single categorical distribution with nn classes.

3 comments

Dear Reviewer oWwL, we thank you for your thorough and detailed feedback.

  1. We understand that the paper should be self-contained, and jumping back and forth can be cumbersome. As you suggested, we moved the section covering the loss to the appendix and merged parts of it with the gradient section 2.5. Further, we tried to make the ASN section more readable and will add a more in-depth ASN section to the appendix. In the appendix, you can already view examples of ASN-generated graphs shown in Fig. 4. Furthermore, we reviewed section 2.3 and moved important parts from the appendix to the main paper to make it self-contained.

  2. I have a question about the test for AND nodes performed at line 4 of Algorithm 1... Yes, we can confirm that inst() is used as written in Alg.1. In the PC literature, scope()/phi() (-> inst(v)) is used to refer to the RV (-> NPP instances) of a node v. Thanks for pointing it out, we intended to use inst() as in the Algo but mixed it up during writing. We changed Def. 3 as well to also contain inst().

  3. I also have another question about Algorithm 1: at line 24, you use an indicator function... You are right about the indicator function, which unfortunately is an artifact we missed while proofreading. Based on the feedback from Reviewer ziMT, we also thought it would be beneficial to explain the sampling in the main paper. Further, the formula for the Gumbel-Softmax depicted here is just for the binary case of an NPP. We replaced it with the correct Softmax variant for NPPs with multiple outcomes, which also matches our implementation. In the main paper, we now also explain how sampling is used within the graph.

Dear Reviewer,

We would like to thank you again for the insightful review. We have provided a detailed answer in the rebuttal as well as the modified paper. We hope to have resolved all your concerns and will be happy to discuss further if any concerns do remain.

Regards,

Authors

My concerns were mostly about presentation, which the authors have improved in the revised manuscript. They have also satisfactorily addressed my technical questions. I am therefore increasing my score.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General Comment

General comment: what changed in the revision

We thank all reviewers for their time and feedback. The revision is uploaded and every change is marked in blue. This is a summary of what changed in substance, so that the individual replies can stay short and point here.

Terminology. What the paper called determinism is now exclusiveness, following PRISM, in the definition and throughout. In the probabilistic-circuit literature determinism is chiefly the condition that makes MAP queries tractable, which is not the query the forward pass computes, so the old name sent readers to the wrong result; We rerwrote Sec. 2.3 accordingly. Further, a main critique was readability which also factored in when rewriting Sec 2.3. We rewrote it such that it is more self contained.

What kind of object the reasoning graph is. Sec. 2.3 now states which circuit properties hold, which do not, and why the missing ones cost nothing. Unweighted ∨\vee-nodes with all mass entering at normalized NPP leaves make it a probabilistic circuit rather than merely an arithmetic one; the graph is not in NNF, now defined at first use, because negation sits on internal edges; and smoothness is a condition on the ∨\vee-nodes alone which normalized NPPs discharge.

The approximation is now measured rather than asserted. There were many questions about sampling and testing. We extended the main paper with the ideas behind Alg.1. Further, the relaxation is now named in the main text as a Gumbel-softmax draw taken once per NPP instance, so a multi-valued NPP is relaxed as one categorical and not as independent Bernoullis (Eq. 7, Sec. 2.3). Alg. 1 now says what a sampled node returns, the differentiable evaluation of its subgraph on that draw.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.