TRANSDUCER GENERATED ARRAYS OF ROBOTIC NANO-ARMS

Abstract

We consider sets of two-dimensional arrays, called here transducer generated languages, obtained by iterative applications of transducers (finite state automata with output). Each transducer generates a set of blocks of symbols such that the bottom row of a block is an input string accepted by the transducer and, by iterative application of the transducer, each row of the block is an output of the transducer on the preceding row. We show how these arrays can be implemented through molecular assembly of triple crossover DNA molecules. Such assembly could serve as a scaffold for arranging molecular robotic arms capable for simultaneous movements. We observe that transducer generated languages define a class of languages which is a proper subclass of recognizable picture languages, but it containing the class of all factorial local two-dimensional languages. By taking the average growth rate of the number of blocks in the language as a measure of its complexity, we further observe that arrays with high complexity patterns can be generated in this way.

1. Introduction and Background

Synthetic DNA has been designed and shown to assemble into complex species that entail the lateral fusion of DNA double helices, such as DNA double crossover (DX) molecules [8], triple crossover (TX) molecules [22] or paranemic crossover (PX) molecules. Double and triple cross-over molecules have been used as tiles and building blocks for large nanoscale arrays [30, 29], including the Sierinski triangle assembly by DX molecules [28]. Theoretically, it is shown that two-dimensional arrays made of DX or TX DNA can simulate the dynamics of a bounded one-dimensional cellular automaton and so are capable of potentially performing computations as a Universal Turing machine [30]. The essential part in these observations is the natural representation of a Wang tile with a DX or a TX molecule.

Wang tiles have been extensively used in the study of two-dimensional languages and there is a natural correspondence between the sets of blocks assembled with Wang tiles and local two-dimensional languages. The physical representation of Wang tiles with DNA molecules demonstrated recently [29, 30] provides another motivation for studying sets of rectangular blocks of symbols namely two-dimensional languages. It is well known that by iteration of generalized sequential machines (finite state machines mapping symbols into strings) all computable functions can be simulated (see for ex. [26, 27]). The full computational power depends on the possibility for iterations of a finite state machine. Moreover, there is a natural simulation of iteration of transducers and recursive (computable) functions with Wang tiles [13]. This idea has been developed further in [5] where a successful experimental simulation of a programmable transducer (finite state machine mapping symbols into symbols) with TX DNA molecules having iteration capabilities is reported. This experimental development provides means for generating patterns and variety of two-dimensional arrays at the nano level. Motivated by this recent experimental development here we define a class of two-dimensional languages generated by iteration of transducers, called transducer generated languages and show how physical realization of arrays corresponding to such a language can be used as a platform for arranging robotic nano-arms. An earlier short description of transducer generated languages appears in [7].

The notation and the definitions are included in Section 2 while in Section 3 we show that transducer generated (TG) two-dimensional (picture) languages belong to the class of recognizable (REC) picture languages. We also observe that TG languages include all local (factorial) picture languages, i.e., languages generated by finite sets of Wang tiles. Although there are fairly well developed classifications and theories to study one-dimensional languages, in particular regular languages, the case of two-dimensional languages remains elusive. The class REC defined by A. Restivo and D. Giammarresi [10, 11] was introduced as a natural extension of regular languages in one-dimensional case. They showed that the emptiness problem for these languages is undecidable which implies that many other questions that are easily solved in one-dimensional case become undecidable in two-dimensional case. Recent work by several authors attempts to better understand REC through various approaches such as: design of variants of finite state automata that recognize these languages [1, 2, 17, 18], characterization of determinism of two-dimensional recognizable languages [3, 4], or study of the factor languages of two-dimensional shift spaces [14, 15]. Therefore, the transducer generated languages introduced here define another sub-class of REC languages whose analysis may provide a way to understand some properties of the whole class of REC.

In Section 4, as a measure of complexity, we make some observations about the average growth rate of the number of sub-blocks in a TG picture language. This measure is known in symbolic dynamics as the entropy of the language and it is well understood in the case of one-dimensional regular languages. It is known that in one-dimensional case, the set of entropies of regular languages coincides with the set of logarithms of Perron numbers (see [25]). However, there is no general theory that describes a way to obtain the entropy of a two-dimensional local, or even less a language belonging to the larger class of recognizable languages. It is known that even languages with so called strong transitivity, i.e., mixing properties, have zero entropy [20, 21]. Here, we observe that the value given by a log of a Perron number can be obtained as an entropy value of a transducer generated two-dimensional language. This also shows that the two-dimensional arrays obtained by self-assembly of DNA tiles simulating iterations of a transducer may have rich pattern complexity.

