Unique Assembly Verification in Two-Handed Self-Assembly

One of the most fundamental and well-studied problems in Tile Self-Assembly is the Unique Assembly Verification (UAV) problem. This algorithmic problem asks whether a given tile system uniquely assembles a specific assembly. The complexity of this problem in the 2-Handed Assembly Model (2HAM) at a constant temperature is a long-standing open problem since the model was introduced. Previously, only membership in the class coNP was known and that the problem is in P if the temperature is one (τ=1\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\tau =1$$\end{document}). The problem is known to be hard for many generalizations of the model, such as allowing one step into the third dimension or allowing the temperature of the system to be a variable, but the most fundamental version has remained open. In this paper, we prove the UAV problem in the 2HAM is hard even with a small constant temperature (τ=2\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\tau = 2$$\end{document}), and finally answer the complexity of this problem (open since 2013). Further, this result proves that UAV in the staged self-assembly model is coNP-complete with a single bin and stage (open since 2007), and that UAV in the q-tile model is also coNP-complete (open since 2004). We reduce from Monotone Planar 3-SAT with Neighboring Variable Pairs, a special case of 3SAT recently proven to be NP-hard. We accompany this reduction with a positive result showing that UAV is solvable in polynomial time with the promise that the given target assembly will have a tree-shaped bond graph, i.e., contains no cycles. We provide a O(n5)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\mathcal {O}(n^5)$$\end{document} algorithm for UAV on tree-bonded assemblies when the temperature is fixed to 2, and a O(n5logτ)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\mathcal {O}(n^5\log \tau )$$\end{document} time algorithm when the temperature is part of the input.


Introduction
Known Results for the Unique Assembly Verification Problem in the 2HAM and the results presented in this paper. |A| is the size of the target assembly, τ is the temperature of the system, and |T | is the number of tile types in the system. Under the Temperature column, τ indicates that the temperature may be included as part of the input.

Shape
Dimensions proves that UAV in the staged model with a single bin and stage is coNP-complete, and that UAV in the q-tile/multiple-tile model with polynomial-sized pieces is coNP-complete. We augment this result with a positive result for the special case of tree-shaped assemblies, providing a O(|A| 5 log τ ) time solution for UAV in this case (where |A| is the size of the assembly) even if τ is included as part of the input.
Our results are highlighted in Table 1 along with other known results for UAV in the 2HAM. To show coNP-hardness for UAV we construct an explicit polynomial-time reduction from Monotone Planar 3-SAT with Neighboring Variable Pairs (MP-3SAT-NVP). This reduction takes inspiration from the recent break-through proof that MP-3SAT-NVP is NP-hard and its use to prove that the connected-assembly-partitioning problem with unit squares is NP-hard [3]. For our tree UAV algorithm, we utilize a cycle decomposition approach over possible produced assemblies combined with dynamic programming.
Overview. The paper is structured as follows. Section 2 formally defines the model, the UAV problem, important definitions, and some small examples. Section 3 has the reduction proving UAV in the 2HAM is coNP-hard. Due to the numerous intricate details related to the proof, the section is broken up into several subsections explaining different aspects of the reduction. Section 4 then gives the algorithms for solving UAV for tree-bonded assemblies. Section 5 then concludes the paper with a summary and future work.

Definitions
In this section we overview the basic definitions related to the two-handed self-assembly model and the verification problems under consideration.

