Pith. sign in

REVIEW 3 major objections 5 minor 63 references

Programming guide for solving constraint satisfaction problems with tensor networks

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

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

Pith's one-line read A constraint satisfaction problem can be encoded once as a tensor network, then contracted with different algebras to count solutions, find largest sizes, and sample configurations.

desk verdict A solid, practical programming guide that deserves referee time, but its core correctness claim rests on an unpublished reference and the overlap-gap evidence is asserted rather than proven. read the letter →

arxiv 2501.00227 v1 pith:UAC74SWA submitted 2024-12-31 physics.comp-ph

Xuanzhao Gao , Xiaofeng Li , Jinguo Liu This is my paper · ORCID
classification physics.comp-ph PACS 02.10.Ox02.10.Xm01.50.hv
keywords tensornetworksconstraintsatisfactionproblemsproblemreductionsJuliasolutionspacepropertiesoverlapgappropertycontractionordersemiring
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

The paper is a practical guide to solving and analyzing constraint satisfaction problems with tensor networks, using a Julia software ecosystem. Its central claim is that a CSP can be translated into a tensor network once, and then different questions about the solution space—how many solutions exist, how large the best solution is, what the full distribution of sizes is, and what the explicit configurations are—are answered by contracting that same network with different element types. This matters because solution-space structure, not just a single optimum, controls how hard a problem is for classical and quantum algorithms. The authors demonstrate the recipe on independent sets, spin glasses, factoring, and a buckyball Ising model, extracting quantities such as the hard-square entropy constant and overlap-gap signatures.

What carries the argument

The central mechanism is contraction of a tensor network with generic element types, where each constraint becomes a tensor and each shared variable becomes an index. A one-vertex independent-set term $W(n_v)$ is a rank-one tensor and each edge constraint $B(n_u,n_v)$ is a rank-two tensor; contracting over shared indices sums over assignments. Swapping the ring operations changes the result the contraction computes: the tropical semiring turns the sum over assignments into a maximum, so the contracted scalar is the largest feasible size, while polynomial coefficients accumulate counts of solutions at fixed sizes. The same contraction order can be reused for every property, and the paper also makes contraction-order optimization itself an ingredient, with heuristic methods such as greedy search, simulated-annealing local search, hypergraph bipartition, and exact treewidth decomposition.

What would settle it

On a small graph whose independent sets are known by brute force, contract the tensor network with GraphPolynomial() and generate_samples from a ConfigsAll tree; any coefficient mismatch or statistically significant sample bias would falsify the property-to-algebra mapping in Table 1 or the unbiased-sampling claim.

Watch

Extended reading notes

Core claim

The generic tensor network method is presented as a unified framework for solving constraint satisfaction problems: the desired property of the solution space is linked to the algebraic operations used during tensor network contraction. For example, contracting with ordinary real arithmetic gives the partition function; contracting with the tropical semiring, where addition becomes max and multiplication becomes addition, gives the largest solution size; polynomial-valued element types give counts at every size; and configuration-carrying element types enumerate or sample solutions. The paper shows that an optimized contraction order is key to making this practical, and it walks through the mapping between each property and its element type in a table. Concrete results include the hard-square entropy constant computed on square lattices up to side length 39, overlap-gap fingerprints in the Hamming-distance distribution of large solutions, reduction of factoring 221 into a 740-vertex independent-set problem on a unit disk graph, and a ground-state degeneracy of 16,000 for the 60-vertex buckyball antiferromagnet.

Load-bearing premise

The load-bearing premise is that using the correct number system for a question—tropical numbers for largest sizes, polynomials for counts, ordinary reals for partition functions—really returns the exact answer the table promises, and that sampling from the stored solution tree is unbiased.

Editorial extensions