A possible implementation of transducer generated arrays with TX DNA molecules to serve as platforms for arranging robotic nano-arms is presented in Section 6. A PX-JX₂ device introduced in [31], has two distinct positions and each is obtained by addition of a pair of DNA strands that hybridizes with the device such that the molecule is in either PX or in JX₂ position. This device has been assembled sequentially [24] and in an array [6]. In the later case it has been shown that a molecular robotic arm can be attached to the device and controlled simultaneously. The successful molecular implementation of a transducer [5] forms a basis for assembling transducer generated arrays incorporating molecular robotic arms to be moved in preprogrammed directions simultaneously.

2. Notation and Definitions

We use Σ to indicate an alphabet, a finite set of symbols. The cardinality of Σ is denoted with #Σ. A finite sequence of symbols is called a word, or a one-dimensional block. The set of all words over alphabet Σ is denoted with Σ^*. The length of a word w = a₁·… · a_k is k and is denoted with |w|. The empty word is denoted with ε. The set of all words of length k is denoted with Σ^k, and set of all words of length less or equal to k is denoted with Σ^≤k.

A one-dimensional language (further referred to as language) is a subset of Σ^*. For a language L, we extend the notation to L_k = Σ^k ∩ L and L_≤k = Σ^≤k ∩ L. A word u such that w = x₁ux₂ for some words x₁, x₂ ∈ Σ* is called a factor of w. The set of all factors of w is denoted with F(w), and the set of all factors of length k of w is denoted with F_k(w). We extend this notation such that the set of factors of all words in a language L denoted by F(L) and the set of factors of all words in L of length k is denoted by F_k(L).

Definition 2.1

A nondeterministic transducer is a five-tuple

$$\tau =(\mathrm{\sum },Q,\delta ,q_0,T),$$

where Σ is a finite alphabet, Q is a finite set of states, q₀ is an initial state (q₀ ∈ Q), T is a set of final (terminal) states (T ⊆ Q), δ ⊆ Q × Σ × Σ × Q is the set of transitions. A transducer is called deterministic if its set of transitions defines a function (which is also denoted with δ) δ: Q × Σ ↦ Σ × Q.

To a transducer we associate a directed labeled graph in the standard way: the set of vertices is the set of states Q and the directed edges are transitions in δ, such that an edge e = (q, a, a′, q′) starts at q and terminates at q′. To each edge we associate labels : δ ↦ Σ and : δ ↦ Σ being the input and the output labels such that for e = (q, a, a′, q′) we have (e) = a and (e) = a′. The input and the output labels are naturally extended to paths in the transducer.

We say that a word w is accepted by a transducer τ = (Σ, Q, δ, q₀, T) if there is a path p = e₁ · · · e_k which starts at q₀, terminates with a state in T and (p) = (e₁) · · · (e_k) = w. The path p in this case is called an accepting path for w. The language which consists of all words that are accepted by τ is called the input language of τ and is denoted (τ). A word v is said to be an output of τ if there is w ∈ (τ) and an accepting path p for w such that (p) = v. In this case we also write v ∈ (w). The language which consist of all outputs of τ is the output language for τ denoted with (τ).

Definition 2.2

If S = {1, …, n} × {1, …, m}, then a map B: S ↦ Σ is a block of size n × m or an n × m-block. We say that n is the number of columns in B and m is the number of rows in B. The empty block is of size n × m where at least one of m, n equals 0 and is denoted by ε.

The blocks are represented as arrays of symbols: the first row of the block is the bottom row, and every successive row is placed on top of the previous row.

Definition 2.3

If B is a block of size n × m, and x, y, n′m′ are positive integers, such that x+n′ ≤ n+1 and y + m′ ≤ m + 1, then a sub-block of B of size n′ × m′ at position (x, y), denoted $B{\mid }_{(x,y)}^{n^{\prime }\times m^{\prime }}$ is the n′ × m′-block such that $B{\mid }_{(x,y)}^{n^{\prime }\times m^{\prime }}(i,j)=B(x+i-1,y+j-1)$ for 1 ≤ i ≤ n′ and 1 ≤ j ≤ m′. We say that a block B′ is a sub-block of B if there are x, y, n′, m′ such that $B^{\prime }=B{\mid }_{(x,y)}^{n^{\prime }\times m^{\prime }}$. We consider the empty block to be a sub-block of every block and we accept the convention that B(1, 1) is the left bottom corner of B.

The set Σ^** denotes the set of all blocks over alphabet Σ. A subset L of Σ^** is called a picture language. The set of all k × ℓ-blocks is denoted with Σ^{k× ℓ}. The set of all k × ℓ sub-blocks of a block B is denoted by F_k,ℓ(B). The set of all sub-blocks of B is denoted with F (B). We extend this notation naturally to F (L) for all sub-blocks of blocks in L and F_k,ℓ(L) for the set of all sub-blocks of size k × ℓ of blocks in L.

Now we concentrate on picture languages generated by transducers. If τ is a transducer (deterministic or nondeterministic), we define inductively: τ⁰(w) = {w} if w ∈ (τ) and τ^r(w) = {u | there is v ∈ τ^r−1(w), u ∈ (v)}.