34:4
Unique Assembly Verification in Two-Handed Self-Assembly  Example of an attachment that takes places using cooperative binding at τ = 2. We denote a glue strength of 1 with a rectangle and a glue of strength 2 with a solid line through the two tiles. Dotted lines between glues indicate that these tiles may attach to each other with the respective strength. Assume assemblies shown are τ -stable unless stated otherwise. (b) The bond graph of the assembly showing that it is τ -stable. (c) These two assemblies are not τ -combinable since this would place two tiles at the same location. We say this is due to geometric blocking.
configuration is said to be τ -stable for a positive integer τ if GÃ is connected and if every edge cut of GÃ has a weight of at least τ . This means that the sum of the glue strengths along each cut is greater or equal to τ . A small example bond graph is shown in Figure 1b.
Assemblies. For a configurationÃ, the assembly ofÃ is the set A = {B :B ≃Ã}. Informally an assembly A is a set containing all translations of a configurationÃ. An assembly A is a subassembly of an assembly B, denoted A ⊑ B, provided that there exists anÃ ∈ A andB ∈ B such thatÃ ⊆B. We define |A| to be the number of tiles in a configuration of A.
An assembly is τ -stable if the configurations it contains are τ -stable. Assemblies A and B are τ -combinable into an assembly C if there existÃ ∈ A,B ∈ B, andC ∈ C such that 1) A∪B =C, 2)Ã∩B = ∅, and 3)C is τ -stable. Informally, two assemblies are τ -combinable if there exist two configurations of the assemblies that may be combined resulting in a τ -stable assembly without placing two tiles in the same location.
Two assemblies combining or binding together is called an attachment. An attachment takes place using cooperative binding if the two assemblies do not share a τ -strength glue and instead use multiple weaker glues summing to τ . An example of an attachment that takes place using cooperative binding can be seen in Figure 1a. If an attachment cannot take place because the two tiles would be placed in the same position, it is geometrically blocked. Two assemblies whose attachment is geometrically blocked is shown in Figure 1c.
Two-handed Assembly. A two-handed assembly system (2HAM) is an ordered tuple Γ = (T, τ ) where T is a set of tiles and τ is a positive integer parameter called the temperature. For a system Γ, the set of producible assemblies P ′ Γ is defined recursively as follows: 1) T ⊆ P ′ Γ , and 2) If A, B ∈ P ′ Γ are τ -combinable into C, then C ∈ P ′ Γ . We are naturally extending the concept of τ -combinable to single tiles by considering them assemblies of size 1.
A producible assembly is terminal provided it is not τ -combinable with any other producible assembly. Denote the set of all terminal assemblies of a system Γ as P Γ . Intuitively, P ′ Γ represents the set of all possible assemblies that can self-assemble from the initial set T , whereas P Γ represents only the set of assemblies that cannot grow any further. Figure 2 shows a small 2HAM example.
An Assembly Tree for a 2HAM system Γ = (T, τ ) is any rooted binary tree whose nodes are elements of P ′ Γ , the leaves are single tiles from the set T , and the two children of any non-leaf node are τ -combinable into their parent. An assembly tree with root A is said to be an assembly tree for assembly A. A small example is shown in Figure 2c.  The input is the 2HAM system (tile set and temperature) and the target assembly. (b) The main producible assemblies of the 2HAM system (for clarity, not all subassemblies are shown). The target assembly is producible and terminal. However, there is also a produced assembly that is a rogue assembly (highlighted) since it not a subassembly of our target and it is terminal. (c) A small example of an assembly tree for one of the producibles.
Unique Assembly. Intuitively, the unique assembly of A means that any produced assembly can continue to grow until it becomes A, thus making A the uniquely produced assembly if the process is provided sufficient time to assemble. This means A is the unique terminal assembly and all produced assemblies are subassemblies of A. Formally, we say a system Γ uniquely produces an assembly A if: 1) P Γ = {A}, and 2) For all B ∈ P ′ Γ , |B| ≤ |A|. ▶ Problem 1 (Unique Assembly Verification). Input: A 2HAM system Γ, an assembly A. Output: Does Γ uniquely produce the assembly A?
The Unique Assembly Verification problem (UAV) is the computational problem that asks to verify if an assembly is uniquely produced. A key concept used throughout this paper is a rogue assembly, which is any producible assembly that breaks one of the conditions of unique assembly and serves as a proof that the instance of the UAV problem is false.
▶ Definition 2 (Rogue Assembly). Given an instance of UAV (Γ, A), an assembly R ⊑ P ′ Γ is a rogue assembly if R ̸ = A and R is not a subassembly of A.
We prove the following Lemma, which is used in the hardness reduction and the positive result. This lemma states that if the instance of UAV is false and all the tiles in Γ are used to build A, then any rogue assembly is made of combinable subassemblies of A. ▶ Lemma 3. For an instance of UAV (Γ, A) that is false the following statement must be true: there exists two producible assemblies B, C such that B, C ⊑ A and B and C are τ -combinable into a rogue assembly R, or there exists a rogue assembly R that is composed of a single tile.
Proof. First, since the instance of UAV is false, there must exist some rogue assembly R. If R is composed of a single tile, the Lemma is true. If R is not composed of a single tile, we walk through its assembly tree to find the assemblies B and C that are both subassemblies of our target A. Consider an assembly tree of R, Υ R . Start at the root-if its two children are both subassemblies of A, then the rogue assembly R satisfies the Lemma. If either of the children is also a rogue assembly (not a subassembly of the target), then follow that node and do the same thing. If both are rogue assemblies, it does not matter which we follow.
Since this is an assembly tree all the leaves represent assemblies composed of one tile. Since we know none of the leaf assemblies are rogue assemblies (if it was the lemma would already be satisfied) we know at some point we must reach a node representing a rogue assembly that can be built from two subassemblies of our target A. ◀ I C A L P 2 0 2 2 34:6 Unique Assembly Verification in Two-Handed Self-Assembly

