Scaling Probabilistic Circuits via Monarch Matrices

Benjie Wang; Guy Van den Broeck; Honghua Zhang; Meihua Dang; Nanyun Peng; Stefano Ermon

REVIEW 3 major objections 5 minor 13 references

Scaling Probabilistic Circuits via Monarch Matrices

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

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

Pith's one-line read This paper claims that replacing the dense matrices in probabilistic-circuit sum blocks with sparse Monarch-structured matrices turns the quadratic scaling bottleneck into a surplus that can be spent on hidden size, yielding better…

desk verdict A mathematically sound and practically useful way to scale PCs with structured Monarch sum blocks; the main caveat is that the headline scaling claim isn't fully verified where it matters most (LM1B). read the letter →

arxiv 2506.12383 v1 pith:KQAYMYU4 submitted 2025-06-14 cs.LG stat.ML

Honghua Zhang , Meihua Dang , Benjie Wang , Stefano Ermon , Nanyun Peng , Guy Van den Broeck This is my paper · ORCID

classification cs.LGstat.ML

keywords probabilisticcircuitsMonarchmatricesstructuredsparsitydensityestimationcircuitmultiplicationtractablegenerativemodelshiddenMarkovFLOPscaling

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

This paper claims that the quadratic cost of dense sum-block matrices is the main obstacle to scaling probabilistic circuits, and that replacing those matrices with sparse Monarch-structured ones removes much of that obstacle while keeping exact likelihood and marginal computations intact. The authors derive the Monarch parameterization from circuit multiplication: multiplying two sum blocks produces a sum block whose weight matrix is their Kronecker product, and that Kronecker map can be executed and materialized as interleaved sums and permutations rather than a dense matrix. In hidden Markov models and hidden Chow-Liu trees, this lets them push hidden sizes to $2^{19}$ while cutting per-layer operations from $O(h^2)$ to $O(h^{1.5})$. The resulting Monarch-HMM reaches 1.57 bits per character on Text8 and 190.34 perplexity on LM1B, and Monarch-HCLT reaches 4.01 bits per dimension on ImageNet32, better than the compared tractable baselines and with better likelihood per FLOP than dense circuits. The paper's point is that structure, not just raw size, is what lets tractable generative models scale.

What carries the argument

The load-bearing object is the generalized Monarch matrix, a structured linear map $M\colon \mathbb{R}^{p q}\to \mathbb{R}^{r s}$ defined by tensors $A\in \mathbb{R}^{r\times p\times q}$ and $B\in \mathbb{R}^{s\times q\times r}$ through $(Mx)_{kl} = \sum_{i,j} A_{kij} B_{ljk} x_{ij}$, which is a batched contraction, a transpose, and a second batched contraction. The $d$-layer version is the same construction iterated $d$ times, and Theorem 3.4 shows that with all factors equal to $2\times 2$ the result is exactly a butterfly matrix, so the family interpolates between Butterfly cost $O(h\log h)$ and standard Monarch cost $O(h^{1.5})$ against the dense baseline $O(h^2)$. The identity $(A\otimes B)x=(B(Ax)^{\mathsf{T}})^{\mathsf{T}}$ carries the argument: it shows the Kronecker product produced by multiplying two sum blocks can be materialized as a circuit with $O(m^3)$ edges instead of $O(m^4)$, and it motivates initializing large Monarch circuits by multiplying smaller dense circuits that were trained separately.

What would settle it

Train a dense HMM and a Monarch-HMM on the same dataset at hidden sizes where both fit in memory (for example Text8 at $2^{12}$ through $2^{15}$) and measure the bits-per-character gap; if the gap does not shrink monotonically as hidden size increases, or if a dataset is found where the gap remains large even at the largest feasible hidden size, the central scaling claim fails. A second check is to train a Monarch-HMM at a hidden size whose FLOP budget matches a smaller dense HMM and verify that the Monarch model's likelihood is no better than the dense model's at equal FLOPs.

Watch

Extended reading notes

Core claim

The central claim is that the linear maps inside sum blocks of a probabilistic circuit do not need to be dense matrices, and that choosing them to be generalized Monarch matrices converts the main computational bottleneck of tensorized PCs into a surplus that can be spent on hidden size. Formally, multiplying two sum blocks with matrices $A$ and $B$ yields a sum block whose map is $A \otimes B$, and the identity $(A\otimes B)x = (B(Ax)^{\mathsf{T}})^{\mathsf{T}}$ shows this map can be executed with batched contractions instead of being materialized as a dense product. When the parameters are untied, this circuit-level fact becomes a family of Monarch linear layers, and multiplying $d$ circuits gives $d$-layer Monarch matrices that interpolate between Monarch and Butterfly sparsity. On Text8, LM1B, ImageNet32, and ImageNet64, PCs built with these layers outperform all compared tractable baselines and close part of the gap to less tractable diffusion and flow models, with better likelihood per FLOP than dense circuits at matched sizes.

