Pith. sign in

REVIEW 4 major objections 4 minor 30 references

Covert Computation in Self-Assembled Circuits

T0 review · 4 major / 4 minor · reviewed 2026-08-14 · deepseek-v4-flash

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

Pith's one-line read A tile-assembly system can compute any boolean function while concealing its input and history.

desk verdict Clear, useful paper with a real new complexity result, but correctness rests on hand-verified gadget properties that should be checked formally or exhaustively. read the letter →

arxiv 1908.06068 v2 pith:WTT5DW32 submitted 2019-08-16 cs.ET cs.CR

Angel A. Cantu , Austin Luchsinger , Robert Schweller , Tim Wylie This is my paper · ORCID
classification cs.ETcs.CR
keywords covertcomputationtileself-assemblyabstractAssemblyModelnegativegluescoNP-completeuniqueverificationdual-raillogicmolecularcryptography
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

Tile self-assembly, the paper argues, can be made covert: the final crystal reports the output of a boolean function but leaves no visible trace of the input bits or of the order in which tiles attached. The paper builds a functionally complete set of covert logic gates—variables, wires, NOT, NAND, and FANOUT—inside the growth-only variant of the abstract Tile Assembly Model, where negative-strength glues act purely as blockers. It then proves that any function computable by a boolean circuit admits a tile assembly computer that covertly computes it, and uses the same circuitry to prove that Unique Assembly Verification in this model is coNP-complete, filling a known gap between the polynomial-time positive-glue case and the undecidable case with detachment. The stakes are practical as well as theoretical: covert molecular computation is a candidate mechanism for privacy-preserving biomedical diagnostics and molecular cryptography.

What carries the argument

The load-bearing machinery is a kit of covert gadgets: dual-rail wires, backfill stops, logic diodes, and NOT, NAND, and FANOUT tile sets. Each gadget uses negative-strength glues as one-way blockers and cooperative attachments—two strength-1 glues binding together—to make backfilling wait until the relevant input value is known. The central invariant is the backfill rule: after a gadget passes a value onward, the entire unused rail is filled in from the downstream side, so the finished assembly contains both possible paths of every wire and the build order is erased. This erasure is what makes the computation covert and is also what lets the gadgets be composed into arbitrary planar circuits without leaving traces of the inputs.

What would settle it

Run an exhaustive enumeration or a tile-assembly simulator on the Section 3 NAND gadget for each of the four input settings and check the nine listed properties: only the claimed output rail grows, the unused input rails are backfilled, and every producible assembly is stable at temperature τ. A single input setting that yields the wrong output, leaves a rail unfilled, or produces an unstable intermediate assembly would refute Theorem 1; for Theorem 2, the same test on the nondeterministic-seed system would expose a second terminal assembly for a satisfiable circuit.

Watch

Extended reading notes

Core claim

The paper's central claim is that covert computation is possible in general: for every function f computable by a boolean circuit, there is a tile assembly computer (TAC) whose terminal assembly depends only on the output f(b), not on the input b or on the assembly history. The proof works by implementing dual-rail logic with tiles: each bit travels on one of two adjacent wires, and once a gadget has read a value, the unused wire is backfilled retroactively so both wires are present in the final assembly. Because the final shape contains both rails of every wire, an observer cannot tell from the finished crystal which bits entered the computation. The same gadget set is then used to prove Theorem 2: deciding whether a growth-only negative-glue tile system uniquely produces a given assembly is coNP-complete, via a reduction from Planar Circuit SAT in which a nondeterministic seed guesses all inputs and the covertly computed output is the unique 'no' assembly iff the circuit is unsatisfiable.

Load-bearing premise

Both theorems rest on the unproven property lists of Section 3: each gadget's negative glues must block exactly as drawn, backfilling must fill every unused wire, and no intermediate assembly may be able to fall apart, so if any single gadget fails one of those behaviors, the covert-circuit simulation and the coNP-hardness reduction both collapse.

Editorial extensions

If this is right

  • Any boolean-circuit-computable function can be implemented as a covert tile system whose final assembly reveals only the function value, enabling privacy-preserving molecular diagnostics where the patient's biological input is not readable from the product.
  • The Unique Assembly Verification dichotomy in the aTAM becomes complete: polynomial time with only positive glues, coNP-complete with negative glues under growth-only, and undecidable when detachment is allowed.
  • Covert computation can be composed from functionally complete NAND and FANOUT gadgets, so circuit designers do not need a crossover gadget; planarity is handled by XOR-from-NAND constructions.
  • The construction provides a concrete template for any future covert tile assembly computer, including the half-adder and multiplier examples used as stepping stones toward molecular cryptography.

