1 Introduction

The genome is not merely a linear sequence of nucleotides encoding proteins. It is a three-dimensional, dynamically regulated structure whose spatial organization is integral to its function. Over the past two decades, advances in chromosome conformation capture (3C, 4C, Hi-C) and super-resolution microscopy have revealed that the genome possesses a rich hierarchical architecture: chromosomes occupy distinct territories within the nucleus, fold into compartments and topologically associating domains, and form specific long-range contacts through chromatin looping . These structural features are not epiphenomenal—they actively regulate gene expression, DNA replication, and repair.

From a computational perspective, this architecture bears a striking resemblance to the memory systems of modern computers. Just as a computer organizes memory into hierarchical levels (registers, cache, RAM, disk) with access control, segmentation, and pointer-based indirection, the genome organizes its information into territories, compartments, domains, and loops with boundary-enforced isolation, accessibility gradients, and specific long-range contacts that function as pointers. This analogy is not merely metaphorical: we argue that it can be made precise using the tools of type theory and programming language semantics.

1.1 Motivation: Beyond Sequence

Classical molecular biology adopted a largely one-dimensional view of the genome. The Central Dogma—DNA $\to$ RNA $\to$ Protein—treats the genome as a tape to be read, and regulatory elements as annotations on that tape. However, this view cannot account for several fundamental observations:

1. Enhancer-promoter specificity. Enhancers can activate promoters hundreds of kilobases away while skipping over intervening genes. The mechanism is three-dimensional looping, not linear scanning.

2. Position effects. Identical transgenes inserted at different genomic locations exhibit dramatically different expression levels, depending on the local chromatin environment and nuclear position.

3. Replication timing. The genome is replicated in a stereotyped temporal order that correlates with its spatial compartmentalization, not its linear position.

4. Aging and telomere attrition. The progressive shortening of telomeres with each cell division imposes a hard limit on replicative lifespan—a phenomenon that has no purely sequence-level explanation but is naturally captured by linear resource types.

These observations demand a framework that treats genome structure as a first-class computational concept. Programming language theory provides exactly such tools.

1.2 Type Theory as a Lens

Type theory, originally developed for the foundations of mathematics and the design of programming languages, provides a rigorous framework for reasoning about resources, access control, and composition. In particular:

• Linear types model resources that must be used exactly once, capturing the irreversible consumption of telomeric repeats during DNA replication.

• Synchronization primitives—mutexes, barriers, and semaphores—formalize the coordination required during mitosis, where the spindle assembly checkpoint ensures that all chromosomes are properly attached before anaphase proceeds.

• Memory segmentation and capability-based access control model the insulation properties of TAD boundaries, which restrict regulatory interactions to within-domain contacts.

• Pointer types with controlled dereferencing capture the semantics of chromatin loops, where a specific genomic locus (the enhancer) “points to” a distant locus (the promoter) and activates it through physical contact.

The contribution of this paper is to systematize these analogies into a coherent type-theoretic framework, prove formal properties of the resulting system, and provide an executable implementation in Haskell.

1.3 Related Work

The analogy between biological systems and computation has a long history, from von Neumann’s self-reproducing automata to Bray’s computational model of cellular signaling . More recently, Regev and Shapiro modeled biological processes using the $\pi$-calculus , and Cardelli developed process algebras for molecular biology . In the genomics domain, the ENCODE project systematically annotated functional elements , and subsequent work on 3D genome organization has revealed the structural features we formalize here.

Our work differs from these approaches in two key respects. First, we focus specifically on structural DNA elements—the architectural components of the genome rather than the coding or regulatory sequences. Second, we use type theory rather than process algebra, which allows us to reason about resource consumption, access control, and memory layout in a unified framework.

1.4 Overview

The remainder of this paper is organized as follows. 2 formalizes telomeres as linear resources. 3 models centromeres as synchronization primitives. 4 treats TADs as memory segments. 5 introduces the formal Structure type. 6 models chromatin loops as pointers. 7 maps nuclear organization onto a memory hierarchy. 8 presents our main theorems with proofs. 9 provides an executable Haskell implementation. 10 discusses implications and future directions.

2 Telomeres as Linear Resources

2.1 Biological Background