Definition 2.4

An n × m-block B is generated by a transducer τ if $B{\mid }_{(1,1)}^{n\times 1}\in \mathcal{J}(\tau )$ and $B{\mid }_{(1,i+1)}^{n\times 1}\in \tau (B{\mid }_{(1,i)}^{n\times 1})$ for all 1 ≤ i < m.

Note that the requirement $B{\mid }_{(1,i+1)}^{n\times 1}\in \tau (B{\mid }_{(1,i)}^{n\times 1})$ is not equivalent to the more general property $B{\mid }_{(1,i+1)}^{1\times m}\in {\tau }^i(B{\mid }_{(1,1)}^{1\times m})$. Moreover the empty block ε is generated by a transducer τ if the initial state is also a terminal state. A n × 1-block is generated by a transducer τ if it belongs to (τ). Every transducer with non-empty input language generates blocks of size n × i for i = 1, 2.

Definition 2.5

A picture language which consists of all blocks that are generated by a deterministic (nondeterministic) transducer τ is called a picture language generated by τ and is denoted with L_τ. A picture language L is said to be transducer generated if there is a transducer τ such that L = L_τ.

The class of transducer generated picture languages is denoted with TG.

3. Local Picture Languages and TG

Given an alphabet Γ and a one-dimensional language L ⊆ Γ^* we say that L is local if there is P ⊆ Γ² such that w ∈ L if and only if F_≤2(w) ⊆ F (P).

For a n × m-block B over Γ, let B̂ denote the (n + 2) × (m + 2)-block obtained from B by surrounding B with symbols . A two-dimensional language L ⊆ Γ^** is local if there exists a finite set θ of 2×2-blocks over Γ ∪ { } such that L = {B ∈ Γ^** | F_2,2(B̂) ⊆ Θ} and we write L = L(Θ). We denote LOC(Γ) (or simply LOC) the family of all local picture languages over Γ.

A two-dimensional language L ⊆ Γ^** is factorial local (denoted FLOC) if there exists a finite set Θ of 2 × 2 blocks over Γ such that L = F(L_θ) where L_θ = {B ∈ Γ^** | ∅ ≠ F_2,2(B) ⊆ Θ}, and we write L = L(Θ). In FLOC languages the frames surrounding the blocks are removed since every sub-block of a block in the language is also in the language.

Proposition 3.1

For every L ∈ FLOC there is a transducer τ such that L_t = L.

Proof

Let L ∈ FLOC. Then L = L(Θ) for some set of tiles Θ over alphabet Γ. Define a transducer τ = (Γ, Q, δ, q₀, T) in the following way. The set of states Q is the set $Q=\{q_0\}\cup \{B{\mid }_{(i,1)}^{1,2}\mid i=1,2,B\in \mathrm{\Theta }\}$ which besides the initial state contains all columns of blocks from Θ. The set of terminal states is T = Q. The transitions are the following:

• start transitions: (q₀, a, b, q) for all q ∈ Q and $\begin{array}{c}b\\ a\end{array}=q$.

• Θ transitions: (q, a, b, q′) whenever qq′ ∈ Θ and $\begin{array}{c}b\\ a\end{array}=q^{\prime }$.

Then L = L_τ follows directly from the fact that the input/output labels are always the same for all incoming edges to a state q and are equal to the bottom and the top symbols of q respectively. One transition follows another if and only if the end states of these transitions are the first and the second column of a block in Θ.

Hence we have shown that both languages contain the same blocks consisting of more than one row and one column. Since these languages consist precisely of the factors of such blocks, we conclude that L = L_τ.

The follwing example shows that a transducer generated language may not be local even if the corresponding transducer is deterministic, and its input language is local.

Example 3.2

Consider the transducer over alphabet {a, b} as depicted in Fig. 3.1. This transducer is deterministic and all of its states are terminal except the “junk state” q₃. The initial state is q₀. The output symbols for all transitions starting at the same state are the same. The input language of the transducer τ is local (the allowed words of length 2 are all but “bb”).

Figure 3.1.

A deterministic transducer τ such that (τ) is a local language, but L_τ is not.

Suppose that L_τ is a local picture language and, there is a set Θ of allowed blocks of size k × k such that every k × k sub-block of a block in L_τ is in Θ. Let B × B′ be the following n × m-blocks where m, n > k

$$B=\begin{array}{ccccccc}a& a& a& \dots & a& a& a\\ & & \dots & & & & \\ a& a& a& \dots & a& a& a\\ a& b& a& \dots & a& a& b\end{array}{B}^{\prime }=\begin{array}{ccccccc}a& a& a& \dots & a& a& a\\ & & \dots & & & & \\ a& a& a& \dots & a& a& b\\ b& a& a& \dots & a& b& a\end{array}.$$