Reading between the lines

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

  • The backfill-and-block design principle likely transfers beyond the specific aTAM gadgets: any self-assembly model that supports two-valued cooperative binding and repulsive glues could implement the same dual-rail erasure strategy, so the result is a template rather than a one-off construction.
  • The coNP-completeness of Unique Assembly Verification suggests that negative glues add computational power not by enabling detachment but by letting a system delay commitment to a wire; a testable prediction is that weakening the growth-only promise even slightly changes the complexity boundary.
  • A concrete follow-up experiment would be to implement the NAND gadget in a DNA tile system or kinetic simulation and watch whether backfilling completes before off-path growth; the logic diodes predict that partial wires should stop cleanly at gadget boundaries, a signature that could be checked experimentally.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 4 minor

Summary. The paper introduces the notion of covert computation in tile self-assembly, formalized through Tile Assembly Computers (TACs), and presents a library of dual-rail logic gadgets -- variables, wires, backfill stops, logic diodes, NOT, NAND, and FANOUT -- built in the abstract Tile Assembly Model with positive and negative glues under a growth-only restriction. The authors claim that any function computed by a boolean circuit can be covertly computed by a TAC (Theorem 1), and they use the covert circuitry to show that Unique Assembly Verification in the growth-only negative-glue aTAM is coNP-complete (Theorem 2). The appendix-like sections give additional AND and OR gadgets, a half-adder, and discussions of cryptographic motivation. The central technical content is the correctness of the gadget constructions, on which both theorems rest.

Significance. If the construction is fully correct, the paper makes a noteworthy contribution to algorithmic self-assembly: it provides the first general framework for concealing input and computational history in aTAM computations, and it resolves the complexity of Unique Assembly Verification under negative glues with the growth-only restriction. The definitions of TACs and covert computation are useful formalizations, and the reduction from Planar Circuit SAT is conceptually clean. The paper is also honest about a previously corrected NAND bug, which signals the fragility of hand-verified gadget constructions. However, the correctness of the main theorems depends on a list of asserted gadget properties that are not formally proved, and at least one of those assertions (property 8 of Section 3.5) is not justified by the text. For this reason the result is plausible but not yet fully established.

major comments (4)
  1. [Section 3.5, property 8] The growth-only constraint is a universal condition: every producible assembly must be τ-stable, not merely the intended build order. The text justifies the additional negative glue nH by saying that "the build path is intentional" so that the tile with nH would be the last tile that could attach. This is not a proof: one must rule out all alternative attachment orders and all partial assemblies that could become unstable. Since property 8 is used in the NAND gadget, and Theorem 1 and Theorem 2 both rely on the NAND gadget, this gap is load-bearing. I request a formal proof, an inductive invariant, or an exhaustive computer-assisted verification of the growth-only property.
  2. [Section 3, gadget properties generally] The correctness of the NOT, NAND, and FANOUT gadgets is presented as lists of properties with informal explanations (e.g., Section 3.4 properties 1-6, Section 3.5 properties 1-9, Section 3.6 properties 1-4) rather than formal proofs. The paper's own statement that the NAND gadget had a backfill issue that "has been corrected" (Section 1) shows that these constructions are delicate. I recommend that the authors supply a rigorous proof of each gadget property, or at least a machine-checkable exhaustive verification, before the main theorems can be considered fully supported.
  3. [Theorem 1 proof] The proof text says that NAND gates are functionally complete and "these are easily transformed into Circuit SAT instances to compute any function that is in the class NP." This is inaccurate: functions computed by boolean circuits are non-uniform and are not restricted to NP. However, the construction in Section 3 already gives a direct simulation of arbitrary circuits by NAND and FANOUT gadgets, so the theorem can be proved without invoking NP or Circuit SAT. The proof should be rewritten to state the direct simulation.
  4. [Theorem 2 proof, coNP membership] The claim that any failure of unique assembly yields "a polynomially sized assembly that is inconsistent with A" needs a supporting argument. A valid certificate can be obtained by taking a growth path from the seed and stopping at the first assembly that is not a subassembly of the target A; a short argument bounding the size of that assembly is needed to make the coNP membership rigorous.
