Part II

Regulatory Sequences as Control Flow — DNA-Lang, Part II

Matthew Long · YonedaAI Research Collective · Chicago, IL · PDF

Keywords: gene regulation, type theory, control flow, promoters, enhancers, silencers, regulatory networks, category theory, fixed points, Haskell

1 Introduction

The central dogma of molecular biology describes the flow of genetic information from DNA to RNA to protein. Yet the regulation of this flow—which genes are expressed, when, at what level, and in which cell types—is arguably more computationally interesting than the flow itself. A human genome contains approximately 20,000 protein-coding genes, but the regulatory sequences that control their expression comprise a far larger fraction of the genome and exhibit combinatorial complexity that rivals any programming language’s control flow semantics.

In programming language theory, control flow refers to the mechanisms by which a program determines which instructions to execute, in what order, and under what conditions. The fundamental control flow primitives—function calls, conditional branching, loops, exceptions, and concurrency constructs—provide a vocabulary for expressing computational intent.

We observe a striking structural correspondence between these programming constructs and the regulatory elements of eukaryotic genomes:

Programming Concept	Biological Element	Mechanism
Function entry point	Promoter	Transcription initiation
Remote configuration	Enhancer	Looping / action at distance
Access control / denial	Silencer	Transcriptional repression
Namespace boundary	Insulator	Chromatin domain separation
Expression level	mRNA abundance	Transcription rate control
Feedback loop	Autoregulation	Self-referential circuits

This paper formalizes this correspondence. We develop a type-theoretic framework in which:

Promoters are modeled as typed function entry points with binding-affinity parameters.
Enhancers are remote configuration operators that modify expression through long-range chromatin interactions.
Silencers implement permission-denial semantics through repression.
Insulators partition the regulatory landscape into independent namespaces.
Gene regulatory networks form categories with genes as objects and regulatory effects as morphisms.
Feedback loops arise as fixed points in these categories.

The framework is implemented in Haskell with a parametric Regulator $⟨$ a $⟩$ type that tracks expression levels through a refinement lattice. We prove that the four regulatory primitives form a complete control algebra and demonstrate the construction of Boolean gene circuits.

This paper is the second in a series of seven papers constituting the DNA-Lang project, which aims to develop a complete programming language whose semantics are grounded in molecular biology. Paper 1 established the correspondence between coding sequences and typed functions; here we extend the framework to encompass the regulatory layer.

1.1 Contributions

A formal type-theoretic model of regulatory sequences as control flow primitives ([sec:promoters,sec:enhancers,sec:silencers]).
The Regulator $⟨$ a $⟩$ parametric type with a lattice of expression levels (5).
A categorical formalization of gene regulatory networks (6).
Fixed-point characterization of feedback loops (7).
A Regulatory Completeness Theorem (8).
Boolean gene circuit constructions (9).
A complete Haskell implementation (10).

1.2 Relation to the DNA-Lang Series

The DNA-Lang project develops a modular framework for biological computation. Each paper in the series formalizes one layer of the biological hierarchy:

Paper 1: Coding sequences as typed functions (the base layer).
Paper 2: Regulatory sequences as control flow (this paper, building on Paper 1).
Papers 3–7: Epigenetic marks, non-coding RNA, repetitive elements, structural DNA, and developmental programs—each composing modularly with the layers below.

The modular composition principle is central: each layer builds upon and composes with the previous layers, and emergent properties arise at each level of composition.

2 Promoters as Function Entry Points

In both programming languages and molecular biology, the concept of an entry point determines where execution (or transcription) begins and with what initial parameters.

2.1 Biological Background

A promoter is a DNA sequence, typically 100–1000 base pairs upstream of a gene, that serves as the binding site for RNA polymerase and associated transcription factors. The key components include:

TATA box: A conserved sequence (consensus TATAAA) located approximately 25–30 bp upstream of the transcription start site (TSS), recognized by TATA-binding protein (TBP).
Initiator element (Inr): Encompasses the TSS itself, with consensus PyPyAN(T/A)PyPy.
Upstream elements: GC boxes, CAAT boxes, and other motifs that modulate basal transcription levels.
Proximal promoter: The region within $\sim$ 250 bp of the TSS, containing binding sites for sequence-specific transcription factors.

2.2 Type-Theoretic Formalization

Definition 1 (Promoter Type). A promoter is a tuple $P = (s, b, σ, ℓ_{0})$ where:

$s \in Σ^{*}$ is the DNA sequence of the promoter region,
$b : T F \to [0, 1]$ is a binding affinity function mapping transcription factors to their binding probabilities,
$σ \in N$ is the strength parameter (a measure of basal transcription rate),
$ℓ_{0} \in E x p r ess i o n L e v e l$ is the default expression level when only basal transcription machinery is present.

We model this as a Haskell data type:

