Physical Computing: Formal Frameworks & Applications

Updated 1 August 2025

Physical computing is a rigorously formalized field that bridges abstract algorithms with real-world device dynamics through explicit encoding and decoding.
The framework employs systematic representation relations and commutative diagrams to ensure that physical evolutions closely match abstract computations within specified error tolerances.
Applications span digital electronics, quantum systems, and unconventional substrates, requiring explicit mapping protocols and active computational entities for validation.

Physical computing is a rigorously formalized field concerned with the use of physical systems to instantiate and drive abstract computational processes. In contemporary research, the subject is characterized by a mathematically precise account of how abstract computational tasks are mapped onto, and solved by, the physical evolution of varied substrates—including digital electronics, quantum systems, biological media, and engineered analog or hybrid devices. It relies on systematic frameworks that explicitly connect the computational (abstract, mathematical) and physical (device, dynamical) levels via well‐defined representation relations, and it is situated in critical contrast to notions such as pancomputationalism by specifying necessary and sufficient conditions under which a physical process counts as computation.

1. Formal Framework for Physical Computation

The most prominent formalism in physical computing is centered on two interacting levels: the abstract computational level and the physical device level (Horsman et al., 2013). This framework identifies the following structural components:

A representation relation $R_T$ encodes the mapping from a physical state $p$ to its abstract model $m_p$ within a physical theory $T$ . This may be inverted for encoding, often denoted $\$\$, allowing for the embedding of abstract data into a physical substrate.
The abstract evolution is governed by a function $C_T$ so that $m'_p = C_T(m_p)$ .
The physical evolution is determined by the device's natural dynamics $\mathcal{H}(p)$ , leading to a new physical state $p'$ .
To ascertain consistency, the physical output is again mapped to the abstract level, yielding $m_{p'}$ .

The commutativity (or near-commutativity) of these mappings is the key diagnostic: a robust physical computer must satisfy $m'_p \equiv m_{p'}$ or $|m'_p - m_{p'}| < \epsilon$ for tolerance $\epsilon$ , ensuring that the predicted abstract computation aligns with the physical process. In computational usage, this cycle is typically inverted: an abstract input is encoded, the device evolves, and the output is decoded and interpreted.

This structure is closely paralleled by later refinements using Abstraction/Representation (AR) theory, which regards the representation relation as non‐logical, mediating between objects in the physical domain $P$ and the abstract domain $M$ (Horsman, 2015). Commuting diagrams are systematically used to guarantee that device evolution and abstract computation correspond up to a specified error.

2. Abstract and Physical Levels: Mapping and Dynamics

Physical computing is defined through the interaction of the abstract and physical layers:

Abstract Level	Physical Level
Algorithm, model state $m_p$	Device state $p$
Abstract operations $C_T$	Device dynamics $\mathcal{H}(p)$
Encode/decode via $R_T$ or $\$\$	Hardware, physical operations

A typical computational process involves encoding an abstract problem in a physical substrate (e.g., voltages as bits), allowing the device to evolve under its physical laws (e.g., logic gates, quantum gates, dissipative dynamics), and then decoding the final state to obtain an abstract answer. This representation acts as a theoretical bridge and must be specified a priori rather than post hoc to avoid assigning computational meaning where none exists.

The commutative diagram formalizes this: starting from $m_p$ , encode to $p$ , evolve to $p'$ , decode to $m_{p'}$ , and check agreement with $C_T(m_p)$ . These relationships persist in both digital and non-standard substrates.

3. Necessary and Sufficient Conditions for Computation

Under the formalism, a physical system is deemed to compute only if all the following hold (Horsman et al., 2013, Horsman, 2015):

Well‐Tested Physical Theory $T$ : The underlying device must be described by a tested physical theory that supplies both the representation map $R_T$ and the abstract dynamics $C_T$ .
Explicit Encoding and Decoding: There exists a clear procedure for mapping abstract data into the physical system and extracting results.
Implemented Fundamental Operation: At least one reliable and reproducible physical operation or transformation must be in place corresponding to a step in the abstract computation.
Commutativity of Diagrams: The complete encode–compute–decode cycle must commute (modulo tolerance $\epsilon$ ), ensuring that physical evolution and abstract computation align.