And let C be an (n + 1) × m-block: $C=\begin{array}{ccccccc}a& a& a& \dots & a& a& a\\ & & \dots & & & & \\ a& a& a& \dots & a& a& b\\ a& b& a& \dots & a& b& a\end{array}$.

One can think of C being a block obtained from B by adding the last column of B′ as a last column. In this case, $B=C{\mid }_{(1,1)}^{n,m}$ and $B^{\prime }=C{\mid }_{(2,1)}^{n,m}$, ie., B, B′ ∈ F(C). Quick check of the transducer shows that blocks B and B′ are in L_τ. Moreover, F_k,k(C) = F_k,k({B, B′}) ⊆ Θ. If L_τ is local, then it must be that C ∈ L_τ, but direct check shows that it, in fact, is not (note that the only way to output symbol b is when the input word starts with b, and this is not the case with the first row of C).

A tiling system is a quadruple (Σ, Γ, Θ, π) where Σ and Γ are finite alphabets, Θ is a finite set of 2 ×2 blocks over Γ ∪ { } defining a local language L(Θ) and π: Γ ↦ Σ is a map called projection. A two dimensional language L ⊆ Σ^** is tiling recognizable if there exists a tiling system (Σ, Γ, Θ, π) such that L = π(L(Θ)) (extending π to the blocks). We denote by REC(Σ) (or simply REC) the family of all tiling recognizable two dimensional languages over Σ.

Proposition 3.3

Transducer generated languages are in REC.

Proof

Assume that the transducer τ = (Σ, Q, δ, q₀, T) is given. Let Γ = QΣ = {qa | q ∈ Q and a ∈ Σ} and projection π: Γ ↦ Σ be defined by π (qa) = a. To prove the claim we define a set of blocks Θ such that π(L(Θ)) = L_τ. The set Θ consists of the union of input blocks Q_i, transition blocks Q_t, and output blocks Q_o defined below.

• Input blocks. The collection of input blocks Θ_i is the union of Θ₁, Θ₂, and Θ₃ defined as follows.

  
• Transition blocks. The collection of transition blocks Θ_t is the union of Θ₄, Θ₅, and Θ₆ defined as follows.

  
• Output blocks. The collection of output blocks Θ_o is the union of blocks Θ₇, Θ₈, and Θ₉ defined below. Since the last row of a block generated by a transducer is not necessarily accepted by the transducer (i.e., it may not be in (τ)) no transition type control is imposed on these tiles.

  

Assume that B ∈ π(L(Θ)). Then B = π (P) for some n × m-block P ∈ L(Θ). Let B_j and P_j denote the j-th rows of B and P respectively for j = 1, …, m − 1. Then B_j = j = a₁ · · · a_n and there are states q₁,…, q_n−1 such that P_j = q₀a₁ · q₁a₂ · … · q_n−1a_n. By construction of L(Θ) we have that (q_i−1, a_i, b_i, q_i) ∈ δ for some b_i ∈ Σ for every i = 0, …, n − 1, and the state q_n is in T. Hence the sequence p_j = (q₀, a₁, b₁, q₁) … (q_n−1, a_n, b_n, q_n), is an accepting path in τ such that B_j = (p_j) ∈ (τ). Moreover, by construction of the transition blocks Θ_t we have that B_j+1 = b₁ · · · b_n and so, B_j+1 = (p_j). Thus, B ∈ L_τ, i.e., π (L(Θ)) ⊆ L_τ.

Conversely, if B ∈ L_τ, then for each 1 ≤ j < m − 1 there is an accepting path p_j = (q₀, a₁, b₁, q₁)(q₁, a₂, b₂, q₃) · · · (q_n−1, a_n, b_n, q_n) of τ such that π (p_j) = B_j and (p_j) = B_j+1. Consider a n × m block P such that P_j = q₀a₁ · q₁a₂ · … · q_n−1a_n for all 1 ≤ j < m − 1 and choose P_m to be a word over the alphabet Γ such that π (P_m) = (p_m−1) = B_m. Hence π(P) = B and by construction B̂ ⊆ F_2,2(Θ). Thus B ∈ π (L(Θ)) and π (L(Θ)) = L_τ.

As noted with the following example there are picture languages in REC that are not in TG.

Example 3.4

Consider the picture language over alphabet {a, b} which consists of all blocks containing at most one appearance of b (all other symbols are a). This picture language is in REC [19]. If there were a transducer that generates this language, this transducer would have a transition with an input symbol a and output b, and a transition with input symbol b and output a. But then, there are n, s such that a^sba^n−s−1 ∈ τ (aⁿ), i.e., on an input aⁿ the transducer may output a word containing a symbol b. Hence blocks with more than three rows that are generated by the transducer can have more than one appearance of b.

4. Entropy