data Promoter = Promoter
  { promoterSequence :: String
  , tataBox          :: Maybe TATABox
  , bindingAffinity  :: Double   -- 0.0 to 1.0
  , basalLevel       :: Double   -- basal transcription rate
  , promoterStrength :: PromoterStrength
  } deriving (Show, Eq)

data PromoterStrength = Weak | Moderate | Strong | VeryStrong
  deriving (Show, Eq, Ord, Enum, Bounded)

Definition 2 (Promoter as Function Entry Point). The correspondence between promoters and function entry points is given by the mapping: $Φ_{P} : P r o m o t er \to (T F C o n t e x t \to E x p r ess i o n L e v e l)$ where $Φ_{P} (P) (c t x)$ computes the expression level by evaluating the binding affinity of each transcription factor in context $c t x$ against the promoter’s binding sites, weighted by the promoter strength $σ$ .

Proposition 3 (Promoter Monotonicity). For a fixed promoter $P$ , the function $Φ_{P} (P) : T F C o n t e x t \to E x p r ess i o n L e v e l$ is monotone with respect to the inclusion ordering on transcription factor contexts and the expression level lattice: $c t x_{1} \subseteq c t x_{2} ⟹ Φ_{P} (P) (c t x_{1}) ⊑ Φ_{P} (P) (c t x_{2})$ when all transcription factors in $c t x_{2} ∖ c t x_{1}$ are activators.

Proof. Let $c t x_{1} \subseteq c t x_{2}$ and suppose every factor $f \in c t x_{2} ∖ c t x_{1}$ is an activator, meaning $b (f) > 0$ contributes positively to transcription rate. The expression level is computed as: $ℓ = ℓ_{0} + σ \cdot f \in c t x \sum b (f) \cdot w (f)$ where $w (f) > 0$ for activators. Since each additional activator adds a non-negative term, $ℓ (c t x_{2}) \geq ℓ (c t x_{1})$ , and by the lattice structure of ExpressionLevel, we have $Φ_{P} (P) (c t x_{1}) ⊑ Φ_{P} (P) (c t x_{2})$ . ◻

2.3 TATA Box as Calling Convention

The TATA box establishes a calling convention—a standardized protocol by which the transcription machinery locates and initiates transcription.

Definition 4 (TATA Calling Convention). A TATA-containing promoter establishes the calling convention: $T A T A C o n v e n t i o n = (T B P_bin d s, p os i t i o n_{- 25}, or i e n t_{downstream})$ This is analogous to the C calling convention specifying stack frame layout, argument passing order, and return address placement.

TATA-less promoters correspond to alternative calling conventions (analogous to fastcall or stdcall), where CpG islands or downstream promoter elements substitute for the TATA box.

3 Enhancers as Remote Configuration

3.1 Biological Background

Enhancers are regulatory DNA elements that increase transcription of target genes and can function over distances of up to 1 megabase. They operate independently of orientation and position relative to the target promoter. The mechanism involves DNA looping, mediated by proteins such as cohesin and CTCF, which brings the enhancer into physical proximity with the promoter.

3.2 The Action-at-a-Distance Problem

In programming languages, the analogous concept is action at a distance: a mechanism by which code in one part of a program affects behavior in a distant part without an explicit connection. Environment variables, global configuration, and dependency injection all exhibit this property.

Definition 5 (Enhancer Type). An enhancer is a tuple $E = (s, d, μ, λ)$ where:

$s \in Σ^{*}$ is the enhancer DNA sequence,
$d \in N$ is the genomic distance (in base pairs) to the target promoter,
$μ : [0, 1]$ is the modification factor (fold-change in expression),
$λ \in [0, 1]$ is the looping probability, which decreases with distance.

data Enhancer = Enhancer
  { enhancerSequence   :: String
  , targetDistance      :: Int        -- base pairs to target
  , foldChange         :: Double     -- multiplication factor
  , loopingProbability :: Double     -- distance-dependent
  , enhancerTFs        :: [String]   -- bound transcription factors
  } deriving (Show, Eq)

3.3 The Looping Model

The probability of enhancer-promoter contact decreases with genomic distance according to a power law: $λ (d) = λ_{0} \cdot (\frac{d _{0}}{d})^{γ}$ where $λ_{0}$ is the contact probability at reference distance $d_{0}$ , and $γ \approx 1.0$ – $1.5$ is the scaling exponent determined by polymer physics.

Definition 6 (Effective Enhancement). The effective enhancement of an enhancer $E$ on a promoter $P$ is: $E (E, P) = 1 + (μ - 1) \cdot λ (d)$ This represents the expected fold-change in expression, accounting for the stochastic nature of chromatin looping.

Proposition 7 (Enhancer Composability). Multiple enhancers $E_{1}, \dots, E_{n}$ acting on the same promoter compose multiplicatively: $E (E_{1}, \dots, E_{n}; P) = i = 1 \prod n E (E_{i}, P)$ when the enhancers bind non-overlapping sets of transcription factors.