A crucial consequence is that post hoc mappings, where input/output correspondence is defined only after seeing physical behavior, do not qualify a system as computational according to this framework.

4. Non-Standard, Unconventional, and Hybrid Computing Scenarios

The framework recognizes a broad class of physical computers beyond conventional digital hardware:

Quantum Systems: Quantum computers are included when their physical evolution realizes a specified abstract quantum computation; however, demonstration of commuting diagrams and representation verification (especially in devices like D-Wave) is challenging due to scaling, noise, and model uncertainties (Horsman et al., 2013).
Biological and Chemical Substrates: Systems such as protein folding machines or slime moulds are only genuinely computing if encoding and decoding schemes are established and embedded in a predictive theory $T$ —otherwise, they remain experimental systems or natural phenomena.
Repurposed Devices: Unconventional substrates (e.g., evolved Liquid Crystal Displays, synthetic active particles, origami-based soft robotics) require the a priori engineering of the encode/decode relationship to satisfy formal criteria (Wang et al., 2023, Bhovad et al., 2021).
Hybrid/Heterotic Systems: AR theory distinguishes heterotic systems—where device combination at the representation level unlocks new computational power—from mere hybrid systems, where joint computation is only at the composition of the abstract outputs (Horsman, 2015).

A key diagnostic is the avoidance of pancomputationalism: not every physical event is computational; only those with a formally mapped, reproducible abstract-physical relationship are.

5. The Role of Computational Entities

A computational entity is any agent, biological or artificial, that enacts and interprets the encode/decode processes without which physical evolution does not amount to computation (Horsman et al., 2013). Entity existence is an objective, not subjective, criterion: it may be instantiated by humans, machine interfaces, automated protocols, or even distributed software agents, so long as they reliably provide the mechanisms to establish, use, and interpret the representation relation.

Analogous to the sender/receiver roles in information theory, the computational entity is responsible for:

Embedding abstract data in a physical state,
Retrieving final physical states and mapping them back into the desired abstract output,
Ensuring that computation is not a physical process alone but a purposefully mediated use of the physical world for abstract prediction or solution.

6. Implications and Generalizations

The generality of the framework has several significant consequences:

Broad Applicability: The formalism encompasses not only conventional computation but also machine-to-machine, non-human, and automated scenarios, applicable to systems as diverse as cloud robotics, programmable matter, and simulation-based self-driving laboratories (Peterson et al., 2022).
Clarity in Classification: By specifying the conditions above, the field avoids classifying all physical change as computation (pancomputationalism), restricting the term to instances with established representation, operational reliability, and entity-mediated cycles.
Scientific Experimentation Analogy: The encode–evolve–decode chain and the commutativity condition are the computational analog of experimental prediction and verification processes, aligning the methodology with rigorous scientific practice.
Integration with Formal Verification: The abstraction/representation framework connects directly with established methods of stepwise system refinement and verification, enabling the formal integration of physical devices and their computational correctness (Horsman, 2015).
Extension to Higher-Order Compositions: Recent category-theoretic extensions articulate physical computing via functorial maps between categories of physical processes and abstract computations, capturing the compositional and relational structure of complex or non-standard systems (Dehghani et al., 2022).

7. Open Issues and Future Directions

Several unresolved issues and avenues for research remain:

Scaling and Robustness: How well do the encode/decode relations and the commutative property scale as physical systems become large, noisy, or hybridized?
Autonomous and Evolutionary Computing Entities: Can computational entities themselves be engineered or evolved within entirely automated settings (e.g., AI-managed laboratory platforms (Peterson et al., 2022))?
Dynamic and Hierarchical Systems: What are the most rigorous approaches to addressing dynamic interactions in systems that operate across scales or as distributed, dynamically configured networks (e.g., networked physical computing enabled by hypergraph matching (Zhu et al., 31 Jul 2025))?
Boundary between Computation and Experimentation: The field continues to interrogate the boundary between using physical systems for computational versus purely experimental or phenomenological purposes, particularly in edge cases with unconventional substrates.

Physical computing, as currently conceptualized, is an umbrella for diverse approaches unified by rigorous logical, mathematical, and physical grounding—a field where the predictive power of physics is directly mobilized to instantiate, accelerate, and diversify abstract computation.