Polycomputing: Multiplexed Substrates

• Polycomputing is the concept where a single substrate performs multiple computations concurrently by leveraging variations in frequency, spatial arrangement, or scale.
• It spans applications from biological systems and granular metamaterials to plant-based processors, challenging traditional one-function-per-component models.
• This approach integrates physical, chemical, and biological modalities to create adaptable, multifunctional computing architectures that transcend classical digital limits.

Searching arXiv for recent and foundational papers on polycomputing and related formulations. Polycomputing denotes a family of ideas in which one physical or formal substrate supports more than one computation, often in the same place and at the same time. In one influential formulation, it is “the ability of the same substrate to simultaneously compute different things,” refined operationally as “the ability of a material to provide the results of more than one computation in the same place at the same time,” provided those results are usable by other parts of the system or by external devices (Bongard et al., 2022). In materials-oriented work, the same idea appears as simultaneous logical behavior multiplexed by frequency, so that one grain or one region of matter can report multiple logical operations without changing substrate (Parsa et al., 2023). Related literatures broaden the theme to coupled heterogeneous devices, collective-state computation, supra-binary branching, and continuous-time analog formalisms, all of which treat computation as distributed across multiple interacting structures rather than localized in a single, uniform machine (Stepney et al., 2012, Zirkind, 2016, Traversa et al., 2014, Bournez et al., 2016).

1. Definitions and conceptual scope

Polycomputing is not identified in the cited literature with mere complexity or incidental multifunctionality. The biological formulation insists on two additional conditions: the substrate must be capable of being used to produce particular results, and those results must be readable or usable by other parts of the system or by external devices (Bongard et al., 2022). This excludes arbitrary physical side effects and distinguishes polycomputing from the weaker claim that one material simply exhibits many correlated phenomena.

The same literature rejects a narrow equation between computation and sequential, deterministic, digital, silicon-based, von Neumann/Turing-style execution. Instead, it places polycomputing alongside massively parallel systems, stochastic systems, physical reservoir computing, computational metamaterials, evolutionary/design-generated hardware, and organic and hybrid substrates (Bongard et al., 2022). A closely related mechanical formulation defines polycomputing as multiple computations in the same place, same substrate, and same time, separated by vibration frequency rather than by separate circuit instances (Parsa et al., 2023).

Across these uses, polycomputing names a shift from one privileged function per component to overloaded or multiplexed computational structure. In some papers, the emphasis falls on simultaneous interpretation of one substrate; in others, on interaction among heterogeneous components whose combined behavior exceeds that of the parts. This suggests that polycomputing is best understood as a general regime of computational overloading, multiplexing, or composition rather than a single fixed model (Stepney et al., 2012).

2. Biological polycomputing and overloaded substrates

The biological literature treats polycomputing as a consequence of evolutionarily reused, multiscale hardware. Living systems are described as nested layers of competence—molecules, cells, tissues, organs, organisms, swarms—within a “multiscale competency architecture,” where each level solves problems at its own scale while constraining and supporting other levels (Bongard et al., 2022). The same ion channels can support homeostasis, development, regeneration, and behavior; the same gene network can participate in several patterning tasks; and the same tissue can be both a structural substrate and an information-processing substrate (Bongard et al., 2022).

Representative examples include spider webs functioning as both prey-capture devices and auditory sensors; mitochondria in cone photoreceptors acting as microlenses; proteins with multiple conformationally dependent functions; overlapping genes and multiple reading frames in DNA; ion channels that also act as transcription factors; and bioelectric networks that simultaneously regulate physiological state and control morphogenesis, regeneration, and cancer suppression (Bongard et al., 2022). Planarian and axolotl systems, as summarized in the same source, further exemplify reuse of bioelectric and signaling machinery across behavior and body patterning, while Xenobots show context-dependent redeployment of standard frog cells into normal embryos or novel self-motile, self-replicating living machines (Bongard et al., 2022).

A distinctive feature of this account is observer dependence. Whether a system is usefully described as computing is treated not as an objective yes/no property but as a function of the observer’s explanatory and control framework. The criterion proposed is pragmatic: a system is a computer to the degree that adopting a computational model helps an observer predict and control it better than alternatives (Bongard et al., 2022). In this setting, polycomputing becomes partly a matter of multiple valid computational descriptions extracted from the same substrate.