Proof. When transcription factor binding events are independent (non-overlapping binding sites), the probability of simultaneous occupancy factorizes. Each enhancer contributes its fold-change independently to the overall transcription rate, yielding a multiplicative composition law. ◻

3.4 Enhancers as Environment Variables

The analogy with environment variables is precise:

Enhancer Property	Environment Variable Analogy
Acts at a distance	Visible across scopes
Position-independent	Order-independent in environment
Orientation-independent	Key-value (not positional)
Multiple enhancers compose	Multiple env vars combine
Tissue-specific activity	Context-dependent resolution

4 Silencers as Access Control

4.1 Biological Background

Silencers are regulatory elements that reduce or abolish transcription of target genes. They recruit repressor proteins that either directly block the transcription machinery or modify chromatin structure to a repressive state (heterochromatin).

Insulators (also called boundary elements) are a related class of elements that partition the genome into independent regulatory domains, preventing enhancers in one domain from activating promoters in another.

4.2 Repression as Permission Denial

Definition 8 (Silencer Type). A silencer is a tuple $S = (s, r, δ)$ where:

$s \in Σ^{*}$ is the silencer DNA sequence,
$r : R e p r essor \to [0, 1]$ is the repression function mapping repressor proteins to their silencing efficacy,
$δ \in [0, 1]$ is the damping factor applied to expression level.