If this is right

  • A single solve interface can return partition functions, total counts, maximum sizes, graph polynomials, largest-k solutions, and full configuration lists for a broad set of CSPs, as long as the problem is encoded as a tensor network.
  • Contraction-order optimization separates the cost of computing all these properties from the choice of property: one optimized order serves every algebra in the table.
  • Reductions between CSPs let a solver for one target problem solve many source problems; the examples factor 15 through a 63-vertex spin glass and 221 through a 740-vertex independent set on a unit disk graph.
  • Solution-space geometry can be studied without full enumeration: samples drawn from a sum-product tree estimate the Hamming-distance distribution of large solutions and expose the overlap gap property.
  • The authors warn that tensor networks are not the best tool for finding a single optimum on high-dimensional graphs; branching or local-search solvers can be preferable, while the tensor network method is intended for counting and solution-space analysis.

Reading between the lines

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

  • If the property-to-algebra mapping is sound, other solution-space observables expressible as semiring operations—for instance, moments or correlation functions of solution counts—could be added to the same table without changing the contraction machinery.
  • The overlap-gap diagnostics shown for King's subgraphs and 3-regular graphs could be used as a finite-size hardness predictor for other solvers, although the paper only demonstrates the diagnostic on the independent-set family.
  • A direct validation step suggested by Section 5.3 is to compare generate_samples against exact enumeration on small graphs; such a check would tell whether the large-problem overlap-gap evidence rests on unbiased sampling from the sum-product tree.
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.

Referee Report

3 major / 5 minor

Summary. The paper is a programming guide for the Julia ecosystem GenericTensorNetworks.jl, OMEinsum.jl, and ProblemReductions.jl. It introduces several constraint satisfaction problems, shows how to reduce them to each other, how to map a CSP to a tensor network, and how to optimize contraction orders. The central technical idea is that different solution-space properties (largest size, counting, enumeration, graph polynomials) are obtained by contracting the same tensor network with different generic element types. The paper closes with applications: the hard-square entropy constant, Hamming-distance-based evidence for the overlap gap property, a factoring-to-Ising reduction, and the Buckyball ground-state degeneracy. The code examples are concrete and several outputs are checked against externally known facts, such as the Petersen independence polynomial, 13 x 17 = 221, and the Buckyball degeneracy of 16000.

Significance. If the framework performs as claimed, the paper provides a practical, unified workflow for exact counting, enumeration, and sampling of CSP solution spaces on moderate-size instances, with potential value for researchers studying quantum and Ising-machine reductions. The reproducible Julia code and the verification of outputs against known exact results are clear strengths. However, the central property-to-algebra mapping is deferred to an unpublished reference, and the sampling and overlap-gap claims are asserted rather than demonstrated, so the 'unified framework' claim is currently conditional. These gaps do not indicate observed errors, but they need to be addressed before the paper can be fully relied upon as a self-contained guide.