Load-bearing premise

The method relies on the empirical pattern that, as models get bigger, the accuracy lost by using a fixed sparse pattern instead of a dense one shrinks fast enough that bigger sparse models beat smaller dense ones.

Editorial extensions

If this is right

Monarch-HMM with hidden size $2^{19}$ reaches 1.57 bits per character on Text8, improving on the dense HMM baseline whose hidden size is capped at $2^{15}$ by memory, while sampling about 200 times faster than the compared diffusion models.
On LM1B, Monarch-HMM attains 190.34 test perplexity, where no prior PC model could scale, versus 320.78 for the dense HMM baseline.
Monarch-HCLT attains 4.01 bpd (lossy) and 4.62 bpd (lossless) on ImageNet32, and 3.74 and 4.33 bpd on ImageNet64, outperforming prior PC models including LVD-PG.
At every FLOP budget tested on Text8, Monarch-HMM gives better bits per character than dense HMM, and sparser structures with more Monarch layers scale even better in FLOP efficiency, though at higher memory cost.
Up to 90% of Monarch-HMM hidden states can be pruned with no significant likelihood drop, indicating that the learned representations are sparse.

Reading between the lines

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

Editorial inference: if the dense-versus-Monarch likelihood gap keeps shrinking with hidden size, dense sum blocks in PCs may become unnecessary at scale, and the practical ceiling on PC size becomes memory for hidden-state caching rather than parameter cost.
Editorial inference: the same circuit-multiplication derivation that produces Monarch matrices could be used to derive other structured matrix families, such as block tensor-train layers, inside PCs with a probabilistic initialization semantics.
Editorial inference: the pruning result suggests combining Monarch layers with learned pruning of hidden states could remove the remaining memory bottleneck and push to even larger hidden sizes.
Editorial inference: a testable extension is Monarch-structured sum blocks in downstream applications such as controllable generation, where the exact tractability that PCs retain over diffusion models is the payoff.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Desk Editor's Note

read the letter

The math checks out, and this is a real advance for the probabilistic circuits subfield. The observation that circuit multiplication gives sum-block weights as a Kronecker product (Eq. 1) is clean, and the explicit materialization as interleaved sums and permutations is genuinely new. The generalization to multi-layer Monarch matrices and the butterfly connection (Theorem 3.4) are correct. The initialization by multiplying two smaller trained circuits is a practical trick that Table 2 shows works. On the empirical side, the scaling plots (Figures 4, 5, 7) support the main claim: at matched FLOPs, Monarch-HMM beats dense HMM, and the gap closes as hidden size grows. That is real evidence, not just a plausible story.

The soft spots are three, in increasing order of importance. First, the abstract overstates. The state-of-the-art claim is only among tractable models; the paper's own numbers are far from diffusion or flow models. The language should say that explicitly. Second, all headline numbers are single-run, with no error bars or seed variation. This is common in the PC literature, but given the size of the LM1B gap, a couple of seeds would help. Third, the load-bearing assumption is that the dense-versus-sparse gap shrinks as hidden size grows. The paper demonstrates that on Text8 and ImageNet with matched-size dense baselines, but not on LM1B, where the dense HMM baseline runs at a much smaller hidden size. The stress-test note makes a fair point: the LM1B improvement could be mostly capacity, not structure. The authors themselves flag this as Hypothesis 3, so it is not hidden, but the abstract's “superior scaling behavior” should be scoped to the data where it was actually tested.

None of this sinks the paper. The core mathematical contribution is sound, the code is released, and the practical gains in memory and FLOPs are real. The main fix is editorial: qualify the abstract, add seed variation, and either provide a smaller-scale token-level matched comparison or explicitly disclaim transfer to LM1B. I would send this to serious referees, and I would cite it in any work on scaling tractable models.

Referee Report

3 major / 5 minor