Unique Assembly Verification Hardness
In this section, we show coNP-hardness of the Unique Assembly Verification problem in the 2HAM with constant temperature by a reduction from Monotone Planar 3-SAT with Neighboring Variable Pairs.
▶ Problem 4 (Monotone Planar 3-SAT with Neighboring Variable Pairs (MP-3SAT-NVP)). Input: Boolean formula ϕ = C 1 ∧ · · · ∧ C m in 3-CNF form where each clause only contains positive or negated literals from X = {x 1 , . . . , x n }. Further, any clause of ϕ with 3 variables is of the form (x i , x i+1 , x j ) or (¬x i ∨ ¬x i+1 ∨ ¬x j ), i.e., at least two of the literals are neighbors. Output: Does there exist a satisfying assignment to ϕ?
Monotone Planar 3-SAT with Neighboring Variable Pairs was recently shown to be NP-hard in [3]. We assume the instance of the problem is a rectilinear planar embedding where each variable is represented by a unit height rectangle arranged in the variable row. Any planar 3SAT formula has a rectilinear encoding [19]. We also assume that every clause is a unit-height rectangle with edges connecting the clauses and the contained variables. The monotone property ensures that each clause contains either only positive or only negative literals. Thus, the clauses may be separated with all positive clauses above the variable row, and all the negative clauses below. The final restriction is neighboring variable pairs, which states that for the three variables in each clause, at least two of the variables are neighbors in the variable row. An example instance is shown in Figure 3a

Overview
Given an instance of MP-3SAT-NVP ϕ, we build an assembly A and a 2HAM system Γ that uniquely assembles A if and only if ϕ does not have a satisfying assignment. An example instance is shown in Fig. 3a and 3c. Alternatively, Γ produces a rogue assembly if and only if there exists a satisfying assignment to ϕ.
The ability to place all positive clauses above the variables and negative clauses below, along with the neighboring variable pairs, allows the clauses to be built hierarchically from the variables up. These properties allow us to require all nested clauses be evaluated and built before the outer clause is built. Thus, we define parent and child clauses as well as root clauses. In Figure 3a, dotted lines connect child clauses c 1 and c 2 with their parent c 3 . The root clauses are c 3 and c 5 . 1 ▶ Definition 5 (Parent/Child/Root Clause). Given a rectilinear encoding of Monotone Planer 3-SAT, a clause C p is a parent clause of child clause C c , if C p fully encloses C c , and any other clause that encloses C c also encloses C p . A root clause is a clause without a parent.
Since ϕ is monotone, the positive and negative clauses may be separated across the variable row. The assembly A is also separated by a horizontal bar that splits the assembly in two. This bar partially extends downward to prevent this assembly from attaching to itself. Above this bar is a subassembly that encodes the positive clauses and below the bar is a subassembly that encodes the negative clauses, which we call the positive and negative circuit, respectively.  The target assembly is designed so that it must be built from the variables up to the clauses. The clause gadgets can only be built if they are satisfied. Thus, parent clauses require that their variables or child clauses be satisfied to build the gadget. We will ensure this by using AND and OR gadgets between the variable and clause gadgets. We cover the parts of the system and gadgets in the order they must assemble: Section 3.2: variable gadgets Section 3.3: OR gates and non-parent clause gadgets Section 3.4: AND gates and parent clauses Section 3.5: the root clauses and the horizontal bar Section 3.6: how a rogue assembly may form if and only if ϕ is satisfiable