major comments (3)
  1. [Section 5.3, Table 1] The property-to-algebra mapping in Table 1 is the load-bearing claim of the paper, but no proof or derivation is given for the listed generic element types. Section 5.3 states that 'the rigorous definition of the relevant algebra could be found in Ref. [35]', and Ref. [35] is marked unpublished. The verified examples (Petersen graph, hard-square entropy, Buckyball) cover only a subset of the table. Please provide a soundness argument for at least the nonstandard types (CountingTropical, TruncatedPoly, ExtendedTropical, LaurentPolynomial), or state explicitly that their correctness is asserted on the basis of an unpublished companion. Without this, a reader cannot verify that the 'unified framework' statement in Section 5.1 holds beyond the demonstrated cases.
  2. [Section 5.3, generate_samples] The text says that generate_samples returns 'a set of unbiased samples from the tree' without specifying the sampling algorithm or proving its correctness. Since Sections 6.2 and 6.3 use these samples to compute Hamming-distance distributions, the unbiasedness claim is load-bearing. Please provide the invariant used by generate_samples (for example, that each internal node's count equals the number of leaves and that children are sampled with probability proportional to count) or qualify the statement as a heuristic. At present this is an unverified assertion.
  3. [Sections 6.2 and 6.3, Figures 9 and 10] The overlap gap property is inferred from the presence of multiple peaks in Hamming-distance histograms of 10,000 samples from the largest two solution sizes. No formal definition of OGP is given, no error bars or statistical tests are reported, and each conclusion rests on a single graph instance. Please state the exact operational criterion used to decide 'multiple peaks', and label the finding as suggestive evidence rather than as a detection of OGP. If OGP is meant in the rigorous sense of Ref. [22], the histogram evidence is insufficient.
minor comments (5)
  1. [Section 2.1.1] The phrase 'no two of which are adjacnet' contains a typo: it should be 'adjacent'.
  2. [Section 4.2.2] The sentence 'thethetransfromationisacceptedwithaprobabilitygivenbytheMetropoliscriterion' is missing spaces and contains the typo 'transfromation'; it should read 'the transformation is accepted with a probability given by the Metropolis criterion'.
  3. [Section 6.4] The word 'chanllenge' in 'the chanllenge problem' should be 'challenge'.
  4. [Figure 1] The figure label 'ProblemReduction.jl' is inconsistent with the package name 'ProblemReductions.jl' used elsewhere; please make the label consistent.
  5. [Section 5.2] For the SizeMax(2) output, the text says 'largest two sizes' but both returned entries are 4.0; this is a degeneracy of the largest size rather than two distinct size values. The wording should be clarified to avoid confusion.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the paper's tensor-network-to-property mapping is either explicitly constructed or checked against external facts, and the deferred unpublished self-citation is a verification gap, not a circular reduction.

full rationale

No circular step is present. Section 3 constructs the tensor network directly from the energy model (Eqs. 2-7), so partition-function and counting outputs are derived from the problem definition rather than fitted to the answers. The generic element-type rows of Table 1 are not re-derived in this guide, but the paper exercises them against externally checkable facts: the Petersen graph counts (76 total, independence polynomial 1+10x+30x^2+30x^3+5x^4, and 5 maximum independent sets), the hard-square entropy sequence, the factored instance with 13x17=221, and the Buckyball ground-state degeneracy 16000. The passage 'The rigorous definition of the relevant algebra could be found in Ref. [35]' is explicitly flagged: Ref. [35] is unpublished and authored by the same lead group, and the paper does not spell out the algebra's correctness proof. That is a transparency and verification limitation, but not circularity, because the reported quantities are not defined as the algorithm's output and no fitted parameter is renamed as a prediction. The unbiased-sampling claim for generate_samples likewise lacks a proof in the text, but no equation shows the sample distribution being assumed into the SumProductTree construction; it is an unproved correctness property rather than a circular one. Overall, the central workflow is self-contained or independently checkable, so the circularity burden is not met.

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

The paper introduces no fitted scientific parameters. Software hyperparameters such as TreeSA weights and GreedyMethod coefficients are user choices in examples, not quantities the central claims depend on. The central workflow assumes the standard mapping from CSP energy models to tensor networks, the correctness of semiring-valued contraction, and, for the OGP sections, unbiased sampling and a specific interpretation of Hamming-distance structure. The last two are asserted rather than proved, so they carry the bulk of the paper's interpretive risk.

assumptions (4)
  • standard math A CSP energy model with per-constraint energy terms defines a partition function that is exactly a tensor network.
    Section 3.1, Eqs. (2)-(3); this is the standard construction used throughout the paper.
  • domain assumption Hard constraints can be encoded as zero entries in edge tensors, such as B = [[1,1],[1,0]] for independent sets, without altering the count of valid configurations.
    Section 3.2, Eqs. (5)-(6); standard but relies on interpreting zero as an absorbing element in the contraction algebra.
  • domain assumption Contracting a tensor network with a given semiring element type yields the corresponding solution-space property, such as tropical max-plus for maximum size.
    Sections 5.1-5.3 and Table 1; correctness is delegated to Refs. [33] and [35], one of which is unpublished.
  • ad hoc to paper generate_samples returns unbiased samples from the sum-product tree, and multiple Hamming-distance peaks indicate the overlap gap property.
    Section 5.3 (unbiased sampling) and Sections 6.2-6.3 (OGP from Hamming peaks); both are asserted without proof or a formal criterion and support the example analyses.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Programming guide for solving constraint satisfaction problems with tensor networks." pith.science (2026). https://pith.science/paper/UAC74SWA

@misc{pith2026250100227,
  author       = {Pith},
  title        = {Pith review of: Programming guide for solving constraint satisfaction problems with tensor networks},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/UAC74SWA}},
  note         = {Machine review of arXiv:2501.00227}
}
read the original abstract