Telomeres are repetitive nucleoprotein structures at the ends of linear chromosomes, consisting of tandem repeats of the hexanucleotide sequence TTAGGG in vertebrates. In humans, telomeres are approximately 10–15 kilobases long at birth and shorten by 50–200 base pairs with each round of DNA replication, due to the end-replication problem: the lagging strand synthesis machinery cannot fully replicate the 3’ end of a linear template .

This progressive shortening imposes a hard limit on the number of times a cell can divide. When telomeres reach a critically short length, the cell enters replicative senescence—a state of irreversible growth arrest first observed by Hayflick and Moorhead . The Hayflick limit, typically 40–60 divisions for human fibroblasts, is thus directly determined by the initial telomere length and the rate of per-division attrition.

The enzyme telomerase, a reverse transcriptase that extends telomeric repeats, is active in germ cells, stem cells, and most cancer cells, but is repressed in normal somatic cells. This creates a fundamental asymmetry: most cells have a finite replicative budget, while a privileged subset can regenerate their telomeric resources.

2.2 Linear Types and Resource Consumption

In linear type theory, a value of linear type must be used exactly once: it cannot be duplicated (no contraction) and cannot be discarded (no weakening). This precisely captures the biology of telomeric repeats: each repeat is consumed exactly once per cell division, and lost repeats cannot be recovered (in the absence of telomerase).

The key observation is that division is only well-typed when $n\ge 1$, i.e., when there is at least one telomeric repeat remaining. When $n=0$, the type $Telomere(0)$ admits no further division:

This models the Hayflick limit as a type-level constraint: the type system statically prevents division beyond the replicative capacity encoded in the telomere length.

2.3 The Division Judgment

We formalize the division process as a typing judgment in a linear type system. Let $\Gamma$ be a linear context (where each variable appears at most once):

$$\frac{\Gamma ⊢t:Telomere(n+1)}{\Gamma ⊢divide(t):Telomere(n)\otimes DaughterCell}(T-Divide)$$

$$\frac{\Gamma ⊢t:Telomere(0)}{\Gamma ⊢senesce(t):SenescentCell}(T-Senesce)$$

The linear context ensures that each telomere value is used exactly once. After division, the original telomere is consumed and replaced by a shorter one; there is no way to “clone” the original telomere without violating linearity.

2.4 Telomerase as Resource Regeneration

Telomerase provides a controlled mechanism for extending telomeric repeats. In our type system, telomerase is modeled as a special operation that is only available in certain cellular contexts (germ cells, stem cells):

The capability token $TelomeraseAccess$ ensures that telomere extension cannot occur in arbitrary cells. This models the biological reality that telomerase is repressed in most somatic cells:

$$\frac{\Gamma ⊢t:Telomere(n)\Delta ⊢a:TelomeraseAccess}{\Gamma ,\Delta ⊢extend(t,a):Telomere(n+k)}(T-Extend)$$

2.5 Cancer as Type Violation

Cancer cells frequently reactivate telomerase, effectively obtaining unauthorized $TelomeraseAccess$ tokens. In our framework, this corresponds to a type violation—a breach of the capability system that allows unlimited resource regeneration:

2.6 Commutative Diagram: Telomere Lifecycle

The following commutative diagram captures the lifecycle of a telomere through successive divisions and optional regeneration:

The dashed arrow indicates that extension requires a $TelomeraseAccess$ capability and is not available in all contexts. When the diagram commutes, it expresses the fact that extension followed by division yields a telomere whose length is $(n+k-1)$, which is strictly greater than the $(n-1)$ obtained by division alone. This captures the biological advantage of telomerase-positive cells.

3 Centromeres as Synchronization Primitives

3.1 Biological Background

The centromere is a specialized chromosomal region that serves as the attachment point for the mitotic spindle during cell division. In humans, centromeres are defined by the presence of alpha-satellite (alphoid) DNA repeats and the centromere-specific histone variant CENP-A. During mitosis, the centromere recruits a large protein complex called the kinetochore, which mediates attachment to spindle microtubules.

The spindle assembly checkpoint (SAC) is a surveillance mechanism that monitors kinetochore-microtubule attachments and delays anaphase onset until all chromosomes are properly bi-oriented on the spindle. The SAC effectively acts as a barrier synchronization: the cell cannot proceed to chromosome segregation until every centromere reports proper attachment.

3.2 The Barrier Model

The $checkpoint$ operation requires that all $2n$ chromosomes have reported attachment. This is the barrier property: no thread (chromosome) can proceed past the barrier until all threads have arrived.