One measure of complexity of a given language is the average growth rate of the number of blocks that appear in the language relative their size. In one dimensional case, this measure is also called the entropy of the language and is derived from the notion of topological entropy of (compact) symbolic dynamical systems (see [12]). The Perron-Frobenious theory provides a straight-forward way of computing the entropy for a one-dimensional regular language. It is the logarithm of the maximal eigen value (also known as Perron numbers) of the adjacency matrix of the minimal deterministic automaton of the language [25]. However, obtaining a general method for computing the entropy of a two-dimensional recognizable language shows to be very difficult, and consequently, there is no general knowledge about what numbers can be realized as the entropy values in two-dimensions. In the following we show that logarithm of every Perron number can be obtained as an entropy value for a transducer generated picture language. In other words, all entropy values realized by one-dimensional regular languages can also be realized by transducer generated picture languages.

Recall that for L ⊆ Σ^* the entropy of L is $h(L)=\underset{n\to \infty }{limsup}\frac{1}{n}log(\#F_n(L))$. This definition extends to an equivalent definition in two-dimensions.

Definition 4.1

For L ∈ Σ^** the entropy of the picture language L is

$$h(L)=\underset{n\to \infty }{limsup}\frac{1}{n^2}log(\#F_{n,n}(L)).$$

Note

1. Since the entropy formula “counts” the sub-blocks of a certain size, the value of the entropy of L_τ and (τ) does not change if we consider these languages to be factorial, hence we can assume that all transducers in this sections have all their states initial and terminal. In this case, F(L_τ) = L_τ.

2. It can be shown that in this case lim sup is always finite [12], and moreover, that the limit always exists. Hence we write lim instead of lim sup.

Note that the entropy of L is always bounded by log #Σ. The entropy of L_τ is zero for any deterministic transducer τ, since for each n it contains at most #Σⁿ blocks of size n × n (each word w can generate at most one block of height n). However, if L_τ is a two dimensional language generated by a nondeterministic transducer, its entropy may no longer be zero. For example, the transducer τ = (Σ, {q}, δ, q, {q}) with δ = {(q, a, b, q)|a, b ∈ Σ}, which consists of one state with transitions having all possible labels generates L_τ = Σ^** and for each n, # F_n,n(L_τ) = #(Σ^{n × n}) = # Σⁿ². Thus h (L_τ) = h (Σ^**) = log #Σ.

For a given transducer τ and w in (τ) define deg(w) = #τ (w), i.e., deg(w) is the number of distinct words that τ can output on input w. We extend this notation to finite sets of words by setting deg(S) = max_w∈S{deg(w)}.

Observe that the number of distinct blocks of height n with the bottom row w contained in L_τ is bounded above by

$$\prod _{i=0}^{n-1}deg({\tau }^i(w)).$$

Suppose there is k > 0 such that deg(w) ≤ n^k for all w in (τ) with |w| = n. Then there are at most (n^k)ⁿ = n^nk n × n-blocks. We observe that

$$\begin{array}{l}h(L_{\tau })=\underset{n\to \infty }{lim}\frac{1}{n^2}log(\#F_{n,n}(L_{\tau }))\\ \le \underset{n\to \infty }{lim}\frac{1}{n^2}log\left(\sum _{\begin{array}{c}\mid w\mid =n\\ w\in \mathcal{J}(\tau )\end{array}}\left(\prod _{i=0}^{n-1}(deg({\tau }^i(w))\right)\right)\\ \le \underset{n\to \infty }{lim}\frac{1}{n^2}log(\#{\mathrm{\sum }}^n·n^{nk})=\underset{n\to \infty }{lim}\left[\frac{1}{n}log\#\mathrm{\sum }+\frac{k}{n}logn\right]=0.\end{array}$$

Thus if there is some positive integer k, such that for any w in (τ), #τ (w) ≤ |w|^k, the entropy of L_τ is zero. This proves:

Proposition 4.2

Let τ be a transducer. If there is a polynomial p such that #τ (w) ≤ p(|w|) for every w ∈ (w), then the entropy of L_τ is 0.

Proposition 4.3

For any regular language L there is a nondeterministic transducer τ such that (τ) = L and h(L_τ) = h(L).

Proof

Let M be a finite state automaton accepting language L. Denote the set of transitions of M by ϕ, and construct a transducer τ from M as follows. The set of states in τ remains the same as in M and the set of transitions in τ is {(q₁, a, b, q₂) | (q₁, a, q₂) ∈ ϕ and b ∈ Σ}. Observe that (τ) = L.

Now consider L_τ. Note that for an n × n-block B ∈ L_τ, every row of B must be in (τ), except maybe the last, n^th row which may not belong to (τ). Let B_p,k denote the set of all n × p-blocks B ∈ L_τ with $B{\mid }_{(1,p)}^{n,1}$ (the p^th row of block B) in (τ). Thus we conclude that #F_n,n(L_τ) ≤ #B_n,n−1#Σn ≤ #B_n,n#Σⁿ. Hence

$$\begin{array}{l}h(L_{\tau })=\underset{n\to \infty }{lim}\frac{1}{n^2}log(\#F_{n,n}(L_{\tau }))\\ \le \underset{n\to \infty }{lim}\frac{1}{n^2}log(\#B_{n,n}·\#{\mathrm{\sum }}^n)\\ =\underset{n\to \infty }{lim}\frac{1}{n^2}log\#B_{n,n}\end{array}$$

Since B_n,n ⊆ F_n,n(L_τ), we have #B_n,n ≤ #F_n,n(L_τ), hence

$$h(L_{\tau })=\underset{n\to \infty }{lim}\frac{1}{n^2}log\#B_{n,n}$$

Because the transducer can output every word of length n on any given input of length n, the number of n×n-blocks in L_τ having each of its rows in (τ) = L is exactly [#F_n( (τ))]ⁿ = (F_n(L))ⁿ, i.e., #B_n,n = [#F_n(L)]ⁿ. Thus

$$h(L_{\tau })=\underset{n\to \infty }{lim}\frac{1}{n}log\#F_n(L)=h(L)$$

Corollary 4.4

Let L be a regular language. Then the entropy of L is an upper bound for the entropy of L_τ for any nondeterministic transducer τ with (τ) = L.

Proof

Let L be a regular language and let τ = (A, Q, δ, q₀, F) be such that (τ) = L. Then consider τ′ = (A, Q, δ′, q₀, F), with δ′ = {(q, a, b, p) | (q, a, s, p) ∈ δ and b ∈ Σ}. Hence δ ⊆ δ′ and h(L_τ) = h(L_τ′). By the proof of the Proposition 4.3, h(L_τ′) = h( (τ)) = h(L).

5. Representing Transducers with Wang Tiles

The relationship between transducers and Wang tiles has been used by J. Kari [16] for generating small set of aperiodic Wang tiles, and the idea that iteration of transducers can correspond to some two-dimensional local languages was implicitly used in [23]. In [13] it was observed that composition of transducers can generate all computable functions. The transducer generated languages are not necessarily local, as they do not necessarily correspond to the languages associated with Wang tiles (e.g., Example 3.2). However, there is a natural way to describe the transducer transitions by Wang tiles as shown below. We use the projection of these Wang tiles on their bottom color to represent the strings outputted by the transducer and to guide the arrangements of the robotic arms in arrays.

A finite set of distinct unit squares with colored edges is called a set of Wang prototiles. We assume that each prototile has an arbitrarily large number of copies called tiles. A tile ξ with left edge colored l, bottom edge colored b, top edge colored t and right edge colored r is denoted with τ = [l, b, t, r]. No rotation or reflexion of the tiles is allowed. Two tiles ξ = [l, b, t, r] and ξ′ = [l′, b′, t′, r′] can be placed next to each other, ξ to the left of ξ′ iff r = l′, and ξ′ on top of ξ iff t = b′.

To each transducer τ we associate a collection of Wang tiles.

• Input and output tiles. Four fixed colors, denoted β_l, β_b, β_r, β_t, called borders, are used in the set of colors, each representing one of the left, bottom, right and top border. For each symbol a ∈ A an input prototile ξ_a = [c, β_b, a, c] is added. There are #Σ such input prototiles. The left and right sides are colored with a new color which is the same for every symbol a, called the connect color c. The “start of input” prototile [β_l, β_b, c_q0, c] (the color c_q0 indicates the start of the computation) and the “end of input” prototile [c, β_b, α, β_r] (α is an end of input symbol, allowing to add the right border color) are also added. The output prototiles which “cap-off” the computation are essentially the same as the input tiles, except they have the “top” border: ${\xi }_a^{\prime }=[c^{\prime },a,{\beta }_t,c^{\prime }]$ where c′ is another connect color. The output row of tiles starts with a top-left corner tile [β_l, c_q0, β_t, c′] and ends with a top-right corner [c′, α, β_t, β_r].

We denote this set with B_τ.

• Computational tiles. Given transducer τ, to each transition of the form (q, a, a′, q′) we associate a prototile [q, a, a′, q′] as presented in Fig. 5.1. Hence, there are as many computational prototiles as there are transitions in τ. Additional left border tile [β_l, c_qo, c_qo, q₀] is added in order to start the computation of the transducer. Similarly, right border tiles [q, α, α, β_r] are added for each terminal state q.

Figure 5.1.

A computational tile for a transducer.

We call this set of prototiles C_τ.

• Finite state automaton tiles. Single row blocks in the language L_τ are precisely the blocks that define (τ). In order to generate these blocks with Wang tiles, we include prototiles that simulate the transitions of the transducer as a finite state automaton, but instead of output, the top color is immediately the border color. Hence, to start reading the input, we include the prototile [β_l, c_q0, β_t, q_o]. For each transition of the form (q, a, a′, q′) in τ we include a prototile [q, a, β_t, q′], and finally we include protitiles [q, α, β_t, β_r] for each terminal state q ∈ T.

We denote this set of prototiles A_τ.

The Wang prototiles that correspond to the transducer τ are = A_τ ∪ B_τ ∪ C_τ. With these sets of input and output prototiles, every iterated computation of τ can be modeled as a tiled rectangle surrounded by boundary colors. In particular one run of the transducer τ reading an input of length n and producing an output is obtained with a tiled n × 3 rectangle (n > 2) such that the sides of the rectangle are colored with boundary colors. As an example consider the transducer T presented in Fig. 5.2(a). It has initial and terminal state s₀ with input/output alphabet {0, 1}. It accepts the set of binary strings that represent numbers divisible by 3. The output is the result of the division of the binary string with three. On input 10101 (21 in decimal) the transducer gives the output 00111 (7 in decimal). The states s₀, s₁, s₂ represent the remainder of the division of the input string with 3. Instead of the last row with boundary color on top, an additional row of tiles can stack on top of the first computation, iterating the transducer by taking its output as a new input.

Figure 5.2.

Left: a transducer that outputs the result of dividing the binary string with 3 in binary; right: tiles representing a single computation of the transducer reading an input 10101 and producing output 00111. The shades of brown indicate the border colors, and shades of blue indicate the connectors c and c′. The gold to the left represents c_q0 and the pink to the right is the end of input symbol α. The states colors are shades of purple whereas the symbol 0 is red and the symbol 1 is white.

The set of all rectangular tilings with border colors on top, left, bottom and right obtained from tiles in is denoted with W( ). Consider the projection π: → Σ projecting on the bottom color of a tile defined with π ([l, b, t, r]) = b. Then, directly from the construction we have:

Proposition 5.1

A rectangular (n + 2) × (m + 1)-array of tiles P is in W( ) if and only if there is an n × m-block B in L_τ such that B(i, j) = π (P (i + 1, j + 1)) for all i = 1, …, n and j = 1, …, m.

The above proposition indicates that blocks in L_τ are obtained from rectangular arrays in W ( ) by removing boundary tiles (left and right sides, and the bottom boundary tiles) and projecting the remaining tiles to their bottom color. For example, the rectangular 7×3-array of tiles in Figure 5.2(right) defines the 5×2-block $\begin{array}{ccccc}0& 0& 1& 1& 1\\ 1& 0& 1& 0& 1\end{array}$.

6. Molecular Implementation

The base row of the two-dimensional array of molecular robotic arms arrangement can be obtained through a set of TX molecules that simulates the execution of a transducer.

Wang tiles are simulated by DNA TX molecules. The colors represent “sticky ends” in the TX molecule and the border colors represent “hairpin ends” such that no assembly is allowed after the border. Each prototile may appear in large number of molecular copies as separately annealed DNA TX molecules. No rotation of the tiles is assured by the coding of the sticky ends. The basic TX tile representing one transition of the transducer schematically is depicted in Fig. 6.1.

Figure 6.1.

A basic TX tile representing one transition of the transducer.

The transducer transitions use tiles made of triple crossover (TX) DNA molecules with sticky ends corresponding to one side of the Wang tile. An example of such molecule is presented in Fig. 6.1(right) with 3′ ends indicated with arrowheads. The connector is a sticky part that does not contain any information but it is necessary for the correct assembly of the tiles. These TX tiles have the middle duplex longer than the other two. It has been shown that such TX molecules can self-assemble in an array [22]. In [5], an implementation of the transducer represented in Figure 5.2 on variable, programmable inputs is reported. The input is adjusted through a sequence of PX-JX₂ devices. In [31] the sequence-dependent PX-JX₂ 2-state nanomechanical device is reported. This robust device, whose machine cycle is shown in Fig. 6.2 is directed by the addition of set strands to the solution that forms its environment. The set strands, drawn green and purple, establish which of the two states the device assumes. They differ by rotation of a half-turn. The sequence-driven nature of the device means that many different devices can be constructed, each of which is individually addressable; this is done by changing the sequences of the strands connecting the DX portion AB with the DX portion A′B′ where the green or purple strands pair with them. The green and purple strands have short, unpaired extensions on them. The state of the device is changed by binding the full biotin-tailed complements of green or purple strands, removing them from solution by magnetic streptavidin beads, and then adding the other strands. In [24, 9] it was shown that these devices can be linearly ordered and each can be individually addressable. Precisely this property of the device is used to obtain a programmable input for the transducer in [5]. Linear arrays of a series of PX-JX₂ devices have been adapted to set the input of the transducer. The computational set-up corresponding to the Wang tiles in Fig. 5.2(b) is illustrated schematically in Fig. 6.3. In Fig. 6.3 one base row corresponding to the input is depicted, as in the example shown in Fig. 5.2 with computational tiles made of DNA triple crossover (TX) molecules.

Figure 6.3.

Schematic view of the base-row programming the array.

6.1. Arranging Devices in an Array

A series of PX-JX₂ devices inserted into gaps in a 2D TX array is reported in [6]. Each of these devices is controlled individually, corresponding to the presence of a particular strand in the solution (n devices lead to 2ⁿ states). The developed cassette is shown schematically in both of its states in Fig. 6.4. Portions (a) and (b) show the cassette in the PX state; (a) is perpendicular to its plane, and (b) is oblique (parts (c) and (d) show similar views of the JX₂ state). The cassette consists of three helical domains, one of which is much shorter than the other two. The short domain is the insertion domain. It contains sticky ends that enable its cohesion roughly perpendicular (~ 103°) to the array that supports it [6]. The other two domains are the device in either the PX or JX₂ state. The array that was selected for insertion is the triple crossover (TX) tile array [22]. In this array, the TX tiles are connected as shown in Fig. 6.5.

Figure 6.4.

Schematic view of the cassette containing the devices. View parallel to the array (a) and perpendicular from the top of the array (b).

Figure 6.5.

Schematic view of the TX array with two distinct positions of the arms obtained through the two distinct states of the devices.

6.2. Arranging Robotic Arms in a Programmed Array

A base of the array is programmed such that the PX-JX₂ devices can be placed in a predesigned arrangement. The base row generated by one execution of the transducer defines the first arrangement of the devices. This is depicted in Fig. 6.6. The linear assembly of the bottom devices (input devices) is the arrangement which defines an input. With different choices of positions of the devices in PX or JX₂ positions, the input symbol is specified as a or b. The chosen input in the figure is ababa which corresponds to the binary string 10101. The output produced by the transducer is the string bbaaa representing the binary string 00111.

Figure 6.6.

Schematic view of the programmed device arrangement

The output sets the choice of particular cassettes (see Fig. 6.4) to be placed in the array. Cassettes containing the device in a JX₂ form are encoded to correspond to output b and a different cassette (with opposite control sequences and different sticky ends in its binding domain) containing the device in a PX form are encoded to correspond to output a. Hence, the same set of set strands shall move the devices from JX₂ into PX and the devices from PX into JX₂ form. This is done using control sequences on the device frames that put one device in the PX state, and the other device in the JX₂ state, using the same set strands; the other set strands achieve exactly the opposite result. The continuation of the assembly into a larger array is similar to the one shown in Fig. 6.5 except, now the TX molecules within the array would transfer the code of the output and all subsequent rows with cassettes would contain the same PX and JX₂ initial setting of the devices. This is represented schematically by the light and dark blue TX tiles in Fig. 6.6. By applying the set strands that exchange the devices from one state into another the arms (hairpins) can be moved synchronously from one position into another (schematically, the arms being “up” change to “down”, and those being “down” change to “up”).

A transducer generated array can be obtained by allowing third, fourth etc. rows of assembly. Note that it is not necessary that transition molecules be implemented immediately on the input. Hence, the first arrangement of the devices can be specified by the defined input, but after the first block of the arranged devices, the transition molecules can be applied and the next assembly of the array could follow the arrangement of the devices as a result of the transducer implementation. Of course, one can apply the transition molecules after the second block of arrangements and the subsequent arrangement of the devices would be according to the next output. This is schematically presented in Fig.6.7 where it is shown the change of the positions of the arms after the set strands have been applied. The arrangement of the arms in Fig. 6.7 corresponds to the 5 × 2-block obtained as a projection of the Wang tile array in Fig. 5.2(right). Two symbols of the input a and b are represented with squares colored light and dark blue respectively. The TX transition molecules are represented with squares colored yellow. Cassettes and the arms made of hairpins are colored red. On the left of the figure, the position of the arms is according to the initial state of the devices, and on the right it is in a position after the set strands have been applied resulting in a synchronous movement of the arms.

Figure 6.7.

Simultaneous movement of the arms in a programmed arrangements of devices.

7. Concluding Remarks

This paper introduces a class of two-dimensional arrays of symbols generated by transducers. This class consists of languages which are included in REC and also contain all factorial local picture languages. If entropy is taken as a measure of complexity, this class shows to have rich pattern generation capabilities. Characterization of patterns that can be generated by iteration of transducers may be of interest in applications, in particular, in algorithmic self-assembly of two-dimensional arrays with DNA tiles. Also, it may be of interest to investigate some decidability questions for these languages: for example, given a language in TG, is there an m × n-block in the language for every m, n? The relationship of the class TG with the class of unambiguous (or non-deterministic) picture languages as well as transitivity and mixing properties of these languages remain to be investigated as well.

Figure 6.2.

The PX-JX₂ device.