Constraint satisfaction problems (CSPs) are a class of problems that are ubiquitous in science and engineering. It features a collection of constraints specified over subsets of variables. A CSP can be solved either directly or by reducing it to other problems. This paper introduces the Julia ecosystem for solving and analyzing CSPs, focusing on the programming practices. We introduce some of the important CSPs and show how these problems are reduced to each other. We also show how to transform CSPs into tensor networks, how to optimize the tensor network contraction orders, and how to extract the solution space properties by contracting the tensor networks with generic element types. Examples are given, which include computing the entropy constant, analyzing the overlap gap property, and the reduction between CSPs.

Figures

Figures reproduced from arXiv: 2501.00227 by the authors.

Figure 1
Figure 1. The generic tensor network framework for solution space analysis of constraint satisfaction problems [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. A gallery of CSPs and their reductions in [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. The types of graphs used in the partition function calculation. (a) is the famous Petersen graph, (b) [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (8 more)
Figure 4
Figure 4. Figure 4: The workflow of problem reduction in ProblemReductions.jl. extract the solution for source problem by extract_solution function. In the following example, we convert an integer factorization problem to a circuit satisfiability problem with a direct reduction rule. ✞ ☎ …
Figure 5
Figure 5. Figure 5: The time to contract the tensor network versus the time to optimize the contraction order. The [PITH_FULL_IMAGE:figures/full_fig_p016_5.png]
Figure 6
Figure 6. Figure 6: The four basic local transformations on the contraction tree, which preserve the result of the contrac [PITH_FULL_IMAGE:figures/full_fig_p017_6.png]
Figure 7
Figure 7. Figure 7: The entropy constant for the square lattice graph. [PITH_FULL_IMAGE:figures/full_fig_p025_7.png]
Figure 8
Figure 8. Figure 8: The pair-wise Hamming distance distribution of solutions at different energies for graphs with and [PITH_FULL_IMAGE:figures/full_fig_p025_8.png]
Figure 9
Figure 9. Figure 9: The number of solutions at different sizes for (a) a [PITH_FULL_IMAGE:figures/full_fig_p026_9.png]
Figure 10
Figure 10. Figure 10: The Hamming distance distribution for the maximum 2 solutions of the independent set problem [PITH_FULL_IMAGE:figures/full_fig_p028_10.png]
Figure 11
Figure 11. Figure 11: The Buckyball structure (fullerene). This problem can be easily solved by using the GenericTensorNetworks.jl package as follows. ✞ ☎ julia> using GenericTensorNetworks, Graphs, ProblemReductions julia> function fullerene() # construct the fullerene graph in 3D space t…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

63 extracted references · 60 canonical work pages

  1. [35]

    Lukin, Hannes Pichler, and Sheng-Tao Wang

    Jin-Guo Liu, Jonathan Wurtz, Mihn-Thi Nguyen, Mikhail D. Lukin, Hannes Pichler, and Sheng-Tao Wang. Computer-assisted gadget design and problem reduction of unweighted maximum independent set.unpub- lished, 2024

    work page 2024

  2. [22]

    Proceedings of the National Academy of Sciences, 118(41), 2021

    David Gamarnik. Proceedings of the National Academy of Sciences, 118(41), 2021

    work page 2021

  3. [1]

    A First-Order Logic Davis-Putnam-Logemann-Loveland Procedure.AI in the new Millenium, Morgan Kaufmann, Seattle, 2002

    Peter Baumgartner et al. A First-Order Logic Davis-Putnam-Logemann-Loveland Procedure.AI in the new Millenium, Morgan Kaufmann, Seattle, 2002

    work page 2002

  4. [2]

    R. J. Baxter, I. G. Enting, and S. K. Tsang.Journal of Statistical Physics, 22(4):465–489, 1980

    work page 1980

  5. [3]

    Tim Besard, Christophe Foket, and Bjorn De Sutter.CoRR, abs/1712.03112, 2017

    work page Pith review arXiv 2017

  6. [4]

    Why is Julia fast? Can it be faster?

    J. Bezanson. “Why is Julia fast? Can it be faster?” 2015, JuliaCon India.https://www.youtube.com/ watch?v=xUP3cSKb8sI

    work page 2015

  7. [5]

    Jeff Bezanson, Stefan Karpinski, Viral B Shah, and Alan Edelman.arXiv preprint arXiv:1209.5145, 2012

    arXiv 2012

  8. [6]

    IOS press, 2009

    Armin Biere, Marijn Heule, and Hans van Maaren.Handbook of Satisfiability, volume 185. IOS press, 2009

    work page 2009

Show all 63 references
  1. [7]

    Conflict-Driven Clause Learning Sat Solvers

    Armin Biere, Marijn Heule, Hans van Maaren, and Toby Walsh. Conflict-Driven Clause Learning Sat Solvers. Handbook of Satisfiability, Frontiers in Artificial Intelligence and Applications, pages 131–153, 2009

    2009

  2. [8]

    Vincent Bouchitté and Ioan Todinca.SIAM Journal on Computing, 31(1):212–232, 2001

    2001

  3. [9]

    Pardalos.Maximum Independent Set and Related Problems, with Appli- cations

    Sergiy Butenko and Panagote M. Pardalos.Maximum Independent Set and Related Problems, with Appli- cations. PhD thesis, USA, 2003

    2003

  4. [10]

    Lukin, July 2023

    Madelyn Cain, Sambuddha Chattopadhyay, Jin-Guo Liu, Rhine Samajdar, Hannes Pichler, and Mikhail D. Lukin, July 2023

    2023

  5. [11]

    Gregory J Chaitin.ACM Sigplan Notices, 17(6):98–101, 1982

    1982

  6. [12]

    Vasek Chvatal.Mathematics of operations research, 4(3):233–235, 1979. 30

    1979

  7. [13]

    Clark, Charles J

    Brent N. Clark, Charles J. Colbourn, and David S. Johnson.Annals of Discrete Mathematics, 48(C):165– 177, 1991

    1991

  8. [14]

    A Compendium of NP optimization Problems, 1995

    Pierluigi Crescenzi, Viggo Kann, and M Halldórsson. A Compendium of NP optimization Problems, 1995

    1995

  9. [15]

    InProceedings 2001 IEEE international conference on data mining, pages 107–114

    Chris HQ Ding, Xiaofeng He, Hongyuan Zha, Ming Gu, and Horst D Simon. InProceedings 2001 IEEE international conference on data mining, pages 107–114. IEEE, 2001

    2001

  10. [16]

    Sepehr Ebadi, Alexander Keesling, Madelyn Cain, Tout T Wang, Harry Levine, Dolev Bluvstein, Giulia Semeghini, Ahmed Omran, J-G Liu, Rhine Samajdar, et al.Science, 376(6598):1209–1215, 2022

    2022

  11. [17]

    Canadian Journal of mathematics, 17:449–467, 1965

    Jack Edmonds. Canadian Journal of mathematics, 17:449–467, 1965

    1965

  12. [18]

    Edward J Farrell.Journal of Combinatorial Theory, Series B, 27(1):75–86, 1979

    1979

  13. [19]

    Gregory Matthew Ferrin. 2014

    2014

  14. [20]

    Matthew Fishman, Steven White, and Edwin Stoudenmire.SciPost Physics Codebases, August 2022

    2022

  15. [21]

    Fedor V Fomin and Petteri Kaski.Communications of the ACM, 56(3):80–88, 2013

    2013

  16. [23]

    Xuan-Zhao Gao, Yi-Jia Wang, Pan Zhang, and Jin-Guo Liu.arXiv:2412.07685, 2024

    2024 arXiv

  17. [24]

    Fred Glover, Gary Kochenberger, and Yu Du.arXiv preprint arXiv:1811.11538, 2018

    2018 arXiv

  18. [25]

    Hyper-Optimized Tensor Network Contraction

    Johnnie Gray and Stefanos Kourtis. Hyper-Optimized Tensor Network Contraction. Quantum, 5:410, March 2021

    2021

  19. [26]

    In Proceedings of 37th Conference on Foundations of Computer Science, pages 627–636

    Johan Hastad. In Proceedings of 37th Conference on Foundations of Computer Science, pages 627–636. IEEE, 1996

    1996

  20. [27]

    John Wiley & Sons, 2011

    Tommy R Jensen and Bjarne Toft.Graph Coloring Problems. John Wiley & Sons, 2011

    2011

  21. [28]

    Gleb Kalachev, Pavel Panteleev, and Man-Hong Yung.arXiv preprint arXiv:2108.05665, 2021

    2021 arXiv

  22. [29]

    Gleb Kalachev, Pavel Panteleev, and Man-Hong Yung, 2022

    2022

  23. [30]

    Springer, 2010

    Richard M Karp.Reducibility Among Combinatorial Problems. Springer, 2010

    2010

  24. [31]

    Werneck.J

    Sebastian Lamm, Peter Sanders, Christian Schulz, Darren Strash, and Renato F. Werneck.J. Heuristics, 23(4):207–229, 2017

    2017

  25. [32]

    Hanson, David R Kincaid, and Fred T

    Chuck L Lawson, Richard J. Hanson, David R Kincaid, and Fred T. Krogh. ACM Transactions on Mathematical Software (TOMS), 5(3):308–323, 1979

    1979

  26. [33]

    Jin-Guo Liu, Xun Gao, Madelyn Cain, Mikhail D Lukin, and Sheng-Tao Wang.SIAM Journal on Scientific Computing, 45(3):A1239–A1270, 2023

    2023

  27. [34]

    Jin-Guo Liu, Lei Wang, and Pan Zhang.Physical Review Letters, 126(9):090506, 2021. 31

    2021

  28. [36]

    American Mathematical Soc., 2009

    László Lovász and Michael D Plummer.Matching Theory, volume 367. American Mathematical Soc., 2009

    2009

  29. [37]

    Mathematical Programming Computation, 15:581–589, 2023

    Miles Lubin, Oscar Dowson, Joaquim Dias Garcia, Joey Huchette, Benoît Legat, and Juan Pablo Vielma. Mathematical Programming Computation, 15:581–589, 2023

    2023

  30. [38]

    Frontiers in physics, 2:5, 2014

    Andrew Lucas. Frontiers in physics, 2:5, 2014

    2014

  31. [39]

    TensorOperations.jl, 10 2023

    Jutho Haegeman <jutho.haegeman@ugent.be> Lukas Devos <lukas.devos@ugent.be>, Maarten Van Damme <maartenvd1994@gmail.com> and contributors. TensorOperations.jl, 10 2023

    2023

  32. [40]

    Xiu-Zhe Luo, Jin-Guo Liu, Pan Zhang, and Lei Wang.Quantum, 4:341, October 2020

    2020

  33. [41]

    Enrico Malaguti and Paolo Toth.International transactions in operational research, 17(1):1–34, 2010

    2010

  34. [42]

    Markov and Yaoyun Shi.SIAM Journal on Computing, 38(3):963–981, January 2008

    Igor L. Markov and Yaoyun Shi.SIAM Journal on Computing, 38(3):963–981, January 2008

    2008

  35. [43]

    Marc Mézard, Giorgio Parisi, Nicolas Sourlas, Gérard Toulouse, and Miguel Virasoro.Journal de Physique, 45(5):843–854, 1984

    1984

  36. [44]

    Naeimeh Mohseni, Peter L McMahon, and Tim Byrnes.Nature Reviews Physics, 4(6):363–379, 2022

    2022

  37. [45]

    A survey of Modern Integer Factorization Algorithms.CWI quarterly, 7(4):337–366, 1994

    Peter L Montgomery. A survey of Modern Integer Factorization Algorithms.CWI quarterly, 7(4):337–366, 1994

    1994

  38. [46]

    Oxford University Press, 2011

    Cristopher Moore and Stephan Mertens.The Nature of Computation. Oxford University Press, 2011

    2011

  39. [47]

    Majid Mumtaz and Luo Ping.Journal of Discrete Mathematical Sciences and Cryptography, 22(1):9–29, 2019

    2019

  40. [48]

    PRX Quantum, 4(1):010316, 2023

    Minh-Thi Nguyen, Jin-Guo Liu, Jonathan Wurtz, Mikhail D Lukin, Sheng-Tao Wang, and Hannes Pichler. PRX Quantum, 4(1):010316, 2023

    2023

  41. [49]

    Pearce and Katherine A

    Paul A. Pearce and Katherine A. Seaton.Journal of Statistical Physics, 53(5):1061–1072, 1988

    1988

  42. [50]

    (c), 2018

    Hannes Pichler, Sheng-tao Wang, Leo Zhou, Soonwon Choi, and Mikhail D Lukin. (c), 2018

    2018

  43. [51]

    Xingze Qiu, Peter Zoller, and Xiaopeng Li.PRX Quantum, 1(2):020311, November 2020

    2020

  44. [52]

    Christopher Rackauckas and Qing Nie.Journal of open research software, 5(1):15–15, 2017

    2017

  45. [53]

    Ronald C Read.Journal of combinatorial theory, 4(1):52–71, 1968

    1968

  46. [54]

    Martin Roa-Villescas, Xuanzhao Gao, Sander Stuijk, Henk Corporaal, and Jin-Guo Liu.Phys. Rev. Res., 6:033261, Sep 2024

    2024

  47. [55]

    InProceedings of the tenth annual ACM symposium on Theory of computing, pages 216–226, 1978

    Thomas J Schaefer. InProceedings of the tenth annual ACM symposium on Theory of computing, pages 216–226, 1978. 32

    1978

  48. [56]

    ACM Journal of Experimental Algorithmics, 27:1–39, 2023

    Sebastian Schlag, Tobias Heuer, Lars Gottesbüren, Yaroslav Akhremtsev, Christian Schulz, and Peter Sanders. ACM Journal of Experimental Algorithmics, 27:1–39, 2023

    2023

  49. [57]

    Scott and Alan D

    Alexander D. Scott and Alan D. Sokal.Journal of Statistical Physics, 118(5-6):1151–1261, 2005

    2005

  50. [58]

    IEEE Transactions on parallel and distributed systems, 13(1):14–25, 2002

    Ivan Stojmenovic, Mahtab Seddigh, and Jovisa Zunic. IEEE Transactions on parallel and distributed systems, 13(1):14–25, 2002

    2002

  51. [59]

    Robert Endre Tarjan and Anthony E Trojanowski.SIAM Journal on Computing, 6(3):537–546, 1977

    1977

  52. [60]

    Hayato Ushijima-Mwesigwa, Christian F. A. Negre, and Susan M. Mniszewski, May 2017

    2017

  53. [61]

    Leslie G Valiant.SIAM Journal on Computing, 8(3):410–421, 1979

    1979

  54. [62]

    Qinghua Wu and Jin-Kao Hao.European Journal of Operational Research, 242(3):693–709, 2015

    2015

  55. [63]

    Mingyu Xiao and Hiroshi Nagamochi.Theoretical Computer Science, 469:92–104, 2013. 33

    2013

Pith tools

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