Summary. This paper proposes replacing the dense sum-block matrices in tensorized probabilistic circuits with Monarch-structured matrices. Section 3 derives the construction from circuit multiplication: multiplying two sum blocks yields a Kronecker-product weight matrix that can be materialized with O(m^3) rather than O(m^4) edges (Eq. 1), and the d-layer extension in Definition 3.2 connects generalized Monarch matrices to butterfly matrices (Theorem 3.4). Section 4 discusses initialization by multiplying smaller dense PCs and training via stochastic EM. Experiments on Text8, LM1B, ImageNet32, and ImageNet64 report improvements over PC baselines and better FLOPs-versus-likelihood scaling than dense circuits.

Significance. The core derivation is correct, and the paper's empirical scaling comparisons on Text8 (Figure 4 and Table 6) and ImageNet (Figure 7) directly support the main efficiency claim: at matched FLOPs, Monarch-structured circuits reach lower BPC than dense circuits. If the results hold, this is a practically important step for scaling tractable probabilistic models, reducing per-layer cost from O(h^2) to O(h^{3/2}) while providing a principled circuit-multiplication initialization. The paper's strengths include a public code release, exact FLOP reporting, and a falsifiable scaling comparison.

major comments (3)

[Section 4 / Definition 3.1] The paper does not specify how the Monarch factor tensors A and B are constrained so that the resulting sum blocks form a valid, normalized PC. Definition 2.1 requires non-negative sum weights that sum to one per sum node, but no parameterization or EM update is given for the factorized weights; without such a description, the 'likelihoods' reported in Tables 1, 4, and 5 and the stochastic-EM training described in Section 4 are not well-defined. Please state the normalization constraint on the slices of A and B (e.g., row-normalize each slice) and give the corresponding EM updates, or explicitly describe a global renormalization procedure.
[Section 5.3, Table 4] The LM1B experiment compares Monarch-HMM against a single dense HMM at a much smaller hidden size, so the perplexity gain from 320.78 to 190.34 conflates increased hidden capacity with the Monarch structure. Because Section 5.1 states that dense HMM uses the largest hidden size that fits in memory while the Monarch model uses h=2^19, the 'superior scaling behavior' claim in the abstract is not directly verified on token-level data. Please add a matched-FLOP or matched-parameter dense (or alternative structured) baseline on LM1B, or explicitly qualify the scaling claim as an extrapolation from the Text8 and ImageNet experiments.
[Section 5.2, Figure 5] Hypothesis 3 ('Increasing model size induces sparsity') is load-bearing for the paper's central scaling argument, but it is only supported indirectly by the closing gap between dense and Monarch BPC as hidden size grows. No direct measurement of weight sparsity in trained dense sum blocks is provided, and the pruning experiment in Figure 6 concerns hidden-state activations rather than sum-block weights. Please provide a more direct test of the sparsity hypothesis or soften the claim that larger models are 'inherently more sparse'.

minor comments (5)

[Section 5.2] There are typos in Section 5.2: 'dimish' should be 'diminishes' and 'differernt' should be 'different'; Section 5.3 contains 'tims' instead of 'times'.
[Section 5.2, Table 3] The complexity expression 'O(dhd+1/d)' in the text should read O(d h^{(d+1)/d}) or O(d h^{1+1/d}) to be consistent with Table 3.
[Figure 7] Figure 7's caption says 'Results for Training on ImageNet32 Dataset,' but the corresponding text discusses ImageNet64; please verify the intended dataset.
[Tables 1 and 4] Tables 1 and 4 use the header 'Time (s) (↓)' for sampling time; the captions should state this consistently to avoid ambiguity.
[Table 3] Table 3 reports GPU memory in GB without stating the assumed bytes per element or the treatment of parameter caching versus hidden-state caching; please add these details for reproducibility.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the Monarch-PC construction rests on a mathematical identity and independent benchmark measurements, not on fitted inputs or self-citation chains.

full rationale

The paper's central derivation is a mathematical identity: the Kronecker product (A⊗B)x is rewritten as (B(Ax)^T)^T, which is then generalized by untying parameters to define Monarch matrices (Section 3.1, Eq. 1; Definition 3.1). This is a self-contained algebraic construction, not an equivalence to the paper's own empirical outputs. The claimed O(h^{3/2}) complexity follows directly from the structure of the construction and is not a fitted value later reported as a prediction. The circuit-multiplication initialization is explicitly tested as an ablation (Table 2) and is not presented as a derived prediction. The scaling claims (Figures 4, 5, 7) are empirical measurements of BPC versus FLOPs comparing Monarch and dense circuits; they are not outputs of the theory. The LM1B result lacks a matched-hidden-size dense baseline, but the paper itself frames it as a proof-of-concept, and that is an empirical comparability limitation rather than a circular step. Self-citations (e.g., Dang et al. 2022 for sparsity motivation) are used as background motivation, not as the load-bearing justification for the Monarch construction or its measured performance. No equation, definition, or fitted parameter is shown to reduce by construction to the claims being made.