3.3 Mutex for Kinetochore Assembly

Each centromere must assemble exactly one kinetochore. Simultaneous assembly of multiple kinetochores on a single centromere (dicentric chromosomes) leads to catastrophic segregation errors. We model this as a mutual exclusion constraint:

3.4 The Mitotic Synchronization Protocol

Combining barriers and mutexes, the full mitotic synchronization protocol is:

1. Each centromere $i$ acquires its kinetochore mutex and assembles a kinetochore.

2. Each kinetochore attaches to a spindle fiber, producing an $Attached(i,j_i)$ token.

3. The checkpoint barrier collects all $2n$ attachment tokens.

4. Upon barrier release, an $AnaphaseLicense$ is produced, permitting chromosome segregation.

The following diagram illustrates the synchronization flow:

4 Topologically Associating Domains as Memory Segments

4.1 Biological Background

Topologically associating domains (TADs) are megabase-scale regions of the genome within which chromatin interactions are significantly enriched relative to inter-domain interactions . TADs are demarcated by boundary elements, typically occupied by the insulator protein CTCF and the cohesin complex. These boundaries function as insulators that restrict the influence of enhancers and silencers to their containing domain.

Key properties of TADs include:

• Self-association: Loci within a TAD interact with each other more frequently than with loci in adjacent TADs.

• Boundary insulation: TAD boundaries block the spread of regulatory signals. The insulation score at a boundary quantifies the reduction in cross-boundary contacts.

• Conservation: TAD boundaries are largely conserved across cell types and even across species, suggesting they are a fundamental unit of genome organization.

• Hierarchical nesting: TADs can contain sub-TADs, forming a hierarchical structure analogous to nested memory segments.

4.2 TADs as Address Space Partitions

We formalize TADs as segments of a genomic address space, where each segment has defined boundaries and access restrictions.

4.3 CTCF and Cohesin as Boundary Enforcement

The CTCF protein binds to specific DNA motifs in a strand-oriented manner. Convergently oriented CTCF sites (one forward, one reverse) form a TAD boundary by stalling the cohesin complex during loop extrusion:

This rule captures the biological observation that CTCF-mediated boundaries require convergent motif orientation. Disruption of a CTCF site (e.g., by mutation or methylation) weakens the boundary, allowing regulatory signals to leak across domains.

4.4 Insulation as Access Control

The insulation property of TAD boundaries is formalized as an access control mechanism. A regulatory element at address $x$ within TAD $T_1$ cannot access a target at address $y$ in a different TAD $T_2$ unless the intervening boundary is permeable:

4.5 Hierarchical TAD Nesting

TADs form a hierarchical structure where sub-TADs are nested within larger TADs, analogous to nested memory segments or nested scoping in programming languages:

This hierarchy directly parallels the nesting of memory segments in a process’s address space, where outer segments define coarse partitions and inner segments provide fine-grained access control.

4.6 Loop Extrusion and Segment Formation

The formation of TADs is mechanistically linked to the process of loop extrusion by cohesin. Cohesin is loaded onto chromatin and processively extrudes a loop until it encounters a boundary element (typically a CTCF site). This process partitions the genome into segments in a manner analogous to a memory allocator partitioning an address space:

This deterministic partitioning is analogous to a memory management unit (MMU) that divides physical memory into fixed segments based on hardware page boundaries. The CTCF sites serve as the “page boundaries” of the genome.

5 The Structure Type

We now unify the preceding concepts into a single parametric type that captures the full structural state of a genome.

5.1 Definition

5.2 Well-Formedness Conditions

Not every assignment of fields constitutes a valid structure. We impose well-formedness conditions that capture the biological constraints:

5.3 Morphisms of Structures

Cellular processes that alter genome structure (differentiation, mitosis, DNA damage) can be modeled as morphisms between structure types:

These morphisms compose, giving us a category $\mathbf{Struct}$ of genome structures:

6 Chromatin Loops as Pointers

6.1 Biological Background

Chromatin loops are specific long-range contacts between distant genomic loci, mediated by protein complexes such as cohesin and the Mediator complex. The most functionally significant loops connect enhancers to their target promoters, enabling distal regulatory elements to activate transcription. Hi-C and ChIA-PET experiments have mapped hundreds of thousands of such loops in the human genome .