Variable Gadget
For each variable gadget we use (2 + 4d) subassemblies ( Figure 4a) to build the variable gadget where d is the number of times the variable is used or its outdegree. An example is shown in Figure 4b where d = 1 and Figure 4c where d = 2. In the figures, the lines are strength-2 glues, and the rectangle glues are all strength-1, thus requiring cooperative binding for the subassemblies to attach in a specific build order. We draw our gadgets separated into subassemblies but we construct our tile set using the single tiles which will self-assemble into these subassemblies. Every variable gadget is built as follows. The Bar Assembly acts as a backbone (or separator) for the completed circuit subassemblies to connect to each other. The Bump is the first assembly to attach to the Bar Assembly. The Bump is a height 2 rectangle with an extra domino below it that is used for geometric blocking and encoding the assignment to that variable. The position of this domino is dependent on the position of the variable gadget on the opposite (negative) side.
The Base Dominoes are used as part of the process of duplicating a variable path to multiple clauses. For each clause a variable is in, we use four subassemblies to connect to the next gadget. The first two gadgets are the Base dominoes. Once the Bump attaches    For each additional output more base dominoes and wires are added. (d) A set of producible subassemblies representing variables that satisfy the example instance. We will walk through how these assemblies grow into a rogue assembly.
to the Bar Assembly, the Base Dominoes can attach cooperatively to both. Once the first Base Domino attaches the next can attach using the glue from the previous domino and the other from the Bump. 2 The Wires attach the variable gadgets to the clauses, and are the final two subassemblies for connecting to the next gadget. The first wire attaches cooperatively to the Bar Assembly and subsequent ones attach to the previous wire. The wires in our system are all built from two assemblies. When both halves of the wire are connected, the next gadget may attach. We call this a completed wire.
Variable gadgets in the negative circuit are built symmetrically rotated 180 degrees. We adjust the position of dominoes on the Bumps of the gadgets so that variable gadgets on opposite circuits that represent the same variable have their domino in the same column. We may generalize these gadgets to out degree d (the variable appears in d clauses) by increasing the width of the bump, and adding additional dominoes and wires.

OR Gates and Clause Gadgets
In CNF form, every variable in a clause is separated by a logical OR, thus, as part of our clause gadgets, we create OR gates to bring the variables together to ensure that the clause only forms if there is at least one variable assignment that satisfies the clause.

OR
Gates. An example of how the OR gate grows off of a variable gadget is shown in Figure 5a. The OR gate consists of a single 2 × 2 square with strength-1 glues on the west, north, and east facing tile edges. The west and east glues each connect to the wires that input to the gate. The north glues are used cooperatively with glues on the incoming wire gadgets to attach another wire gadget going to the clause gadget. To complete the new wire gadget it must also cooperatively use the other incoming wire. Note the wires from the other input can backfill, but this does not cause an issue as the "backward" growth stops after building the wire. Figure 5b shows an example with only one variable used in the OR gate.  The process of a variable gadget growing the OR gate used for clauses. Glues used for attachment in the next step are denoted by arrows. If one of the variable gadgets is constructed the 2 × 2 square assembly may attach. The output wires of the gate then attach cooperatively with the wire from the variable assembly and the square. Note that only one of the variable assemblies needs to be constructed for the OR gate to build its output wire. (b) Once the output wires of the OR gate have attached the wire for the other variable may "Backfill" or grow backwards.  Non-parent Clauses. We first cover clauses without children, or clauses at the bottom of the circuit. The simplest type of this gadget are clauses with only 2 literals as in Figure 6a. This gadget is fairly straightforward to implement as we only need to use a single OR gate. An example of this type of clause is in Figure 7a, and its implementation is in Figure 7c. Note that both variables appear in other clauses so those variable gadgets have additional wires. For non-parent clauses with 3 literals (Figure 10a), we use 2 OR gates (Figure 8c).