Assumptions & free parameters 3 free parameters · 6 assumptions · 0 invented entities

No new entities are postulated. The generalized Monarch matrices are redefinitions of existing structured matrix families in a PC context; they are mathematical objects with the same parameter count as known Monarch and butterfly matrices, not new physical or probabilistic entities.

free parameters (3)

hidden size h = up to 2^19 (524288) for Text8; m=16384 for ImageNet
Chosen as the largest size fitting in GPU memory; the scaling claims depend on the ability to increase h.
Monarch layer count d = 2 (main), 3, 4 (ablations)
Selecting d trades FLOPs against memory; d=2 used for main results, d=3 and 4 for scaling analysis.
image training hyperparameters = mini-batch 20000, epochs 20
Chosen by hyperparameter search over mini-batch in [1000,5000,20000,60000] and epochs in [5,10,20], so performance depends on these choices.

assumptions (6)

standard math Kronecker product identity vec(BXA^T) = (A⊗B)vec(X)
Used in Eq. 1 to factor the product of two sum-block matrices.
domain assumption Circuit multiplication can build a tractable PC for p_A(x)p_B(x) when A and B share a vtree
From Shen et al. 2016 and Vergari et al. 2021; the paper relies on this to interpret the Kronecker product as a circuit.
domain assumption Smoothness and decomposability are preserved by the Monarch construction
The materialization of Eq. 1 as alternating sum and transpose blocks must keep product nodes decomposable and sum nodes smooth; the paper asserts this without a formal proof.
ad hoc to paper Learned dense PC weights are sparse, and this sparsity is approximately structured
Motivates the fixed Monarch sparsity pattern; supported by Dang et al. 2022 for sparsity and by the paper's Figure 5 showing the gap shrinks with hidden size, but the structure assumption itself is an empirical bet.
ad hoc to paper Stochastic mini-batch EM converges to good parameters at hidden sizes up to 2^19
All results depend on EM optimization succeeding at scale; no convergence guarantee is given, and only 20 epochs are used.
standard math The YCoCg-R transform is exactly invertible in integer arithmetic
Appendix B.3 gives the inverse; this justifies comparing likelihoods on transformed and original RGB data.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Scaling Probabilistic Circuits via Monarch Matrices." pith.science (2026). https://pith.science/paper/KQAYMYU4

@misc{pith2026250612383,
  author       = {Pith},
  title        = {Pith review of: Scaling Probabilistic Circuits via Monarch Matrices},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/KQAYMYU4}},
  note         = {Machine review of arXiv:2506.12383}
}

read the original abstract

Probabilistic Circuits (PCs) are tractable representations of probability distributions allowing for exact and efficient computation of likelihoods and marginals. Recent advancements have improved the scalability of PCs either by leveraging their sparse properties or through the use of tensorized operations for better hardware utilization. However, no existing method fully exploits both aspects simultaneously. In this paper, we propose a novel sparse and structured parameterization for the sum blocks in PCs. By replacing dense matrices with sparse Monarch matrices, we significantly reduce the memory and computation costs, enabling unprecedented scaling of PCs. From a theory perspective, our construction arises naturally from circuit multiplication; from a practical perspective, compared to previous efforts on scaling up tractable probabilistic models, our approach not only achieves state-of-the-art generative modeling performance on challenging benchmarks like Text8, LM1B and ImageNet, but also demonstrates superior scaling behavior, achieving the same performance with substantially less compute as measured by the number of floating-point operations (FLOPs) during training.

Figures

Figures reproduced from arXiv: 2506.12383 by the authors.