minor comments (4)
  1. [Throughout] There are several typographical errors, including "implementaiton" (Section 1), "assemby" (Section 2.3), "receieved" (Section 3.4), and "ouput" (Definition 2). The paper would benefit from a careful proofreading pass.
  2. [Section 3.4] The NOT gadget properties are explained with reference to Figure 6, but the figure does not show the logic diode that is part of the actual gadget in Figure 5b. It would improve clarity to either include the diode in the walkthrough or state explicitly that the properties are claimed for the version with the diode.
  3. [Section 4] In the reduction for Theorem 2, the sentence "If the circuit is not-satisfiable, then the final computation will be false regardless of the guessed input" should be phrased more carefully: the TAC computes the circuit for the nondeterministically chosen input, so for unsatisfiable circuits every possible evaluated input yields the unique false output assembly, which is the target assembly in the UAV instance.
  4. [Section 3.1] The variable gadget is described as having a negative glue between the true and false tiles, but the accompanying text could explain more explicitly why this prevents both tiles from attaching in the seed phase; the current phrasing "only the ti or fi tile may attach" is clear enough, but a bit more detail would help the reader verify the blocking mechanism.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the construction and the complexity reductions are self-contained, with load-bearing gadget properties asserted rather than circularly assumed.

full rationale

The paper's derivation chain is constructive rather than definitional. Theorem 1 asserts that any Boolean-circuit function can be covertly computed by a TAC; the proof supplies explicit covert variable, wire, NOT, NAND, and FANOUT gadgets in Section 3, and cites only external standard facts for functional completeness. No parameter is fitted to a target output, and the covert condition that all inputs mapping to the same output produce the same final assembly is a design specification enforced by backfilling, not an input assumed into the theorem. Theorem 2 reduces Planar Circuit SAT to Unique Assembly Verification using those same gadgets plus a nondeterministic input seed; the reduction's correctness depends on the Section 3 gadget properties, but that is ordinary logical dependence, not circularity. The only self-citation, reference [3], is a provenance note for the ICALP version and is not load-bearing, because the full construction appears in the present paper. The genuine correctness risk is that Section 3.5 property 8, the growth-only constraint for the H-NOT's extra negative glue, is supported only by the assertion that 'the build path is intentional to ensure this can not happen', and the paper itself notes that a NAND backfill issue 'has been corrected'. That is a soundness or verification gap in a hand-checked gadget construction, not a circular step: no equation or definition reduces the theorem's conclusion to its own assumptions.

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

The central claim rests on the informal correctness of the gadget constructions, which is the main unfounded premise. The remaining axioms are standard model and complexity background.

assumptions (6)
  • standard math The abstract Tile Assembly Model (aTAM) definitions, including the diagonal glue function property that only equal glue types interact.
    Section 2.2 defines the model; these are background assumptions from the self-assembly literature.
  • domain assumption The growth-only condition: all producible assemblies are tau-stable (no detachment).
    Section 2.2 restricts to valid growth-only systems; this is a modeling choice the paper relies on.
  • standard math NAND and FANOUT gates are functionally complete for Boolean circuits.
    Section 3.5, citing Sheffer [27].
  • standard math Circuit SAT is NP-complete.
    Section 4, citing Garey and Johnson [15].
  • standard math Planar Circuit SAT (with crossover implemented by XOR gates) is NP-complete.
    Section 4, citing Scott et al. [26] and deriving XOR from NANDs.
  • ad hoc to paper The covert gadgets (NOT, NAND, FANOUT, etc.) satisfy their stated properties.
    These properties are asserted in Section 3.4-3.6 without formal proof; the paper's theorems depend on them.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Covert Computation in Self-Assembled Circuits." pith.science (2026). https://pith.science/paper/WTT5DW32

@misc{pith2026190806068,
  author       = {Pith},
  title        = {Pith review of: Covert Computation in Self-Assembled Circuits},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/WTT5DW32}},
  note         = {Machine review of arXiv:1908.06068}
}
read the original abstract

Traditionally, computation within self-assembly models is hard to conceal because the self-assembly process generates a crystalline assembly whose computational history is inherently part of the structure itself. With no way to remove information from the computation, this computational model offers a unique problem: how can computational input and computation be hidden while still computing and reporting the final output? Designing such systems is inherently motivated by privacy concerns in biomedical computing and applications in cryptography. In this paper we propose the problem of performing ``covert computation'' within tile self-assembly that seeks to design self-assembly systems that ``conceal'' both the input and computational history of performed computations. We achieve these results within the growth-only restricted abstract Tile Assembly Model (aTAM) with positive and negative interactions. We show that general-case covert computation is possible by implementing a set of basic covert logic gates capable of simulating any circuit (functionally complete). To further motivate the study of covert computation, we apply our new framework to resolve an outstanding complexity question; we use our covert circuitry to show that the unique assembly verification problem within the growth-only aTAM with negative interactions is coNP-complete.

