AuDaLa is Turing Complete

AuDaLa is a recently introduced programming language that follows the new data autonomous paradigm. In this paradigm, small pieces of data execute functions autonomously. Considering the paradigm and the design choices of AuDaLa, it is interesting to determine the expressiveness of the language and to create verification methods for it. In this paper, we take our first steps to such a verification method by implementing Turing machines in AuDaLa and proving that implementation correct. This also proves that AuDaLa is Turing complete.

💡 Research Summary

The paper “AuDaLa is Turing Complete” investigates the expressive power of AuDaLa, a newly introduced programming language that follows the data‑autonomous paradigm. In this paradigm, small pieces of data are active agents that execute functions on their own, thereby making parallel execution the default mode of computation. The authors ask whether AuDaLa, despite being designed as a domain‑specific parallel language, is expressive enough to be considered a general‑purpose language. To answer this, they set out to prove that AuDaLa is Turing‑complete by providing a concrete implementation of a deterministic Turing machine (TM) inside AuDaLa and by formally arguing that the implementation faithfully simulates the TM semantics.

The paper begins with a concise introduction to the motivation behind AuDaLa. Modern performance gains are increasingly obtained through parallelism, and most languages expose threads, processes, or explicit parallel constructs. AuDaLa, by contrast, abstracts away the notion of active processors and memory management; data elements themselves carry out functions autonomously. This design promises automatic parallelism, separation of concerns, and a “bottom‑up” programming model. However, because AuDaLa’s design is heavily influenced by domain‑specific languages, its expressive power is not obvious. The authors therefore aim to establish a lower bound on expressiveness by proving Turing completeness.

Section 2 formalises the TM model used for the proof. The authors adopt the standard 7‑tuple definition (states Q, start state q₀, accepting set F, tape alphabet Γ, input alphabet Σ, blank symbol B, transition function δ). They restrict attention to deterministic machines and assume a non‑empty input. Configurations are defined as pairs (q, t) where t:ℤ→Γ describes the infinite tape, with cell 0 being the head. The transition relation is defined in the usual way, moving the head left or right and updating the tape symbol.

Section 2.2 describes the actual AuDaLa implementation. The tape is modelled as a doubly‑linked list of structs called TapeCell, each holding a left pointer, a right pointer, and an integer symbol. The control unit is a struct Control that stores a reference to the current head cell, the current state, and a Boolean flag indicating whether the current state belongs to the accepting set. The AuDaLa program consists of three parts: (1) struct definitions, (2) “steps” (functions) that are executed in parallel on the data types, and (3) a schedule that first runs an init step once and then repeatedly runs a transition step. Because AuDaLa does not allow loops inside steps, iteration is achieved by the external scheduler.

The init step constructs a chain of TapeCell instances for each symbol of the input string, links them together, and creates a single non‑null Control instance pointing at the leftmost cell with state q₀. The transition step encodes the TM’s transition function δ as a large if‑else‑if chain: each clause checks whether the current state and the symbol under the head match a particular entry of δ, then updates the symbol, changes the state, sets the accepting flag, and moves the head left or right, allocating a new TapeCell when the head moves beyond the current bounds. The authors note that the code for a left move is analogous to the right‑move case shown.

Section 3 provides the correctness argument. The authors introduce the notion of an “implementation configuration” (q_P, t_P) derived from the concrete AuDaLa state: q_P is the value of the state field of the unique non‑null Control instance, and t_P maps each integer index i to the symbol stored in the corresponding TapeCell (i = 0 for the head, negative indices follow the left pointers, positive indices follow the right pointers). They prove that every implementation configuration is also a valid TM configuration.

Determinism is a central theme. Lemma 1 establishes that any non‑deterministic step in AuDaLa must involve a data race (simultaneous accesses to the same parameter by distinct struct instances). Lemma 2 shows that init is deterministic because it runs when only the null‑instance of Control exists, so no race is possible. Lemma 3 proves that after init the implementation configuration exactly matches the TM’s initial configuration (q₀, t_S). Lemma 4 and Lemma 5 extend determinism to any reachable idle state with a single non‑null Control instance, showing that each execution of transition is deterministic and contains no data races. Lemma 6 is the key simulation lemma: if an implementation configuration corresponds to a TM configuration, then executing one transition step yields a new implementation configuration that corresponds precisely to the TM’s next configuration according to δ.

By inductively applying Lemma 6 from the initial configuration, the authors argue that the AuDaLa program reproduces the exact sequence of TM configurations, halting exactly when the TM reaches an accepting state. Consequently, AuDaLa can simulate any deterministic TM, establishing that AuDaLa is Turing‑complete.

The conclusion restates the result and outlines future work: extending the verification methodology to full AuDaLa programs, handling the weak memory model variant of AuDaLa’s semantics, and possibly exploring automated verification tools.

Overall, the paper succeeds in demonstrating that AuDaLa can encode a universal computational model, thereby providing a solid lower bound on its expressive power. The proof is structured around a series of lemmas that connect the concrete AuDaLa state to the abstract TM state, and the implementation is described in sufficient detail to be reproducible. However, the manuscript suffers from numerous typographical and formatting issues (e.g., broken line breaks, inconsistent notation, and OCR artifacts) that hinder readability. The reliance on a massive if‑else‑if chain for δ may be impractical for machines with large state spaces, suggesting that a more scalable encoding (e.g., using hash tables or pattern‑matching constructs) could improve performance and clarity. Moreover, several lemmas are stated without full proofs, with references to an appendix that is not included in the excerpt; a more self‑contained presentation would strengthen the argument for readers unfamiliar with AuDaLa’s formal semantics. Despite these shortcomings, the paper makes a valuable contribution by bridging a novel parallel programming paradigm with classical computability theory, and it lays groundwork for future verification efforts in data‑autonomous languages.