**Figure 1.** Probabilistic circuits architecture illustration with Monarch matrices. (a) Two sum blocks in PCs with weight matrices A, B of arbitrary dimensions. (b) A constructed sum block with weight matrix as the Kronecker product A ⊗ B, representing the circuit product of two sum blocks. (c) Efficient circuit representation for the linear transformation A ⊗ B. TRANSPOSE TRANSPOSE Ai : r × p A1 A2 Aq B1 B2 Br Bi : s × q [PIT… view at source ↗

**Figure 2.** Generalized two-layer Monarch matrix. the resulting circuit exhibits structured sparsity, leading to PCs parameterized by Monarch matrices. In Section 3.2, we extend this analysis to the multiplication of more than two PCs, and derive a new multi-layer Monarch matrix parameterization. Finally, in Section 3.3, for a PC with hidden size h, we show how this can be used to control the compute and memory used between O(… view at source ↗

**Figure 3.** Illustration of Butterfly factors (Meng et al., 2022). Examples of butterfly factors for D = 16 are shown in [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗

Figures from the paper (5 more)

**Figure 4.** Figure 4 [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]

**Figure 5.** Figure 5: Test set BPC as a function of hidden size for [PITH_FULL_IMAGE:figures/full_fig_p007_5.png]

**Figure 6.** Figure 6: We can effectively prune up to 90% hidden states [PITH_FULL_IMAGE:figures/full_fig_p007_6.png]

**Figure 7.** Figure 7: Results for Training on ImageNet32 Dataset. Test bits-per-dimension (↓) as a function of training FLOPs per pixel. Monarch-HCLT demonstrates greater efficiency than HCLT as the computation budget increases. spectively. Our work tackles an orthogonal aspect in that it f…

**Figure 8.** Figure 8: Illustration of Butterfly factors (Meng et al., 2022). Examples of butterfly factors for D = 16 are shown in [PITH_FULL_IMAGE:figures/full_fig_p013_8.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

13 extracted references · 9 canonical work pages

[2]

•B(i, D)is a block-diagonal matrix with block size D 2i−1 × D 2i−1 , where each block is aB 1, D 2i−1 butterfly factor

Definition A.1(Butterfly Factor).Given any D= 2d and 1≤i≤d , a butterfly factor matrix B(i, D)is a sparse matrix with the following sparsity pattern: •B(1, D)has non-zero elements only along the diagonals of the four D 2 × D 2 submatrices. •B(i, D)is a block-diagonal matrix with block size D 2i−1 × D 2i−1 , where each block is aB 1, D 2i−1 butterfly facto...

work page 2022
[3]

Notice that the delta functions require (for a non-zero entry) that j(i) c =j (i+1) c whenever c̸=i

For each of the butterfly factors, let us write: B(i,2 d)j(i) 1 j(i) 2 ...j(i) d ,j(i+1) 1 j(i+1) 2 ...j(i+1) d :=A(i,2 d)j(i) i ,j(i) 1 ,...,j(i) i−1,j(i) i+1,...,j(i) d ,j(i+1) i Y c̸=i δj(i+1) c j(i) c where we have attached a superscript to each index to indicate it is associated with the ith butterfly factor; in particular, j(1) c =j c andj (d) c =j ...

work page 2024
[6]

Maene, J., Derkinderen, V ., and Martires, P. Z. D. Klay: Accelerating neurosymbolic ai.arXiv preprint arXiv:2410.11415,

work page Pith review arXiv
[1970]

One billion word benchmark for measuring progress in statistical language modeling

Chelba, C., Mikolov, T., Schuster, M., Ge, Q., Brants, T., Koehn, P., and Robinson, T. One billion word benchmark for measuring progress in statistical language modeling. arXiv preprint arXiv:1312.3005,

arXiv
[1995]

On the latent variable interpretation in sum-product networks

Peharz, R., Gens, R., Pernkopf, F., and Domingos, P. On the latent variable interpretation in sum-product networks. IEEE transactions on pattern analysis and machine intel- ligence, 39(10):2030–2044,

work page
[2011]

Accessed: 2024-12-1

URL http:// mattmahoney.net/dc/text8.zip. Accessed: 2024-12-1. Malvar, H. and Sullivan, G. Ycocg-r: A color space with rgb reversibility and low dynamic range.ISO/IEC JTC1/SC29/WG11 and ITU-T SG16 Q, 6,

work page 2024
[2013]

Tractable learning for structured probability spaces: A case study in learning preference distributions

Choi, A., Van den Broeck, G., and Darwiche, A. Tractable learning for structured probability spaces: A case study in learning preference distributions. InProceedings of 24th International Joint Conference on Artificial Intelligence (IJCAI), volume 2015, pp. 2861–2868. IJCAI-INT JOINT CONF ARTIF INTELL,

work page 2015
[2018]

Kingma, D. P. and Welling, M. Auto-encoding variational bayes.arXiv preprint arXiv:1312.6114,

arXiv

Show all 13 references

[2019]

Interpolating Butterfly and Monarch Matrices Butterfly matrices (Dao et al., 2019; Meng et al.,

12 Scaling Probabilistic Circuits via Monarch Matrices A. Interpolating Butterfly and Monarch Matrices Butterfly matrices (Dao et al., 2019; Meng et al.,

2019
[2021]

Scaling up probabilistic circuits by latent variable distillation

Liu, A., Zhang, H., and Van den Broeck, G. Scaling up probabilistic circuits by latent variable distillation. In Proceedings of the International Conference on Learning Representations (ICLR), may 2023a. Liu, A., Ahmed, K., and Van den Broeck, G. Scaling tractable probabilisti...

arXiv
[2022]

They are constructed as the product of sparse matrices known as butterfly factor matrices (Parker, 1995)

are a class of expressive structured matrices. They are constructed as the product of sparse matrices known as butterfly factor matrices (Parker, 1995). In this section, we will show how Butterfly matrices (products of sparse Butterfly factor matrices) can be viewed as general...

1995
[2024]

Argmax flows and multinomial diffusion: Towards non-autoregressive language models.arXiv preprint arXiv:2102.05379, 3(4):5,

Hoogeboom, E., Nielsen, D., Jaini, P., Forr´e, P., and Welling, M. Argmax flows and multinomial diffusion: Towards non-autoregressive language models.arXiv preprint arXiv:2102.05379, 3(4):5,

arXiv
[2025]

Ziegler, Z

URL https://arxiv.org/pdf/2411.12256. Ziegler, Z. and Rush, A. Latent normalizing flows for dis- crete sequences. InProceedings of the 36th International Conference on Machine Learning,

arXiv

Pith tools

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

[1] [2]

•B(i, D)is a block-diagonal matrix with block size D 2i−1 × D 2i−1 , where each block is aB 1, D 2i−1 butterfly factor

Definition A.1(Butterfly Factor).Given any D= 2d and 1≤i≤d , a butterfly factor matrix B(i, D)is a sparse matrix with the following sparsity pattern: •B(1, D)has non-zero elements only along the diagonals of the four D 2 × D 2 submatrices. •B(i, D)is a block-diagonal matrix with block size D 2i−1 × D 2i−1 , where each block is aB 1, D 2i−1 butterfly facto...

work page 2022

[2] [3]

Notice that the delta functions require (for a non-zero entry) that j(i) c =j (i+1) c whenever c̸=i

For each of the butterfly factors, let us write: B(i,2 d)j(i) 1 j(i) 2 ...j(i) d ,j(i+1) 1 j(i+1) 2 ...j(i+1) d :=A(i,2 d)j(i) i ,j(i) 1 ,...,j(i) i−1,j(i) i+1,...,j(i) d ,j(i+1) i Y c̸=i δj(i+1) c j(i) c where we have attached a superscript to each index to indicate it is associated with the ith butterfly factor; in particular, j(1) c =j c andj (d) c =j ...

work page 2024

[3] [6]

Maene, J., Derkinderen, V ., and Martires, P. Z. D. Klay: Accelerating neurosymbolic ai.arXiv preprint arXiv:2410.11415,

work page Pith review arXiv

[4] [1970]

One billion word benchmark for measuring progress in statistical language modeling

Chelba, C., Mikolov, T., Schuster, M., Ge, Q., Brants, T., Koehn, P., and Robinson, T. One billion word benchmark for measuring progress in statistical language modeling. arXiv preprint arXiv:1312.3005,

arXiv

[5] [1995]

On the latent variable interpretation in sum-product networks

Peharz, R., Gens, R., Pernkopf, F., and Domingos, P. On the latent variable interpretation in sum-product networks. IEEE transactions on pattern analysis and machine intel- ligence, 39(10):2030–2044,

work page

[6] [2011]

Accessed: 2024-12-1

URL http:// mattmahoney.net/dc/text8.zip. Accessed: 2024-12-1. Malvar, H. and Sullivan, G. Ycocg-r: A color space with rgb reversibility and low dynamic range.ISO/IEC JTC1/SC29/WG11 and ITU-T SG16 Q, 6,

work page 2024

[7] [2013]

Tractable learning for structured probability spaces: A case study in learning preference distributions

Choi, A., Van den Broeck, G., and Darwiche, A. Tractable learning for structured probability spaces: A case study in learning preference distributions. InProceedings of 24th International Joint Conference on Artificial Intelligence (IJCAI), volume 2015, pp. 2861–2868. IJCAI-INT JOINT CONF ARTIF INTELL,

work page 2015

[8] [2018]

Kingma, D. P. and Welling, M. Auto-encoding variational bayes.arXiv preprint arXiv:1312.6114,

arXiv