The paper also connects polycomputing to causal emergence. In the cited example, micro-level effective information is $EI(S_m)=2.43$ bits with effectiveness $Eff(S_m)=0.4$, whereas the macro-level description yields $EI(S_M)=3$ bits (Bongard et al., 2022). The claim is not merely that higher scale is simpler, but that the same system can be simultaneously interpretable as different machines at different scales. A common misconception is therefore that polycomputing requires one mechanism to execute several explicit programs in the conventional sense; the biological account instead allows simultaneous computations to arise from distinct observer-relative, scale-relative, and function-relative readings of one evolving material substrate (Bongard et al., 2022).

3. Material realizations and physical multiplexing

Several unconventional-computing platforms instantiate polycomputing materially rather than metaphorically.

Substrate	Simultaneous computations	Distinguishing mechanism
Granular matter	Two NAND functions in one material	Different vibration frequencies
Plant roots and tissues	Morphological, collision-based, analog, memristive functions	Growth topology, coatings, nanoparticles, conductive polymers
Granular metamaterials and reservoirs	Multiple Boolean operations or different computations from one substrate	Physical stimulation and readout regime

In granular matter, vibration is the information-bearing mode, and the central result is the evolution of a material in which one grain acts simultaneously as two different NAND gates at two different frequencies (Parsa et al., 2023). The reported system is a $5 \times 6$ triangular lattice of circular particles, hence 30 particles, with two input ports, one output port, and one power source. Bits are represented by vibration amplitudes, and logical behavior is scored through frequency-domain gain,

$$G_{ij}(\omega)=\frac{\hat f(O_{ij})}{\hat f(\mathrm{in}_i)+\hat f(\mathrm{in}_j)} ,$$

with NAND fitness minimized by

$$F=\max(|1-G_{00}(\omega)|,\ |1-G_{01}(\omega)|,\ |1-G_{10}(\omega)|,\ |0-G_{11}(\omega)|).$$

The polycomputing result is that one evolved granular material behaves as a NAND gate at both $10$ Hz and $20$ Hz, with computation distributed across the material rather than confined to a single chosen output site; the functionality remains intact so long as signal-to-noise ratio stays above about $-20$ dB (Parsa et al., 2023).

Plant-based computing realizes a different form of polycomputing. “Morphological plant processors” represent data by initial root configurations and sources of attractants and repellents, while computation is performed by roots following gradients and interacting with each other; output is the topology of the root network (Adamatzky et al., 2017). In the same biological substrate, electrical properties can be modified by loading plants with functional nanoparticles or coating parts of plants with conductive polymers, yielding living variable resistors, capacitors, operational amplifiers, multipliers, potentiometers, fixed-function generators, memristors, transistors, and logic gates (Adamatzky et al., 2017). The paper explicitly states that electrically modified plants can implement summation, integration with respect to time, inversion, multiplication, exponentiation, logarithm, and division, and gives a summing-amplifier equation

$$v_0=-\left(\frac{R_0}{R_1}v_1+\frac{R_0}{R_2}v_2\right),$$

with one concrete parameterization yielding $Eff(S_m)=0.4$0 (Adamatzky et al., 2017).

These material systems clarify a central point: polycomputing is not identical with traditional parallelism. Frequency multiplexing in granular matter, topology-based encoding in roots, and electrical rematerialization in coated plants all use the same physical region to support multiple computational abstractions. This suggests that the operative distinction is not simply “many operations at once,” but multiple usable computations realized in one substrate under different encodings, probes, or dynamical regimes (Parsa et al., 2023, Adamatzky et al., 2017).

4. Collective, spatial, and massively distributed media

Polycomputing also appears in media whose computational power emerges from local interaction among many simple components. In self-organizing particle systems, each particle has only constant-size local memory and communicates only with adjacent particles, yet the swarm collectively implements a binary counter, matrix-vector multiplication, matrix-matrix multiplication, image color transformation, and edge detection (Porter et al., 2017). The counter reaches value $Eff(S_m)=0.4$1 in $Eff(S_m)=0.4$2 asynchronous rounds, while matrix-vector multiplication takes $Eff(S_m)=0.4$3 asynchronous rounds after setup, and matrix-matrix multiplication takes $Eff(S_m)=0.4$4 (Porter et al., 2017). The computational gain comes from turning geometry into distributed memory and transport structure.

A related spatial-language approach programs homogeneous media composed of millions of identical processing elements communicating locally by using “spatial types” over vertices, edges, and faces of a maximal planar graph (Gruau, 2019). Boolean and integer fields are spread across these loci, and computation is expressed through simplicial reductions such as $Eff(S_m)=0.4$5, $Eff(S_m)=0.4$6, and $Eff(S_m)=0.4$7. The framework computes, for example,