Figures

Figures reproduced from arXiv: 1908.06068 by the authors.

Figure 1
Figure 1. High-level overview of the aTAM with repulsive forces. Both systems have tiles that can attach to the seed tile given they can attach with τ strength. The arrows show the possible assembly paths from the seed tile with the terminal assembly being outlined. (a) A negative aTAM system that has a possible assembly path causing disassembly. One path is growth-only, but the other path can attach the tile with the purple/… view at source ↗
Figure 2
Figure 2. An example with two gadgets, A and B, to show how backfilling works in covert computation. (a) If true is output from Gadget A, that wire assembles to the next gadget. (b) Gadget B builds, and based on its function, outputs the true or false wire (false in this case). Once B received the input (the true wire assembles that then assembles B), it backfills the false wire towards A (the false wire cooperatively assembl… view at source ↗
Figure 3
Figure 3. (a) Example of the 4 possible input seeds for a half-adder from Section 5.2. (b) Variables are represented by a true and a false line where only one may exist. The variables build off the seed, but only the ti or the fi tile may attach due to the negative glue between the two tiles. (a) Backfill Stop (b) Logic Diode [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figures from the paper (10 more)
Figure 4
Figure 4. Figure 4: (a) A backfill stop. This ensures that the wire is allowed to backfill up to a certain point. (b) A gadget referred to as a logic diode. This ensures input from one direction and stops tiles from assembling in the wrong direction. creates a valid input over all possibl…
Figure 5
Figure 5. Figure 5: (a) Basic NOT gate (b) NOT gate with the logic diode on the input (c) A covert NOT gate with an additional negative horizontal glue on the output to prevent incorrect backfilling. This modification is needed when using this gate for the construction of the NAND gate. 1…
Figure 6
Figure 6. Figure 6: (a) A NOT gadget with true input t in i and output f out i . The true output can not place from tile x due to the negative glues n1 and n3 of strength −1. (b) Once the NOT gadget passes the false output, glues h3, h4 cooperatively allow the false portion and wire to ba…
Figure 7
Figure 7. Figure 7: (a) Diagram of the covert NAND gate with NOTs shown as blocks. The boxes for the NOT blocks are shown outlined in Figures 5b and 5c. The left box is the standard NOT gadget and the right box is the H-NOT gadget. (b) The full NAND gate with the two NOT gadgets filled in…
Figure 8
Figure 8. Figure 8: (a) FANOUT gadget. (b) True input wire for the FANOUT gadget t in i results in output wires t out1 i and t out2 i . (c) False input wire for the FANOUT gadget f in i results in output wires f out1 i and f out2 i . 7. The wire f out i is always placed. The glues a1, a2 …
Figure 9
Figure 9. Figure 9: Constructing planar crossover gadgets with NAND gates. (a) XOR symbol. (b) NAND symbol. (c) Two wires in a circuit that cross making it non-planar. (d) A planar circuit using XOR gates that act as a crossover. (e) A planar circuit using only NAND gates that implement a…
Figure 10
Figure 10. Figure 10: (a) Diagram of the covert AND gate with NOTs shown as blocks. The left box is the standard NOT gadget and the right box is the V-NOT gadget (has an additional vertical glue). (b) The full AND gate with the two NOT gadgets filled in and some simplification for space. “…
Figure 11
Figure 11. Figure 11: (a) Block diagram for the OR gadget. (b) The covert OR gadget with the NOT gadget block filled in with the tiles. 5.2 Encryption and Cryptography Several encryption methods are based off problems that we believe to be “hard” computationally. One of the most common is …
Figure 12
Figure 12. Figure 12: Constructing covert circuits for arithmetic building up to cryptography examples. (a) XOR symbol. (b) AND symbol. (c) A half-adder, which has two 1-bit numbers as input and a 2-bit number as output. (d) A 2-bit multiplier which has two 2-bit numbers as input and outpu…
Figure 13
Figure 13. Figure 13: Covert Half-Adder made with 4 NANDs, 3 FANOUTs, 2 NOTs, and 1 AND. The seed input is highlighted and all 4 possible seeds are shown in (a). Regardless of the seed, the final assembly will look identical except the final T/F representing the bits of the numbers added. …

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

30 extracted references · 30 canonical work pages

  1. [3]

    Cantu, Austin Luchsinger, Robert Schweller, and Tim Wylie

    Angel A. Cantu, Austin Luchsinger, Robert Schweller, and Tim Wylie. Covert Computa- tion in Self-Assembled Circuits. In Christel Baier, Ioannis Chatzigiannakis, Paola Flocchini, and Stefano Leonardi, editors, 46th International Colloquium on Automata, Languages, and Programming (ICALP 2019), volume 132 of Leibniz International Proceedings in Informatics (...

    work page 2019

  2. [1]

    Adleman, Qi Cheng, Ashish Goel, Ming-Deh A

    Leonard M. Adleman, Qi Cheng, Ashish Goel, Ming-Deh A. Huang, David Kempe, Pablo Mois- set de Espan´ es, and Paul W. K. Rothemund. Combinatorial optimization problems in self- assembly. In Proceedings of the 34th Annual ACM Symposium on Theory of Computing , pages 23–32, 2002

    work page 2002

  3. [2]

    Arithmetic computation in the tile assembly model: Addition and multiplication

    Yuriy Brun. Arithmetic computation in the tile assembly model: Addition and multiplication. Theoretical Comp. Sci., 378:17–31, 2007. 17

    work page 2007

  4. [4]

    Demiane, Martin L

    Cameron Chalk, Erik D. Demiane, Martin L. Demaine, Eric Martinez, Robert Schweller, Luis Vega, and Tim Wylie. Universal shape replicators via self-assembly with attractive and repulsive forces. In Proc. of the 28th Annual ACM-SIAM Symposium on Discrete Algorithms (SODA’17), 2017

    work page 2017

  5. [5]

    Self-assembly of any shape with constant tile types using high temperature

    Cameron Chalk, Austin Luchsinger, Robert Schweller, and Tim Wylie. Self-assembly of any shape with constant tile types using high temperature. In Proc. of the 26th Annual European Symposium on Algorithms, ESA’18, 2018

    work page 2018

  6. [6]

    Multiparty unconditionally secure protocols (abstract)

    David Chaum, Claude Crpeau, and Ivan Bjerre Damgrd. Multiparty unconditionally secure protocols (abstract). In Proc. of the 20th Annual ACM Symposium on Theory of Computing (STOC’88), pages 11–19, 1988

    work page 1988

  7. [7]

    Goldwasser, Ming-Yang Kao, Robert T

    Qi Cheng, Gagan Aggarwal, Michael H. Goldwasser, Ming-Yang Kao, Robert T. Schweller, and Pablo Moisset de Espan´ es. Complexities for generalized models of self-assembly. SIAM Journal on Computing , 34:1493–1515, 2005

    work page 2005

  8. [8]

    Liberton, and Katleen et al

    Peter Claes, Denise K. Liberton, and Katleen et al. Daniels. Modeling 3d facial shape from dna. PLOS Genetics, 10(3):1–14, 03 2014

    work page 2014

Show all 30 references
  1. [9]

    Secure genomic testing with size- and position-hiding private substring matching

    Emiliano De Cristofaro, Sky Faber, and Gene Tsudik. Secure genomic testing with size- and position-hiding private substring matching. In Proc. of the 12th ACM Workshop on Privacy in the Electronic Society , WPES’13, pages 107–118. ACM, 2013

    2013

  2. [10]

    Theory of algorithmic self-assembly

    David Doty. Theory of algorithmic self-assembly. Communications of the ACM , 55(12):78–88, 2012

    2012

  3. [11]

    Negative interactions in irreversible self-assembly

    David Doty, Lila Kari, and Benoˆ ıt Masson. Negative interactions in irreversible self-assembly. Algorithmica, 66(1):153–172, 2013

    2013

  4. [12]

    Lutz, Matthew J

    David Doty, Jack H. Lutz, Matthew J. Patitz, Robert Schweller, Scott M. Summers, and Damien Woods. The tile assembly model is intrinsically universal. In Proc. of the 53rd IEEE Conf. on Foun. of Comp. Sci. , FOCS ’12, 2012

    2012

  5. [13]

    Dowlin, R

    N. Dowlin, R. Gilad-Bachrach, K. Laine, K. Lauter, M. Naehrig, and J. Wernsing. Manual for using homomorphic encryption for bioinformatics. Proceedings of the IEEE , 105(3):552–567, March 2017

    2017

  6. [14]

    Crystals that Count! Physical Principles and Experimental Investigations of DNA Tile Self-Assembly

    Constantine Evans. Crystals that Count! Physical Principles and Experimental Investigations of DNA Tile Self-Assembly . PhD thesis, California Inst. of Tech., 2014

    2014

  7. [15]

    M. R. Garey and D. S. Johnson. Computers and Intractability: A Guide to the Theory of NP- Completeness (Series of Books in the Mathematical Sciences) . W. H. Freeman, first edition edition, 1979. 18

    1979

  8. [16]

    McGuire, David Golan, Eran Halperin, and Yaniv Erlich

    Melissa Gymrek, Amy L. McGuire, David Golan, Eran Halperin, and Yaniv Erlich. Identifying personal genomes by surname inference. Science, 339(6117):321–324, 2013

    2013

  9. [17]

    Huang, E

    Z. Huang, E. Ayday, J. Fellay, J. Hubaux, and A. Juels. Genoguard: Protecting genomic data against brute-force attacks. In 2015 IEEE Symposium on Security and Privacy, pages 447–462, May 2015

    2015

  10. [18]

    Fast arithmetic in algorithmic self-assembly

    Alexandra Keenan, Robert Schweller, Michael Sherman, and Xingsi Zhong. Fast arithmetic in algorithmic self-assembly. Natural Computing, 15(1):115–128, Mar 2016

    2016

  11. [19]

    Lander, Lauren M

    Eric S. Lander, Lauren M. Linton, and Bruce Birren et al. Initial sequencing and analysis of the human genome. Nature, 409(6822):860–921, 2 2001

    2001

  12. [20]

    Self-assembly of shapes at constant scale using repulsive forces

    Austin Luchsinger, Robert Schweller, and Tim Wylie. Self-assembly of shapes at constant scale using repulsive forces. Natural Computing, Aug 2018

    2018

  13. [21]

    Matthew J. Patitz. An introduction to tile-based self-assembly and a survey of recent results. Natural Computing, 13(2):195–224, Jun 2014

    2014

  14. [22]

    Patitz, Trent A

    Matthew J. Patitz, Trent A. Rogers, Robert Schweller, Scott M. Summers, and Andrew Winslow. Resiliency to multiple nucleation in temperature-1 self-assembly. In Proc. of DNA Computing and Molecular Programming, DNA’16, pages 98–113, 2016

    2016

  15. [23]

    Patitz, Robert T

    Matthew J. Patitz, Robert T. Schweller, and Scott M. Summers. Exact shapes and turing universality at temperature 1 with a single negative glue. In DNA Comp. and Molecular Prog., volume 6937 of LNCS, pages 175–189. 2011

    2011

  16. [24]

    Reif, Sudheer Sahu, and Peng Yin

    John H. Reif, Sudheer Sahu, and Peng Yin. Complexity of graph self-assembly in accretive systems and self-destructible systems. Theoretical Comp. Sci., 412(17):1592–1605, 2011

    2011

  17. [25]

    Fuel efficient computation in passive self-assembly

    Robert Schweller and Michael Sherman. Fuel efficient computation in passive self-assembly. In Proceedings of the 24th Annual ACM-SIAM Symposium on Discrete Algorithms , SODA’13, pages 1513–1525. SIAM, 2013

    2013

  18. [26]

    Minesweeper may not be np-complete but is hard nonetheless

    Allan Scott, Ulrike Stege, and Iris van Rooij. Minesweeper may not be np-complete but is hard nonetheless. The Mathematical Intelligencer , 33(4):5–17, Dec 2011

    2011

  19. [27]

    A set of five independent postulates for boolean algebras, with applica- tion to logical constants

    Henry Maurice Sheffer. A set of five independent postulates for boolean algebras, with applica- tion to logical constants. Transactions of the American Mathematical Society , 14(4):481–488, 1913

    1913

  20. [28]

    Introduction to Circuit Complexity: A Uniform Approach

    Heribert Vollmer. Introduction to Circuit Complexity: A Uniform Approach . Springer-Verlag, Berlin, Heidelberg, 1999

    1999

  21. [29]

    Algorithmic Self-Assembly of DNA

    Erik Winfree. Algorithmic Self-Assembly of DNA . PhD thesis, California Institute of Technol- ogy, June 1998

    1998

  22. [30]

    A molecular cryptography model based on structures of dna self-assembly

    Jing Yang, Jingjing Ma, Shi Liu, and Cheng Zhang. A molecular cryptography model based on structures of dna self-assembly. Chinese Science Bulletin , 59(11):1192–1198, Apr 2014. 19

    2014

Pith tools

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