AND Gates and Parent Clauses
Since every clause in CNF form is separated by a logical AND, we create AND gates that compare clauses. Thus, we need to know which clauses are parent clauses since they have child clauses underneath them with wires coming into the gates. We also build a FANOUT gate for connecting clauses.
AND Gates. The AND gate uses 2 vertical dominoes that share a single strength-1 glue between them. Figure 9a shows an example AND gate being constructed. Once a wire that inputs to the gate is completed, one of the dominoes can cooperatively attach. The domino has another strength-1 glue on its north side that allows a horizontal domino to cooperatively attach using the glue exposed on the wire.
Using the glues from the newly attached dominoes, the two halves of the gate are able to attach to each other. This allows for the two glues on the horizontal dominoes to be used to cooperatively bind the white center domino. From here, the two halves of the wire that outputs from the AND gate can attach.   FANOUT Gates. In order to build the parent clause, we also need a way to "fan-out" and copy the signal from an AND gate to two other gadgets. We do this by adding glues to the north side of the center domino and having two wires grow off of the gadget. This process is shown in Figure 9b.
Parent Clauses. Consider a parent clause C p = (x 1 ∨ x 4 ). Let C c be the child clause. Since we want this gadget to build only if its own clause and its child are both satisfied, we can view this statement as (x 1 ∨ x 4 ) ∧ C c . However, we can modify the statement to be (x 1 ∧ C c ) ∨ (C c ∧ X 4 ), which we can build since we have planar circuits. An example of the circuit and gadgets are shown in Figure 6b.
By the neighboring variable pairs restriction, we know that any clause with three variables has at least a pair of them being neighbors. This means that there cannot be any child clauses beneath that neighboring pair, so we may use an OR gate between those two variables and then build the rest of the gadget in the same way as the two literal version (Figure 6c).
In our example instance, the root clause of the positive circuit has two children. For these cases we may use the AND gadget to verify that both child clauses have been satisfied before allowing the parent clause to build. The root clause of the negative circuit in our example instance (Figure 11a) has three literals. The constructed gadget can be seen in Figure 11a.

Root Clauses and Horizontal Bar
Root Clauses and Arms. The root clause is the outermost clause on either side of the variables. Although it functions similar to the other clauses, instead of outputting a wire, a horizontal 4 × 1 rectangle can attach after it finishes assembling. The arms may then cooperatively bind to the rectangle and the wires of the root clause forming the top of the   circuit. The glues on the ends of these arms allow for the circuit to attach to the horizontal bar. A high-level view of the root clauses and arms attached is shown in Figure 12a as well as a detail of the assembly process of the root clause in Figure 12b.
Horizontal Bar. The horizontal bar (Figure 12a) is a width-1 assembly that extends the width of both circuits with strength-1 glues on the north and south side of the outer tiles. Since the arms must also be able to attach to each other to form a rogue assembly the glues on the ends of the horizontal bar must be the same. In order to prevent the horizontal bar from attaching to another instance of itself, we extend the bar partially downward so it will geometrically block copies from attaching.