$Eff(S_m)=0.4$8

and claims that fields of radius $Eff(S_m)=0.4$9 can be computed in $EI(S_M)=3$0 time in the spatial-types framework, whereas a cellular-automaton translation can become $EI(S_M)=3$1 (Gruau, 2019). Its Voronoï example states that strict Voronoï cells are filled using 55 gates and radius 4 (Gruau, 2019).

Polycomputing-style decomposition also appears in high-precision arithmetic. In multiword arithmetic, a multiple double is an unevaluated sum of 64-bit doubles and a multiple integer is an unevaluated sum of 64-bit integers; higher precision is then offset by parallel computing (Verschelde, 18 Jun 2026). The inner-product decomposition

$EI(S_M)=3$2

rewrites one high-precision operation as many smaller mostly independent computations in ordinary double arithmetic, followed by a structured recombination (Verschelde, 18 Jun 2026). The cited measurements report that 1,024 inner products in hexa-double precision took about 9 seconds on one thread, but about 293 milliseconds on a two-socket machine using 96 threads (Verschelde, 18 Jun 2026).

The Physarum literature provides a still more radical version in which the substrate’s own morphodynamics constitute part of the computational structure. The plasmodium’s branching, fusion, competition, and protoplasmic-tube formation are formalized by a process calculus whose operators include inaction, choice, cooperation, hiding, and fusion, with rules such as

$EI(S_M)=3$3

and transition equations governing synchronization and annihilation (Schumann et al., 2011). Here, the structural part of computation is not merely implemented in the substrate; it is continuously reorganized by the substrate.

5. Heterogeneous composition and formal abstractions

A more abstract line of work treats polycomputing as composition of heterogeneous systems rather than multiplexing inside one material. In heterotic computing, the central claim is that computational power derives from the interaction of two or more different computational systems, with the interaction itself explicitly modeled (Stepney et al., 2012). If systems $EI(S_M)=3$4 and $EI(S_M)=3$5 are represented in categories $EI(S_M)=3$6 and $EI(S_M)=3$7, the proposed structure uses maps

$EI(S_M)=3$8

forming an adjoint pair,

$EI(S_M)=3$9

This is intended to capture mutual update between unlike systems without collapsing them into one homogeneous model (Stepney et al., 2012).

The computation-environment framework separates syntax from semantics by defining a universal processor

$5 \times 6$0

and a computation environment

$5 \times 6$1

where $5 \times 6$2 is the computist interacting with the processor (Ramezanian, 2012). This yields plural computational semantics for the same machine syntax. The paper constructs both a Turing computation environment $5 \times 6$3, where $5 \times 6$4 and $5 \times 6$5, and a persistently evolutionary environment $5 \times 6$6, where $5 \times 6$7 and the behavior of the processor can evolve interactively while remaining persistent on prior inputs (Ramezanian, 2012). This is not polycomputing in the “same substrate, same time” sense, but it is computational pluralism in a strong semantic sense.

The computon model shifts attention to “computation in the large.” A computon is a 13-tuple,

$5 \times 6$8

with explicit separation of data and control, ports, units, devices, and interface structure (Arellanes, 16 Feb 2026). Composition is defined via finite colimits, especially coproducts and pushouts, yielding sequential, parallel, branching, and iterative devices. Open branching $5 \times 6$9, closed branching $$G_{ij}(\omega)=\frac{\hat f(O_{ij})}{\hat f(\mathrm{in}_i)+\hat f(\mathrm{in}_j)} ,$$0, and synchronous parallelism

$$G_{ij}(\omega)=\frac{\hat f(O_{ij})}{\hat f(\mathrm{in}_i)+\hat f(\mathrm{in}_j)} ,$$1

are treated as categorical constructions rather than ad hoc control operators (Arellanes, 16 Feb 2026). This gives polycomputing a formal assembly discipline in which interacting devices are structurally correct by construction.

At the programming-language level, polymonads generalize monadic sequencing from

$$G_{ij}(\omega)=\frac{\hat f(O_{ij})}{\hat f(\mathrm{in}_i)+\hat f(\mathrm{in}_j)} ,$$2

to

$$G_{ij}(\omega)=\frac{\hat f(O_{ij})}{\hat f(\mathrm{in}_i)+\hat f(\mathrm{in}_j)} ,$$3