The loop extrusion model proposes that cohesin (or condensin) is loaded onto chromatin and processively extrudes a loop until it encounters convergent CTCF sites, which stall the extrusion machinery and stabilize the loop . This produces the characteristic pattern of corner peaks in Hi-C contact maps at positions corresponding to CTCF-CTCF loop anchors.

6.2 Loops as Typed Pointers

We model a chromatin loop as a typed pointer from one genomic locus (the source, typically an enhancer) to another (the target, typically a promoter):

The type annotations enforce that loops connect compatible element types. An enhancer-promoter loop has type $ChromatinLoop(Enhancer,Promoter)$; a structural loop connecting two CTCF sites has type $ChromatinLoop(CTCF,CTCF)$.

6.3 Pointer Dereferencing as Activation

In programming, dereferencing a pointer accesses the value at the pointed-to address. In the genome, “dereferencing” a chromatin loop means that the enhancer physically contacts the promoter and activates transcription:

6.4 Cohesin as Pointer Manager

Cohesin plays a dual role: it mediates loop formation (creating pointers) and maintains loop stability (preventing dangling pointers). We formalize this as a pointer management system:

The lifecycle of a chromatin loop pointer is captured in the following diagram:

6.5 Dangling Pointers and Structural Variants

Structural variants (deletions, inversions, translocations) can disrupt chromatin loops by removing or relocating one of the anchor sites. In our framework, this creates a dangling pointer—a loop whose target no longer exists or has been moved to an incompatible location:

7 Nuclear Organization as Memory Hierarchy

7.1 Overview

The nucleus is not a homogeneous compartment. It contains functionally distinct sub-regions that differ in transcriptional activity, replication timing, and chromatin composition. We map these onto a memory hierarchy analogous to that of modern computer architectures.

7.2 Chromosome Territories as Memory Banks

Each chromosome occupies a preferred, roughly ellipsoidal region of the nucleus called a chromosome territory . Territories of different chromosomes show limited intermingling, establishing a coarse spatial partitioning of the genome.

Inter-territory communication requires explicit inter-bank transfer operations, which are less efficient than intra-territory (intra-bank) access:

$$\frac{x\in Territory(c_1)y\in Territory(c_2)c_1\ne c_2}{latency(x,y)\gg latenc{y}_{\text{intra}}}(T-InterBank)$$

7.3 A/B Compartments as Cache Hierarchy

Within chromosome territories, the genome is partitioned into A (active) and B (inactive) compartments . A compartments are gene-rich, euchromatic, early-replicating, and transcriptionally active. B compartments are gene-poor, heterochromatic, late-replicating, and transcriptionally silent.

7.4 Lamina-Associated Domains as Cold Storage

Lamina-associated domains (LADs) are genomic regions that physically contact the nuclear lamina, a meshwork of lamin proteins lining the inner nuclear membrane . LADs are predominantly heterochromatic, gene-poor, and transcriptionally repressed. They represent the most inaccessible level of the nuclear memory hierarchy.

7.5 The Complete Memory Hierarchy

Combining these levels, the nuclear memory hierarchy is:

The governing principle is that the nuclear position of a genomic locus determines its accessibility, just as the level of the memory hierarchy in a computer determines access latency. Moving a locus from the nuclear periphery to the interior (from LAD to A compartment) is analogous to loading data from disk into cache.

7.6 Radial Position and Access Latency

The radial position of a genomic locus within the nucleus correlates with its transcriptional activity. Gene-rich chromosomes tend to occupy central positions, while gene-poor chromosomes are peripheral. This radial organization creates a continuous gradient of accessibility:

This function captures the observation that loci near the nuclear periphery (large $r$) have higher access latency (lower transcriptional activity) than loci near the center (small $r$). The exponent $\gamma$ can be calibrated from experimental data relating nuclear position to gene expression levels.

8 Formal Properties

We now state and prove the three central theorems of our framework. These theorems establish that the type-theoretic model faithfully captures the essential properties of genome structural organization.

8.1 Telomere Linear Type Theorem

8.2 TAD Encapsulation Theorem

8.3 Territory Memory Protection Theorem

8.4 Additional Formal Results

9 Haskell Implementation

We provide a Haskell implementation that captures the core types and operations of our framework. The implementation uses Haskell’s type system to enforce linearity constraints (via GADTs and DataKinds) and to model the structural hierarchy.