Rogue Assemblies
For the construction of the target assembly, each piece is built from the variables up to the root clause. However, the nondeterministic build order means that not all parts of each circuit need to be built in order for the root clause to be satisfied. For instance, if one of the variables in a clause attaches, the OR gates will still allow the wires to attach. Thus, using a variable constitutes setting it to true (and in the negative circuit using a variable is setting the negation to true).
With root clauses satisfied and the arms attaching, a rogue assembly may occur as shown in Figure 13c. The corresponding circuit is shown in Figure 13b. This can occur because the arms can attach to each other without the horizontal bar. Normally, the variable gadgets   would overlap and prevent this attachment if both the positive and the negative circuit used the same variable (which is setting a variable to both true and false). Thus, the positive and negative side each have their own set of variables that make all clauses on their respective sides true. This rogue assembly can only happen if there is a subset for each side that allows all clauses to be true, and thus satisfies the original MP-3SAT-NVP formula.
For an MP-3SAT-NVP instance ϕ and an assignment X s to the variables in X, let A p and A n be the positive and negative circuit assemblies, respectively, created from ϕ. We say an assembly A ′ p ⊑ A p represents the assignment X s if it has attached variable gadgets for the variables in X s that equal 1, and has built its root clause. For negated circuits, it must have variable gadgets attached for variables set to 0 in X s . ▶ Lemma 6. For a rectilinear encoding of Monotone Planar 3SAT ϕ with neighboring variable pairs and 2HAM system Γ ϕ as described above, there exist two producible assemblies A ′ p ⊑ A p and A ′ n ⊑ A n that both represent the same assignment X s to the variables X, if and only if X s satisfies ϕ.
Proof. If there exists a satisfying assignment X s to X, we may build A ′ p by taking the variable gadgets for variables assigned to 1 and grow the circuit off of them. Since we know all the clauses are satisfied, each clause gadget (including the root clause) may grow resulting in an assembly A ′ p that represents X s . By the same argument we know A ′ n is producible since X s satisfies ϕ, which includes the negated clauses.
We prove these assemblies are producible only if X s satisfies ϕ via contradiction. Assume X s does not satisfy ϕ, but both assemblies A ′ p and A ′ n are producible. Since X s does not satisfy ϕ, there must exist at least one unsatisfied clause c i . W.L.O.G., assume c i is a positive clause. We show the assembly A ′ p cannot be produced. If c i is the root clause, assume all of the children of c i are satisfied. The center input of the clause is a producible subassembly of A ′ p since variable gadgets are allowed that satisfy the clauses below it. We can see in Figure 12b the other producible subassemblies of the gadgets only have a strength-1 glue between them. This means none of the subassemblies are able to attach to each other on their own. In order for the arms to attach to the output wire of the root clause, at least one of the AND gates must be fully constructed. The AND gate cannot assemble unless both halves of the gate have been constructed. The middle input is built, but the other half of the AND gadget must grow off a completed wire from the variable gadget. However, since c i is not satisfied the variables gadgets which satisfy the formula have not attached so the assembly A ′ p cannot build the clause gadget. If c i is another parent clause that is not the root. Let the clause c j be the parent clause of c i . If the clause gadget for c i is not constructed then the gadget for c j is not buildable. Since the gadgets used are the same as the root clause, the output wires of the clause gadget for c i cannot be built without a variable gadget which satisfies the formula. The middle input of clause gadget representing c j will not be buildable since this would be the output wire of c i . The middle input goes to two AND gates that cannot construct unless both wires have been built. Thus, the output wire of c j cannot be built without its children clauses satisfying it. In the case c j has multiple children, the output wires of all its children are joined by AND gates that will not construct without both inputs.
Finally, consider the case where c i is a clause without children. In order for the clause's output wire to complete, it must be attached to an OR gadget and the outer wire of the variable gadget. The OR gadget may only attach to a completed wire from a variable gadget (or another OR). The variable gadget cannot be completed without placing the bump, so we cannot have built the outwire of c i . By the same argument as the previous case, this clause not being built results in its parent not being built. If c i is not satisfied, the clause gadget for c i cannot be constructed, which means the assembly A ′ p is not producible. ◀ ▶ Theorem 7. The Unique Assembly Verification problem in the 2HAM is coNP-Complete with τ = 2.
Proof. Given an instance of a rectilinear encoding of Monotone Planar 3SAT with neighboring variable pairs ϕ, we provide an explicit polynomial time reduction by creating a 2HAM system Γ = (T, 2) and an assembly A such that Γ uniquely produces A if and only if there does not exist a satisfying assignment to ϕ. We create the assembly A by taking the rectilinear encoding of ϕ, arranging the rectangles on a grid graph, and replacing the rectangles with the given variable and clause gadgets. We also add the arms and horizontal bar. Assume there exists a satisfying assignment X s to the variables X, for ϕ. We know by Lemma 6, there exist two producible assemblies A ′ p and A ′ n that both contain the arms and have complementary bump positions 3 . These two assemblies can cooperatively bind to one another using the two glues on their arms, and thus produce a rogue assembly as in Figure  13c. This means a satisfying assignment to ϕ implies Γ does not uniquely construct A.    Even though the shape of this assembly is a square, its bond graph is acyclic, and thus this assembly is tree-bonded. (c) This assembly is not tree-bonded due to the cycle in its bond graph. Now assume Γ does not uniquely produce A, so there exists some rogue assembly B. The only repeated glues in the tile set of Γ are the exposed glues on the arms. Any rogue assembly must use these two glues to assemble, and they must be assembled from two subassemblies of the target by Lemma 3. Let B be producible by combining two assemblies b and b ′ . Since both b and b ′ are producible assemblies with both their arms, and they can attach to each other, they are not geometrically blocked. This implies they must represent the same assignment and by Lemma 6, this can only be true if the assignment satisfies ϕ. By viewing which variable gadgets are included in the two assemblies, we can identify the satisfying assignment to ϕ. Thus, Γ will uniquely produce A if and only if there does not exist a satisfying assignment to ϕ. ◀