allowing composition of computations with three different kinds of effects (Hicks et al., 2014). The associated coherence result states that no matter which type-correct binds are chosen, the elaborated program’s semantics is the same (Hicks et al., 2014). A plausible implication is that software-level polycomputing can be formalized as disciplined composition across multiple effect domains, not only as heterogeneous hardware or material embodiment.

6. Complexity claims, resource trade-offs, and limitations

The complexity-theoretic literature around polycomputing is heterogeneous and sometimes controversial. Memcomputing is presented as a non-Turing paradigm using interacting memory cells, or memprocessors, to store and process information on the same physical platform (Traversa et al., 2014). The paper claims that universal memcomputing machines have the same computational power as non-deterministic Turing machines and therefore can solve NP-complete problems in polynomial time using polynomial resources, with intrinsic parallelism and information overhead arising from collective states (Traversa et al., 2014). For subset sum, the collective state is

$$G_{ij}(\omega)=\frac{\hat f(O_{ij})}{\hat f(\mathrm{in}_i)+\hat f(\mathrm{in}_j)} ,$$4

whose harmonic amplitudes encode subset sums. The same paper is explicit that these results do not answer the $$G_{ij}(\omega)=\frac{\hat f(O_{ij})}{\hat f(\mathrm{in}_i)+\hat f(\mathrm{in}_j)} ,$$5 question, because the comparison is not within the Turing-machine paradigm, and that the fabricated prototype is limited by noise and would require error-correcting codes to scale (Traversa et al., 2014).

A different complexity analysis studies deterministic, error-free physical computation systems. In that framework, a computation system is $$G_{ij}(\omega)=\frac{\hat f(O_{ij})}{\hat f(\mathrm{in}_i)+\hat f(\mathrm{in}_j)} ,$$6, and the class of polynomial-time classical physical computation systems satisfies

$$G_{ij}(\omega)=\frac{\hat f(O_{ij})}{\hat f(\mathrm{in}_i)+\hat f(\mathrm{in}_j)} ,$$7

With input-dependent measurement times, timed classical physical computation systems still yield

$$G_{ij}(\omega)=\frac{\hat f(O_{ij})}{\hat f(\mathrm{in}_i)+\hat f(\mathrm{in}_j)} ,$$8

whereas algebraically acting timed systems satisfy

$$G_{ij}(\omega)=\frac{\hat f(O_{ij})}{\hat f(\mathrm{in}_i)+\hat f(\mathrm{in}_j)} ,$$9

(Whyman, 2016). The central interpretation is that physical state functions as nonuniform advice, and that algebraicity plus measurement-time constraints restrict how many hidden bits are extractable in polynomial time (Whyman, 2016).

Continuous-time analog computation offers yet another route. For polynomial ordinary differential equations and GPAC-style systems, the paper argues that natural variants of computability and complexity all coincide, with polynomially bounded length-computability equal to polynomial time-space computability:

$$F=\max(|1-G_{00}(\omega)|,\ |1-G_{01}(\omega)|,\ |1-G_{10}(\omega)|,\ |0-G_{11}(\omega)|).$$0

It further treats polynomial ODEs as a programming model robust under weak, robust, strong, extreme, and online formulations of computation (Bournez et al., 2016). This situates polycomputing within continuous dynamics rather than discrete multiplexing.

Architectural proposals beyond binary logic pursue polycomputing by introducing native multi-input, multi-output switching primitives. Supra-binary computing proposes multi-gated AND/OR, a software construct mswitch, and machine-level opcodes such as Op-Reset, Op-Turn-On, Op-Turn-Off, and Op-Activate, with the claim that multi-switching would make parallel processing built in rather than layered on top of binary semantics (Zirkind, 2016). The proposal is explicitly theoretical and notes unresolved issues of hardware feasibility, physical size, and address management (Zirkind, 2016).

Taken together, these works show that polycomputing is not a single settled thesis. In some literatures it is an experimentally supported material phenomenon, as in granular matter or plant electronics; in others it is a conceptual lens for biological overloading, a categorical theory of interacting devices, or a claim about alternative complexity resources. Common misconceptions are therefore twofold: first, that polycomputing is simply another name for parallelism; second, that all polycomputing claims make the same complexity-theoretic commitment. The cited work instead supports a more precise view: polycomputing concerns the simultaneous, overloaded, or compositional realization of multiple computations, while the meaning of “multiple,” the relevant substrate, and the admissible resource model vary substantially across the field (Bongard et al., 2022, Parsa et al., 2023, Stepney et al., 2012, Traversa et al., 2014).