{-# LANGUAGE GADTs, DataKinds, KindSignatures, TypeFamilies #-}

module StructuralDNA where

import Data.Kind (Type)

-- Natural numbers at the type level
data Nat = Z | S Nat

-- Telomere as a linear resource indexed by repeat count
data Telomere (n :: Nat) where
  TelomereZ :: Telomere Z
  TelomereS :: Telomere n -> Telomere (S n)

-- Division consumes one telomeric repeat
divide :: Telomere (S n) -> (Telomere n, DaughterCell)
divide (TelomereS t) = (t, DaughterCell)

-- Senescence for zero-length telomeres
senesce :: Telomere Z -> SenescentCell
senesce TelomereZ = SenescentCell

-- Telomerase extends telomeric repeats
extend :: Telomere n -> TelomeraseAccess -> Telomere (S n)
extend t _ = TelomereS t

data DaughterCell = DaughterCell deriving Show
data SenescentCell = SenescentCell deriving Show
data TelomeraseAccess = GermCell | StemCell

-- CTCF orientation
data CTCFOrientation = Forward | Reverse
  deriving (Eq, Show)

-- Boundary with insulation score
data Boundary = Boundary
  { ctcfOrientation :: CTCFOrientation
  , cohesinLoaded   :: Bool
  , insulationScore :: Double  -- in [0,1]
  } deriving Show

-- TAD as a memory segment with boundaries
data TAD = TAD
  { tadStart    :: Int
  , tadEnd      :: Int
  , leftBound   :: Boundary
  , rightBound  :: Boundary
  } deriving Show

-- Check well-formedness: convergent CTCF
isWellFormed :: TAD -> Bool
isWellFormed tad =
  ctcfOrientation (leftBound tad) == Forward &&
  ctcfOrientation (rightBound tad) == Reverse

-- Access control between loci in different TADs
accessPermission :: [Boundary] -> Double
accessPermission = product . map (\b -> 1.0 - insulationScore b)

-- Check if access is granted
canAccess :: [Boundary] -> Double -> Bool
canAccess boundaries threshold =
  accessPermission boundaries > threshold

-- Locus types at the value level
data LocusType = Enhancer | Promoter | CTCFSite | Other
  deriving (Eq, Show)

-- Genomic locus
data GenomicLocus = GenomicLocus
  { chromosome :: Int
  , position   :: Int
  , locusType  :: LocusType
  } deriving Show

-- Chromatin loop as a pointer between loci
data ChromatinLoop = ChromatinLoop
  { anchorSource :: GenomicLocus
  , anchorTarget :: GenomicLocus
  , loopStrength :: Double
  } deriving Show

-- Dereference: enhancer-promoter activation
data TranscriptionEvent = TranscriptionEvent
  { targetGene :: GenomicLocus
  , txnLevel   :: Double
  } deriving Show

deref :: ChromatinLoop -> Double -> Maybe TranscriptionEvent
deref loop accessThreshold
  | locusType (anchorSource loop) == Enhancer
  , locusType (anchorTarget loop) == Promoter
  , loopStrength loop > accessThreshold
  = Just (TranscriptionEvent (anchorTarget loop)
                             (loopStrength loop))
  | otherwise = Nothing

-- Compartment assignment
data Compartment = CompartmentA | CompartmentB
  deriving (Eq, Show)

-- Memory hierarchy levels
data MemoryLevel
  = Register       -- transcription factory
  | L1Cache        -- A compartment, euchromatin
  | MainMemory     -- B compartment, heterochromatin
  | ColdStorage    -- lamina-associated domain
  deriving (Eq, Ord, Show)

-- Territory as a memory bank
data Territory = Territory
  { territoryChrom  :: Int
  , nuclearPosition :: (Double, Double, Double)
  , territoryVolume :: Double
  } deriving Show

-- Access latency computation
accessLatency :: MemoryLevel -> MemoryLevel -> Double
accessLatency src dst = abs (cost dst - cost src)
  where
    cost Register    = 1.0
    cost L1Cache     = 5.0
    cost MainMemory  = 20.0
    cost ColdStorage = 100.0

-- The full Structure type
data Structure = Structure
  { structTADs          :: [TAD]
  , structLoops         :: [ChromatinLoop]
  , structTerritories   :: [Territory]
  , structCompartments  :: GenomicLocus -> Compartment
  , structAccessibility :: GenomicLocus -> Double
  }

10 Discussion and Conclusion

10.1 Summary of Contributions

We have presented a type-theoretic framework that formalizes the structural elements of the genome as components of a memory architecture. The key mappings are:

• Telomeres $⟷$ Linear resources: The progressive shortening of telomeres with each cell division is captured by a linear type system where each division consumes one unit of a finite resource. The Hayflick limit emerges as a type-level constraint.

• Centromeres $⟷$ Synchronization primitives: The spindle assembly checkpoint is a barrier that requires all chromosomes to report attachment before anaphase proceeds. Kinetochore singularity is enforced by mutual exclusion.

• TADs $⟷$ Memory segments: TAD boundaries enforced by convergent CTCF and cohesin provide insulation analogous to memory segment protection, with quantitative insulation scores governing cross-boundary access.

• Chromatin loops $⟷$ Typed pointers: Enhancer-promoter loops are pointers that, when dereferenced, activate transcription. Cohesin manages the pointer lifecycle through extrusion, stalling, and release.

• Nuclear organization $⟷$ Memory hierarchy: Chromosome territories, A/B compartments, and LADs map onto a multi-level memory hierarchy with increasing access latency.

10.2 Biological Implications

The framework provides a unified computational lens for understanding several biological phenomena:

1. Aging: Telomere attrition is resource exhaustion. The Hayflick limit is a compile-time (type-level) guarantee that replicative capacity is finite.

2. Cancer: Telomerase reactivation is a capability violation; TAD boundary disruption creates dangling pointers and ectopic enhancer-promoter contacts. Both are “type errors” in the genome’s structural program.

3. Development: Cell differentiation involves large-scale reorganization of the memory hierarchy—compartment switching, LAD repositioning, and loop rewiring—corresponding to a complete memory remapping.

4. Structural variants: Deletions, inversions, and translocations that disrupt TAD boundaries or loop anchors are pointer corruption events with predictable pathological consequences.

10.3 Connections to Programming Language Design

Our framework suggests that programming language design can draw inspiration from genome organization. The genome’s use of linear types for resource management, barriers for synchronization, segments for isolation, and pointers for long-range communication represents a system that has been refined by billions of years of evolution. Specific insights include:

• Bounded linear types: The telomere model suggests that parameterizing linear types by a resource count enables fine-grained tracking of resource lifetimes, going beyond the binary used/unused distinction of standard linear types.

• Insulation scores: The quantitative insulation model for TAD boundaries suggests that access control need not be binary; graded permissions parameterized by a real-valued score could model partial isolation in concurrent systems.

• Hierarchical memory: The nuclear memory hierarchy suggests that programming languages could benefit from explicit memory hierarchy annotations, allowing programmers to reason about data placement and access patterns.

10.4 Limitations and Future Work

Several aspects of genome structure are not yet captured by our framework:

• Dynamics: Our model is largely static; a process-algebraic extension could capture the dynamic aspects of loop extrusion and compartment switching.

• Stochasticity: Genome organization is inherently stochastic at the single-cell level. Incorporating probabilistic types or measure-theoretic semantics is a natural extension.

• Phase separation: Recent work suggests that many nuclear compartments are formed by liquid-liquid phase separation, which introduces a physical mechanism not yet captured by our type-theoretic model.

• Replication: The interplay between replication timing and the memory hierarchy deserves formal treatment.

• Epigenetic marks: Histone modifications and DNA methylation affect chromatin accessibility and should be integrated as annotations on the memory hierarchy.

10.5 Conclusion

By treating structural DNA elements as components of a memory architecture, we gain a precise, formal language for reasoning about genome organization. The type-theoretic framework enables us to state and prove properties—resource soundness for telomeres, encapsulation for TADs, protection for territories—that have direct biological interpretations. The Haskell implementation demonstrates that these formal constructs yield executable specifications, bridging the gap between mathematical biology and computational practice.

The genome is not just a program; it is an entire computing system, complete with memory management, access control, synchronization, and hierarchical storage. Understanding its architecture through the lens of programming language theory opens new avenues for both computational biology and programming language design.

Acknowledgments

The author thanks the members of the YonedaAI Collaboration for valuable discussions on category theory, type theory, and their applications to biological systems.