Verification of Tree-Bonded Assemblies
In this section, we investigate the problem of Unique Assembly Verification with the promise that the target assembly A is tree-bonded, meaning the bond graph of the target assembly forms a tree. Figures 14a and 14b show examples of tree-bonded assemblies. Figure 14c shows an assembly whose bond graph contains a cycle and thus is not a tree-bonded assembly. We first present a O(|A| 5 ) algorithm for temperature 2 systems, and then extend this method to provide a O(|A| 5 log τ ) time dynamic programming algorithm for the case where the temperature τ of the system can be passed as a parameter. Before describing the algorithms, we first introduce some required definitions and the problem formulations.
Tree-Bonded Assemblies. An assembly A is a tree-bonded assembly if and only if the induced bond graph G A is acyclic.
Binding Sites. For two configurations C 1 and C 2 , we say a binding site B is a pair of points (p a , p b ), such that their distance is ||p a − p b || 2 = 1, and the tiles C 1 (p a ) and C 2 (p b ) have nonzero glue strength between each other. The set of binding sites for two configurations is the set of pairs of points that meet this requirement. We also define an inner binding site. For two configurations, C 1 and C 2 , and a pair of binding sites a = (a 1 , I(a, b) be the set of binding sites that occur on the inside of the loop formed by a, b (inner binding sites). An example of the area enclosed by a loop is seen in Figure 15c.

High-level Overview
The high-level goal of this algorithm is to find a rogue assembly that acts as a witness that the instance of UAV is false. We note that a given instance, P = (Γ, A), of Temp2-Tree-UAV, where Γ = (T, 2), can be broken down into three possible cases. An example tree-bonded assembly is shown in Figure 15a.

1.
The instance P is false, and Γ produces a tree-bonded rogue assembly.

2.
The instance P is false, and the only rogue assemblies producible in Γ are non tree-bonded.

The instance P is true.
At a high level, the algorithm checks if either Case 1 or Case 2 as true, and f so, the algorithm rejects, otherwise it accepts. Case 1 can be checked efficiently by modifying Γ to function as a noncooperative system Γ ′ and utilizing the algorithm for temperature-1 UAV provided in [16]. To check the second case, Lemma 3 states that if the instance is false, it suffices to check pairs of subassemblies of the target assembly A in order to find a witness rogue assembly. Thus, we take two copies of the target assembly and attempt to find possible ways they may bond, even if the resulting assembly places two tiles at the same position. We call the pairs of tiles that contribute glue strength binding sites Tiles that are in the same position are called intersections. An example of both may be seen in Figure 15b.
We first analyze the case of temperature-2 systems where only two binding sites that do not intersect are needed. We then generalize this algorithm by using dynamic programming to find the set of binding sites to maximize the binding strength between the assemblies without any intersections.

Tree-Bonded Rogue Assemblies
The following algorithm checks if a system uniquely assembles a given shape provided the system is restricted to behaving in a noncooperative manner. This means that two assemblies can only attach if they share one or more strength-τ glues between them. This system functions equivalently to a temperature-1 system where all glues less than strength-τ are removed and all glues greater than strength-τ are set to strength-1. We modify the system in this way and then use the known polynomial time algorithm for temperature-1 UAV [16].

Temperature-2
With respect to the given instance of Temp2-Tree-UAV P , if P is false, and the algorithm for NonCoop-UAV(Γ, A) returns "accept", then Lemma 10 implies there exist two subassemblies of the target, B 1 and B 2 , that attach to each other using cooperative binding.
To find these two subassemblies, we take two "copies" of the target assembly and find all |A| 2 possible ways to combine them-even if it results in intersections. If any combination results in at least two binding sites, we attempt to find 2-combinable subassemblies. Since these subassemblies are also tree-bonded, there only exists one path between each pair of tiles-including the binding sites. So for each pair of binding sites, we take the loop formed by the two binding sites and check if it intersects itself. An example of a loop that intersects itself is shown in Figure 15d. If there ever exists a pair of binding sites whose paths do not intersect, then those two subassemblies will form a rogue assembly and we reject.

Variable Temperature
We now present an algorithm for Tree-UAV as a generalization of the previous problem where the temperature of the system τ is given as input. The algorithm is similar except it does not suffice to only find a single loop since the temperature requirement attachment may be greater than 2. We must find multiple loops between binding sites that do not intersect. Once we find a way to combine the assemblies, we view binding sites and loops hierarchically using inner binding sites. An example of an inner binding site is in Figure 15c. We recursively calculate the max binding strength when taking each pair of binding sites as the outer loop. After calling NonCoop-UAV(Γ, A), we check each possible way to attach A to itself. For each of these ways, we build a b × b table where b is the total number of induced binding sites. For each pair of binding sites, we calculate the maximum value recursively augmented with the table. Thus, we only compute the maximum value once for each loop.
First, if the created loop intersects itself, we cannot use it, so the value is set to −1. Next, we check if the binding sites form a simple loop with no inner binding sites. Here, the max value is the sum of the glue strengths between the binding sites. For loops with inner binding sites, we do a loop decomposition, which is the process of breaking a loop into two smaller loops along one of the inner binding sites. An example is shown in Figure 16a.
To find the max binding strength of the outer loop, we break the loop up along each inner binding site and recursively get the max strength of the two resulting loops (subtracted by the glue strength of the inner binding site since it would be counted twice). If either of the smaller loops intersects itself, it returns −1 and we know not to use that inner binding site. The max binding strength of the outer loop is then the maximum of these computed values over all choices of inner binding sites. The recursive checks are implemented with a dynamic programming/memoization table to eliminate repeated recursive calls.
Due to space constraints, the analysis of Alg. 3 and proof of Thm. 12 have been omitted.

Conclusion
In this paper, we have addressed the long-standing open problem of the complexity of verifying unique assembly within the 2-handed tile self-assembly model and shown that the problem is coNP-complete even at temperature τ = 2 and in two dimensions. These are the smallest possible values for which this problem can be hard, as both temperature-1 self-assembly and 1-dimensional self-assembly have established polynomial time verification solutions. Given this hardness, we explored a natural scenario where this problem might be more tractable, and showed that restricting the input assemblies to tree-bonded assemblies allows for an efficient O(|A| 5 log τ )-time unique assembly verification algorithm. , b1, b2). The subroutine that calculates the max strength when using two binding sites as the outer loop. The method glueStr(b) takes in a binding site and returns the strength of the glue connecting the two tiles.