The silencer modifies the expression level by: $ℓ^{'} = ℓ \cdot (1 - δ \cdot ρ \in bound max r (ρ))$

data Silencer = Silencer
  { silencerSequence :: String
  , repressionLevel  :: Double   -- 0.0 = no effect, 1.0 = full silence
  , silencerType     :: SilencerType
  } deriving (Show, Eq)

data SilencerType = Classical | Polycomb | Heterochromatin
  deriving (Show, Eq)

Definition 9 (Access Control Semantics). The silencer-access control correspondence is formalized as: $c h ec k P er mi ss i o n : G e n e \times C e l l C o n t e x t \to {A l l o w, D e n y}$ where: $c h ec k P er mi ss i o n (g, c t x) = {D e n y A l l o w if \exists S \in silencers (g) : δ (S, c t x) > θ otherwise$ Here $θ$ is a threshold above which the silencer effect is sufficient to prevent transcription.

4.3 Insulators as Namespace Boundaries

Definition 10 (Insulator Type). An insulator $I = (s, β)$ defines a namespace boundary where:

$s \in Σ^{*}$ is the insulator sequence (often a CTCF binding site),
$β \in [0, 1]$ is the barrier strength.

An insulator partitions the regulatory landscape into scopes: $scope (P) = {E ∣ ∄ I between E and P with β (I) > θ_{I}}$

Proposition 11 (Namespace Isolation). If an insulator $I$ with barrier strength $β > θ_{I}$ lies between enhancer $E$ and promoter $P$ , then the effective enhancement is bounded: $E (E, P ∣ I) \leq 1 + (μ - 1) \cdot λ (d) \cdot (1 - β)$ In the limit $β \to 1$ , the enhancer has no effect: $E (E, P ∣ I) \to 1$ .

Proof. The insulator reduces the looping probability by a factor $(1 - β)$ , since the insulator protein (typically CTCF) creates a topological barrier to chromatin loop formation. Substituting the attenuated looping probability into 6 yields the bound. ◻

5 The $R e g u l a t or \ensuremath ⟨ E x p r ess i o n L e v e l \ensuremath ⟩$ Type

We now unify the regulatory elements into a single parametric type.

5.1 The Expression Level Lattice

Definition 12 (Expression Level). The expression level is an element of the lattice: $L = O f f ⊑ B a s a l ⊑ I n d u ce d (d) ⊑ M a x$ where $d \in R_{> 0}$ parameterizes the induction level. The lattice operations are: $O f f ⊔ x M a x ⊔ x I n d u ce d (d_{1}) ⊔ I n d u ce d (d_{2}) = x = M a x = I n d u ce d (max (d_{1}, d_{2})) O f f ⊓ x M a x ⊓ x = O f f = x$

data ExpressionLevel
  = Off
  | Basal
  | Induced Double
  | Max
  deriving (Show, Eq)

instance Ord ExpressionLevel where
  compare Off Off = EQ
  compare Off _   = LT
  compare _ Off   = GT
  compare Max Max = EQ
  compare Max _   = GT
  compare _ Max   = LT
  compare Basal Basal = EQ
  compare Basal (Induced _) = LT
  compare (Induced _) Basal = GT
  compare (Induced a) (Induced b) = compare a b

5.2 The Regulator Type

Definition 13 (Regulator). The Regulator type is a parametric record: $R e g u l a t or ⟨ a ⟩ = (P r o m o t er, [E nhan cer], [S i l e n cer], a \to E x p r ess i o n L e v e l)$ This encapsulates the complete regulatory context for a gene, where the output function $a \to E x p r ess i o n L e v e l$ maps an input signal of type $a$ to an expression level.

data Regulator a = Regulator
  { regPromoter   :: Promoter
  , regEnhancers  :: [Enhancer]
  , regSilencers  :: [Silencer]
  , regOutput     :: a -> ExpressionLevel
  }

Theorem 14 (Regulator Composition). Given regulators $R_{1} : R e g u l a t or \ensuremath ⟨ a \ensuremath ⟩$ and $R_{2} : R e g u l a t or \ensuremath ⟨ b \ensuremath ⟩$ , their composition $R_{1} \circ R_{2} : R e g u l a t or \ensuremath ⟨ (a, b) \ensuremath ⟩$ is defined by: $(R_{1} \circ R_{2}) . r e g O u tp u t (a, b) = R_{1} . r e g O u tp u t (a) ⊓ R_{2} . r e g O u tp u t (b)$ with the promoter taken from $R_{1}$ , enhancers concatenated, and silencers merged by maximum repression.

Proof. We verify the lattice properties. The meet operation $⊓$ on ExpressionLevel is associative, commutative, and idempotent (it forms a semilattice). The concatenation of enhancer lists is associative with identity $[]$ . The maximum-repression merge of silencers is associative and commutative. Therefore the composition is well-defined and associative, making $R e g u l a t or$ a valid compositional type. ◻

Definition 15 (Refined Regulator). A refined regulator $R_{ϕ}$ is a regulator equipped with a refinement predicate $ϕ$ : $R_{ϕ} = {R : R e g u l a t or \ensuremath ⟨ a \ensuremath ⟩ ∣ ϕ (R . r e g O u tp u t)}$ Common refinements include: $ϕ_{active} ϕ_{binary} ϕ_{graded} : \forall a . R . r e g O u tp u t (a) ⊒ B a s a l : \forall a . R . r e g O u tp u t (a) \in {O f f, M a x} : \forall a_{1}, a_{2} . a_{1} \leq a_{2} ⟹ R . r e g O u tp u t (a_{1}) ⊑ R . r e g O u tp u t (a_{2})$

The binary refinement $ϕ_{binary}$ is particularly important—it characterizes gene circuits that function as digital logic gates, which we explore in 9.

6 Gene Regulatory Networks as Categories

6.1 The Category $GRN$

Definition 16 (GRN Category). A gene regulatory network category $GRN$ consists of:

Objects: Genes $g_{1}, g_{2}, \dots, g_{n}$ together with their associated regulators.
Morphisms: Regulatory effects $f : g_{i} \to g_{j}$ , representing the influence of gene $g_{i}$ ’s product on gene $g_{j}$ ’s expression.
Composition: If $f : g_{i} \to g_{j}$ and $h : g_{j} \to g_{k}$ , then $h \circ f : g_{i} \to g_{k}$ represents the transitive regulatory effect.
Identity: $id_{g_{i}} : g_{i} \to g_{i}$ represents the absence of self-regulation (neutral effect).

We must verify the category axioms:

Proposition 17 (GRN Category Axioms). $GRN$ satisfies the category axioms:

Associativity: $(k \circ h) \circ f = k \circ (h \circ f)$ for composable morphisms.
Identity: $f \circ id = f$ and $id \circ f = f$ .

Proof. Regulatory effects are modeled as functions $E x p r ess i o n L e v e l \to E x p r ess i o n L e v e l$ on the expression level lattice. Function composition is associative, and the identity function satisfies both identity laws. ◻

6.2 Morphisms as Regulatory Effects

Each morphism in $GRN$ carries additional structure:

Definition 18 (Regulatory Morphism). A regulatory morphism $f : g_{i} \to g_{j}$ is a triple $(t, w, τ)$ where:

$t \in {A c t i v a t i o n, R e p r ess i o n}$ is the regulatory type,
$w \in R_{> 0}$ is the weight (strength of the effect),
$τ \in R_{\geq 0}$ is the time delay (for dynamic models).

The categorical structure enables us to reason about regulatory network topology:

Definition 19 (Network Motifs as Diagrams). Common network motifs correspond to categorical diagrams:

Feed-forward loop: A diagram $A \to B \to C$ with $A \to C$ .
Feedback loop: A morphism $f : A \to B$ with $g : B \to A$ such that $g \circ f \neq = id_{A}$ .
Bifan: Morphisms $A \to C$ , $A \to D$ , $B \to C$ , $B \to D$ .

A coherent feed-forward loop in

GRN

. The diagram commutes (

g \circ f = h

) when the indirect path

A \to B \to C

produces the same regulatory effect as the direct path

A \to C

6.3 Functors Between GRNs

Definition 20 (GRN Functor). A GRN functor $F : GRN_{1} \to GRN_{2}$ maps:

Genes in network 1 to genes in network 2,
Regulatory effects to regulatory effects,

preserving composition and identities. This formalizes the notion of regulatory homology between organisms.

Example 21. The Hox gene regulatory network is conserved across metazoa. The functor $F : GRN_{Drosophila} \to GRN_{mouse}$ maps homeotic selector genes to their murine homologs while preserving the colinear regulatory structure.

7 Feedback Loops as Fixed Points

Feedback loops are morphisms in $GRN$ that create self-referential circuits. We formalize them using fixed-point theory.

7.1 Positive Feedback and Bistability

Definition 22 (Positive Feedback Loop). A positive feedback loop on gene $g$ is an endomorphism $f : g \to g$ in $GRN$ with $t = A c t i v a t i o n$ . The steady states are the fixed points: $Fix (f) = {ℓ \in L ∣ f (ℓ) = ℓ}$

Theorem 23 (Bistability Theorem). A positive feedback loop with a sigmoidal activation function $f (ℓ) = \frac{ℓ ^{n}}{K ^{n} + ℓ ^{n}} \cdot ℓ_{m a x}$ (Hill coefficient $n \geq 2$ ) has exactly three fixed points: a stable Off state, a stable Max state, and an unstable intermediate state. This yields a bistable switch.

Proof. The fixed-point equation $ℓ = f (ℓ)$ reduces to: $1 = \frac{ℓ ^{n - 1}}{K ^{n} + ℓ ^{n}} \cdot ℓ_{m a x}$ For $n \geq 2$ , graphical analysis shows the sigmoidal curve $f (ℓ)$ intersects the diagonal $ℓ = ℓ$ at three points when $K$ is in an appropriate range. The derivative $f^{'} (ℓ) < 1$ at the low and high intersections (stable) and $f^{'} (ℓ) > 1$ at the middle intersection (unstable). By the Banach fixed-point theorem applied to the restrictions of $f$ to neighborhoods of the stable points, these correspond to attracting fixed points—the Off and Max states of the expression level lattice. ◻

The bistable switch is the biological analog of a boolean flip-flop—a memory element that stores one bit of information.

7.2 Negative Feedback and Homeostasis

Definition 24 (Negative Feedback Loop). A negative feedback loop consists of morphisms $f : g_{1} \to g_{2}$ (activation) and $h : g_{2} \to g_{1}$ (repression), forming a cycle with net negative gain.

Theorem 25 (Homeostasis Theorem). A negative feedback loop with linear gain $- k$ ( $k > 0$ ) converges to a unique fixed point $ℓ^{*} = \frac{ℓ _{input}}{1 + k}$ , which is globally asymptotically stable.

Proof. The dynamical system is $\dot{ℓ} = ℓ_{input} - k \cdot ℓ - ℓ$ . Setting $\dot{ℓ} = 0$ gives $ℓ^{*} = ℓ_{input} / (1 + k)$ . The eigenvalue of the linearized system is $- (1 + k) < 0$ , confirming global asymptotic stability. ◻

This is the biological analog of a PID controller: the negative feedback continuously adjusts expression to maintain a set point.

Remark 26 (Connection to Domain Theory). The existence of fixed points in regulatory networks can also be established via the Knaster-Tarski theorem, since the expression level lattice $L$ is a complete lattice and regulatory functions are typically monotone or antitone. For monotone functions, the least fixed point $μ f$ and greatest fixed point $ν f$ always exist. This connects gene regulation to the denotational semantics of programming languages, where least fixed points give meaning to recursive definitions.

8 Regulatory Completeness Theorem

We now prove that the four regulatory primitives form a complete control algebra.

8.1 The Control Algebra

Definition 27 (Regulatory Control Algebra). The regulatory control algebra $A = (G, \oplus, \otimes, \neg, [\cdot])$ consists of:

$G$ : the set of gene expression states (elements of $L^{n}$ for $n$ genes),
$\oplus$ : enhancer composition (additive boosting),
$\otimes$ : promoter-mediated activation (multiplicative gating),
$\neg$ : silencer-mediated repression (complementation),
$[\cdot]$ : insulator-mediated scoping (namespace restriction).

Axiom 28 (Algebra Axioms). The operations satisfy:

$\oplus$ is commutative and associative with identity $O f f$ .
$\otimes$ is associative with identity $M a x$ (full promoter activity).
$\otimes$ distributes over $\oplus$ : $a \otimes (b \oplus c) = (a \otimes b) \oplus (a \otimes c)$ .
$\neg (\neg a) = a$ (double negation elimination for silencers).
$[a \oplus b] = [a] \oplus [b]$ when $a, b$ are in the same insulator scope.
$[a] \oplus b = b$ when $a$ is insulated from $b$ (scope isolation).

8.2 The Completeness Theorem

Theorem 29 (Regulatory Completeness). For any computable function $F : L^{n} \to L^{m}$ on expression levels, there exists a regulatory network $N$ composed solely of promoters, enhancers, silencers, and insulators such that the steady-state expression map of $N$ computes $F$ .

Proof. The proof proceeds in three steps:

Step 1: Boolean completeness. We first show that the algebra restricted to binary expression levels ${O f f, M a x}$ is functionally complete. Define: $AND (a, b) OR (a, b) NOT (a) = a \otimes b = a \oplus b = \neg a$ These satisfy the Boolean algebra axioms, and ${AND, OR, NOT}$ is a functionally complete set for Boolean functions. Therefore any Boolean function $f : {0, 1}^{n} \to {0, 1}^{m}$ can be realized.

Step 2: Graded extension. For the full lattice $L$ , we encode graded expression levels using populations of binary switches. An expression level $I n d u ce d (d)$ with $d \in [0, 1]$ is represented by a population of $N$ bistable switches, of which $⌊ d N ⌋$ are in the Max state. This encoding is faithful as $N \to \infty$ .

Step 3: Turing completeness via feedback. Feedback loops (7) provide memory (via bistable switches) and iteration (via oscillatory circuits). Combined with the Boolean gates from Step 1, this yields a system capable of simulating any Turing machine with bounded tape. Since the expression level lattice provides a finite but arbitrarily refinable state space, any computable function on $L^{n}$ can be approximated to arbitrary precision.

By construction, the network $N$ uses only promoters (for $\otimes$ ), enhancers (for $\oplus$ ), silencers (for $\neg$ ), and insulators (for $[\cdot]$ ). ◻

Corollary 30 (Regulatory Turing Completeness). The regulatory control algebra, augmented with unbounded feedback, is Turing complete.

9 Boolean Gene Circuits

We now apply the framework to construct specific gene circuits that function as digital logic elements.

9.1 The Toggle Switch

Definition 31 (Toggle Switch). A toggle switch consists of two genes $g_{1}, g_{2}$ with mutual repression: $g_{1} \neg g_{2} g_{2} \neg g_{1}$ This forms a bistable circuit with two stable states: $(g_{1} = M a x, g_{2} = O f f)$ and $(g_{1} = O f f, g_{2} = M a x)$ .

The toggle switch was first constructed synthetically by Gardner, Cantor, and Collins (2000) in E. coli and serves as a biological 1-bit memory element.

The toggle switch: mutual repression between two genes creates bistability.

The dynamics are governed by: $\frac{d [ g _{1} ]}{d t} \frac{d [ g _{2} ]}{d t} = \frac{α _{1}}{1 + [ g _{2} ] ^{n}} - δ_{1} [g_{1}] = \frac{α _{2}}{1 + [ g _{1} ] ^{n}} - δ_{2} [g_{2}]$ where $α_{i}$ are maximum production rates, $δ_{i}$ are degradation rates, and $n$ is the Hill coefficient.

9.2 The Repressilator

Definition 32 (Repressilator). A repressilator consists of three genes in a cyclic repression chain: $g_{1} \neg g_{2} \neg g_{3} \neg g_{1}$ This produces sustained oscillations in gene expression.

The repressilator, constructed by Elowitz and Leibler (2000), is the biological analog of a ring oscillator in digital electronics.

The repressilator: a three-gene ring oscillator.

Proposition 33 (Repressilator Oscillation). The repressilator with Hill coefficient $n > n_{crit}$ exhibits a stable limit cycle via Hopf bifurcation. The period of oscillation scales as $T \sim 3 τ_{d} ln (n)$ where $τ_{d}$ is the protein degradation time.

9.3 Feed-Forward Loops

Definition 34 (Feed-Forward Loop). A coherent feed-forward loop (C1-FFL) consists of: $X + Y + Z with X + Z$ where all regulatory effects are activating. The C1-FFL functions as a persistence detector: gene $Z$ is activated only when $X$ is persistently present, filtering out transient signals.

Definition 35 (Incoherent Feed-Forward Loop). An incoherent feed-forward loop (I1-FFL) has: $X + Y \neg Z with X + Z$ The I1-FFL functions as a pulse generator: gene $Z$ shows a transient pulse of expression followed by adaptation to a lower steady state.

9.4 Combinational vs. Sequential Logic

Circuit Type	Digital Analog	Biological Example
AND gate	Combinational	Dual-input promoter
OR gate	Combinational	Redundant enhancers
NOT gate	Combinational	Repressor-operator
Toggle switch	Sequential (SR latch)	$λ$ phage lysis-lysogeny
Repressilator	Sequential (ring osc.)	Circadian clock
C1-FFL	Debounce filter	Arabinose system

10 Haskell Implementation

We present a complete Haskell implementation of the framework. The implementation is organized into five modules:

Promoter.hs: Promoter types, TATA box modeling, binding affinity computation.
Enhancer.hs: Enhancer types, distance-dependent effects, the looping model.
Regulator.hs: The core Regulator a type, expression level algebra, composition.
ExpressionControl.hs: Feedback loops, GRN simulation, Boolean circuit evaluation.
Main.hs: Demonstration of promoter binding, enhancer effects, and gene circuit simulation (toggle switch, repressilator).

All code compiles with ghc -o main Main.hs and requires no external dependencies.

10.1 Core Types

The expression level lattice is implemented as an algebraic data type with a custom Ord instance respecting the lattice ordering (12).

data ExpressionLevel = Off | Basal | Induced Double | Max
  deriving (Show, Eq)

latticeJoin :: ExpressionLevel -> ExpressionLevel -> ExpressionLevel
latticeJoin Off x = x
latticeJoin x Off = x
latticeJoin Max _ = Max
latticeJoin _ Max = Max
latticeJoin Basal Basal = Basal
latticeJoin Basal (Induced d) = Induced d
latticeJoin (Induced d) Basal = Induced d
latticeJoin (Induced a) (Induced b) = Induced (max a b)

latticeMeet :: ExpressionLevel -> ExpressionLevel -> ExpressionLevel
latticeMeet Off _ = Off
latticeMeet _ Off = Off
latticeMeet Max x = x
latticeMeet x Max = x
latticeMeet Basal Basal = Basal
latticeMeet Basal (Induced _) = Basal
latticeMeet (Induced _) Basal = Basal
latticeMeet (Induced a) (Induced b) = Induced (min a b)

10.2 The Regulator Type

data Regulator a = Regulator
  { regPromoter   :: Promoter
  , regEnhancers  :: [Enhancer]
  , regSilencers  :: [Silencer]
  , regOutput     :: a -> ExpressionLevel
  }

composeRegulators :: Regulator a -> Regulator b -> Regulator (a, b)
composeRegulators r1 r2 = Regulator
  { regPromoter  = regPromoter r1
  , regEnhancers = regEnhancers r1 ++ regEnhancers r2
  , regSilencers = regSilencers r1 ++ regSilencers r2
  , regOutput    = \(a, b) ->
      latticeMeet (regOutput r1 a) (regOutput r2 b)
  }

10.3 Gene Regulatory Network Simulation

The GRN is represented as a list of genes with regulatory edges (morphisms). Simulation proceeds by iterating the update function until a fixed point is reached or a maximum number of iterations is exceeded.

data Gene = Gene
  { geneName  :: String
  , geneLevel :: Double
  } deriving (Show)

data Edge = Edge
  { edgeFrom   :: Int
  , edgeTo     :: Int
  , edgeType   :: EdgeType
  , edgeWeight :: Double
  } deriving (Show)

data EdgeType = Activation | Repression deriving (Show, Eq)

simulateGRN :: [Gene] -> [Edge] -> Int -> [Gene]
-- iterates update function to steady state

10.4 Boolean Gene Circuits

simulateToggle :: Double -> Double -> Int -> [(Double, Double)]
simulateToggle g1_init g2_init steps =
  take steps $ iterate step (g1_init, g2_init)
  where
    alpha = 5.0; n = 2.0; delta = 1.0; dt = 0.1
    step (g1, g2) =
      let g1' = g1 + dt * (alpha / (1.0 + g2**n) - delta * g1)
          g2' = g2 + dt * (alpha / (1.0 + g1**n) - delta * g2)
      in (g1', g2')

11 Discussion and Conclusion

11.1 Summary of Results

We have developed a type-theoretic framework that formalizes the regulatory sequences of eukaryotic genomes as control flow primitives in a programming language. The key results are:

Promoters as function entry points (2): Promoters determine where transcription begins and with what parameters, analogous to function entry points with calling conventions. The TATA box establishes a standardized calling convention.
Enhancers as remote configuration (3): Enhancers modify gene expression from a distance through chromatin looping, analogous to environment variables and remote configuration. The effective enhancement follows a power-law distance dependence.
Silencers as access control (4): Silencers implement permission-denial semantics, while insulators partition the regulatory landscape into independent namespaces.
The Regulator type (5): The parametric $R e g u l a t or \ensuremath ⟨ a \ensuremath ⟩$ type unifies regulatory elements with an expression level lattice $O f f ⊑ B a s a l ⊑ I n d u ce d (d) ⊑ M a x$ .
GRN categories (6): Gene regulatory networks form categories whose morphisms are regulatory effects, enabling compositional reasoning about network topology.
Feedback as fixed points (7): Positive feedback yields bistable switches; negative feedback yields homeostatic controllers. These connect to the fixed-point semantics of programming languages.
Regulatory completeness (8): The four regulatory primitives (promoter, enhancer, silencer, insulator) form a complete control algebra—any computable expression-level function can be realized by their composition.
Boolean gene circuits (9): Toggle switches, repressilators, and feed-forward loops are biological implementations of digital logic elements.

11.2 Relation to the Modular Framework

This paper establishes the second layer of the DNA-Lang modular framework. The regulatory layer composes with the coding sequence layer (Paper 1) through a clear interface: coding sequences define the functions, and regulatory sequences control when, where, and at what level those functions are invoked.

The modular composition principle predicts emergent properties at each level:

Layer 1 (coding sequences): Individual protein functions.
Layer 2 (regulatory sequences, this paper): Gene expression programs—the ability to execute different subsets of functions in different contexts.
Layers 3–7: Epigenetic memory, RNA-mediated regulation, genome architecture, chromatin structure, and developmental programs will add further layers of control.

Each layer builds upon the previous ones, and the emergent computational power of the full system exceeds the sum of its parts.

11.3 Biological Implications

The framework provides several insights for systems biology:

Regulatory mutations as type errors: Mutations in regulatory sequences can be classified as type errors in the control flow program. A mutation that destroys a TATA box is analogous to corrupting a function’s entry point; a mutation that creates a spurious enhancer binding site is analogous to an unintended environment variable binding.
Disease as control flow bugs: Many diseases, particularly cancers, arise from regulatory disruptions rather than coding mutations. Our framework provides a vocabulary for classifying these disruptions: enhancer hijacking (misrouted configuration), silencer failure (access control breach), insulator disruption (namespace leak).
Synthetic biology design: The algebraic framework provides a principled approach to designing synthetic gene circuits. The Regulatory Completeness Theorem guarantees that any desired expression program can be implemented using the four basic regulatory elements.

11.4 Limitations and Future Work

Several limitations should be noted:

The current model treats regulatory effects as deterministic, while biological gene expression is inherently stochastic. A future extension should incorporate probabilistic types.
The expression level lattice $L$ is a simplification of the continuous range of possible expression levels. A more refined model would use interval types or measure-theoretic expressions.
The categorical framework assumes that regulatory effects compose cleanly, but in practice, epistatic interactions can violate this assumption. Higher-categorical structures (2-categories) may be needed to capture these interactions.
Temporal dynamics are treated only implicitly through feedback loops. A full treatment requires temporal types or process algebra integration, which we defer to Paper 7 (developmental programs).

11.5 Conclusion

We have shown that the regulatory sequences of eukaryotic genomes—promoters, enhancers, silencers, and insulators—admit a precise formalization as control flow primitives in a type-theoretic framework. The resulting $R e g u l a t or \ensuremath ⟨ a \ensuremath ⟩$ type, equipped with an expression level lattice and composed within a categorical structure, provides both a mathematical foundation for reasoning about gene regulation and a practical framework for designing synthetic gene circuits.

The Regulatory Completeness Theorem establishes that these four primitives suffice to implement any computable expression-level function, paralleling the result in programming language theory that a small set of control flow primitives suffices for Turing completeness.

As the second paper in the DNA-Lang series, this work establishes the control flow layer that will be composed modularly with subsequent layers—epigenetic marks, non-coding RNA, repetitive elements, structural DNA, and developmental programs—to build a complete computational model of the genome.

Gardner, T.S., Cantor, C.R., and Collins, J.J. (2000). Construction of a genetic toggle switch in Escherichia coli. Nature, 403(6767):339–342.

Elowitz, M.B. and Leibler, S. (2000). A synthetic oscillatory network of transcriptional regulators. Nature, 403(6767):335–338.

Alon, U. (2007). An Introduction to Systems Biology: Design Principles of Biological Circuits. Chapman & Hall/CRC.

Ptashne, M. and Gann, A. (2002). Genes & Signals. Cold Spring Harbor Laboratory Press.

Davidson, E.H. (2006). The Regulatory Genome: Gene Regulatory Networks in Development and Evolution. Academic Press.

Barendregt, H.P. (1984). The Lambda Calculus: Its Syntax and Semantics. North-Holland.

Pierce, B.C. (2002). Types and Programming Languages. MIT Press.

Moggi, E. (1991). Notions of computation and monads. Information and Computation, 93(1):55–92.

Barr, M. and Wells, C. (1990). Category Theory for Computing Science. Prentice Hall.

Shen-Orr, S.S., Milo, R., Mangan, S., and Alon, U. (2002). Network motifs in the transcriptional regulation network of Escherichia coli. Nature Genetics, 31(1):64–68.

Levine, M. (2010). Transcriptional enhancers in animal development and evolution. Current Biology, 20(17):R754–R763.

Spitz, F. and Furlong, E.E.M. (2012). Transcription factors: from enhancer binding to developmental control. Nature Reviews Genetics, 13(9):613–626.

Ong, C.-T. and Corces, V.G. (2011). Enhancer function: new insights into the regulation of tissue-specific gene expression. Nature Reviews Genetics, 12(4):283–293.

Bell, A.C., West, A.G., and Felsenfeld, G. (2001). Insulators and boundaries: versatile regulatory elements in the eukaryotic genome. Science, 291(5503):447–450.

Tarski, A. (1955). A lattice-theoretical fixpoint theorem and its applications. Pacific Journal of Mathematics, 5(2):285–309.

Mangan, S. and Alon, U. (2003). Structure and function of the feed-forward loop network motif. Proceedings of the National Academy of Sciences, 100(21):11980–11985.

Wadler, P. (2015). Propositions as types. Communications of the ACM, 58(12):75–84.

Mac Lane, S. (1998). Categories for the Working Mathematician. Springer, 2nd edition.