Algorithm 4 maxStr(C, TB
Data: Union of two assemblies C, Table T Future Work. While we have resolved the general question of unique assembly verification in the 2HAM, as well as addressed a natural restricted case of tree-bonded assemblies, there remain important directions for future research.
Our hardness reduction utilizes a tile set that is roughly the size of the input assembly. All hardness results in the literature for the 2-handed self-assembly model have this property. Yet, the computational power of self-assembly allows for the assembly of large assemblies with small tile sets, as seen in the efficient self-assembly of squares [1,24], or the implementation of "Busy Beaver" Turing machines [24]. How hard is UAV for large assemblies with substantially smaller tile sets. Does the hardness scale with assembly size or tile set size? Is there some form of fixed-parameter tractability for the UAV problem?
We proved that UAV for the multiple tile (or q-tile) model is coNP-complete with polynomial-sized assemblies attaching. Is UAV polynomial in the multiple tile model and the 2HAM in the case where every producible assembly, except the one that grows into the terminal assembly, is bounded by a constant? A related question in the aTAM and the 2HAM is the number of two-handed operations actually required to make the problem hard. If all subassemblies can only grow by single tile attachments, how many two-handed operations to combine those subassemblies are needed for UAV to remain hard? The ability to more efficiently construct shapes by assembling parts separately has been studied in other models as well [25]. Another direction initiated by our efficient tree assembly algorithm is the consideration of other natural restricted classes of the UAV problem. For example, how does UAV scale with respect to the genus of an assembly's connectivity graph? A related question involves verification for fully connected assemblies, a previously-studied concept [14] in which assemblies include positive bonds between all neighboring tiles.