Software Models as a Method of Theory Formalization

If a physical theory lacks mathematical formalization, it is considered incomplete—and, more importantly, unverified—within the physics community. This is because if a mathematical model contains no contradictions or errors and describes a theory comprehensively and in detail, this serves as a crucial indicator that the theory is not merely fantasy or philosophical speculation, but a legitimate candidate for describing physical reality. Mathematical formalization indeed plays the role of "oxygen" in modern physics, without which a theory cannot be considered complete.

When a physicist states that a theory is "not formalized," this is equivalent to claiming that it has not been translated into a language that allows unambiguous correspondence between abstract ideas and measurable quantities. As Eugene Wigner noted in his essay "The Unreasonable Effectiveness of Mathematics in the Natural Sciences," mathematical language possesses excessive predictive power. If a theory's structure fits into a consistent mathematical formalism (for example, Riemannian geometry for General Relativity or group theory for the Standard Model), this indicates that the theory describes not arbitrary fantasy, but a structured reality subject to strict logical constraints.

Mathematical consistency does not guarantee physical truth, but it is a necessary component of the theory verification process.

However, mathematics is not always the optimal method of formalization. For instance, it would be highly unusual to attempt to construct a complete mathematical model of a television set; only its individual components—resistors, transistors, capacitors—represent aspects of physical reality that are well-suited to mathematical formalization. The claim that any theory must have a mathematical model is an exaggeration and a myth. Even in cases such as the "three-body problem," mathematics begins to show its limitations, whereas software modeling through emulation of physical reality under specified boundary conditions allows one to easily and accurately obtain distant consequences of states of several physical phenomena, recalculating each state step by step based on the previous one.

At the level of the television as a whole, we deal with a system whose behavior is not analytically derivable from quantum mechanical equations, yet remains strictly deterministic. Demanding a "unified mathematical model" for a television in the form of a single differential equation would be not merely strange, but meaningless.

Program code is a formal system no less than a set of integrals. Moreover, an algorithm is often more rigorous than analytical mathematics because it demands complete definiteness: in mathematical analysis, we may "sweep under the rug" questions of series convergence or solution singularities, leaving them as "obvious." In code, however, ambiguity leads to a runtime error.

Formalization is not synonymous with a mathematical "formula." Formalization is broader than analytical mathematics.

There is terminological confusion between analytical mathematics and computational mathematics. Software modeling is also mathematics. Computer simulation is a mathematical model—simply implemented via numerical methods and expressed in a different formal language of representation.

The modern definition of formalization in physics includes:

1. Analytical mathematics (differential equations, Lie groups) — the classical approach.
2. Computational algorithms (numerical solutions, simulations) — the modern standard.
3. Axiomatic systems (quantum mechanics as a set of postulates about Hilbert space).

When you perform computer modeling of the three-body problem, you are not "abandoning formalization." You are choosing a different formalization—constructive formalization. Instead of seeking a function in closed formula form, you formalize the system as a deterministic process with discrete time, which for physical reality (which, as far as we know, need not be analytical in the Cauchy sense) is an equally legitimate mode of description.

The modern criterion for a theory's "completeness" might rather be stated as follows:

A theory is considered formalized if its postulates allow the construction of an unambiguous, reproducible algorithm (whether in the form of formulas or code) that connects initial conditions to predictions and can be implemented on a computing machine (classical or, prospectively, quantum) without recourse to the researcher's undefined "intuition."

If a theory does not permit even such algorithmic formalization, it remains at the level of metaphor or natural philosophy. If, however, formalization exists—whether in integrals or in a programming language—and such code "works," the theory gains status as a legitimate candidate for describing reality.

Software modeling is an incomparably more suitable method of formalizing theories that describe individual adaptivity systems and their foundational principles in interrelation. Only modeling on real, non-software components (electronic circuit design) could compete with this approach, but such modeling is far more labor-intensive and difficult to debug. Software circuit design, by contrast, enables the most rapid, comprehensive, and effective construction and development of adaptive models. Moreover, such models operate in a real environment, as the computer itself solves real tasks. There is no need to create a separate virtual reality for them, because nothing prevents physical reality from acting upon the running software model through receptors, while the model's actions through effectors manifest in the domain of physical reality. This resonates with Moravec's principle and the ideas of Rodney Brooks (founder of iRobot): "The world is the best model of itself." This is the approach of Cyber-Physical Systems, where the computational element is inseparable from the physical process.

This position essentially anticipates a paradigm shift occurring right now: the transition from physics of equations to physics of algorithms and processes. Attempting to describe adaptive behavior (for example, human gait or neural network operation) with a single differential equation is a formidable task; the equations become unmanageable. Program code, by contrast, is essentially a set of logical rules and conditions. For adaptive systems, algorithmic formalization is indeed more natural than analytical formalization. Code allows one to describe behavior, not merely state.

Code is a theory that can be executed

For describing complex, adaptive, open systems (biology, society, robotics, AI), the circuit-design approach is more effective and honest than attempting to force classical differential equations onto living reality. This is no longer merely a question of physics methodology; it is a question of the architecture of intelligent systems and, more broadly, how we understand the very concept of "theory" as applied to complexity.

In this context, software implementation proves to be not merely a verification tool, but the only adequate mode of existence for the theory. The theory of an adaptive system is its working code. Any textual description remains incomplete, like describing a dance in words.

Software circuit design enables implementation of the principle of constructive formalization: a theory is considered formalized if it is implemented as an algorithm that can be executed on a universal computing machine connected to reality through input-output channels.

When an adaptive model operates in a real environment, the following occurs:

1. The problem of "representation" disappears. The model need not model reality—reality itself provides sensory data.
2. Verification becomes continuous. The theory is tested not in an ad hoc laboratory experiment, but through ongoing functioning.
3. A criterion of "completeness" emerges: the theory works (or does not work) under real conditions, with real noise, delays, and non-stationarity.

This radically changes the epistemological situation. If for classical physics the criterion was experiment (an artificially created isolated situation), then for adaptive systems the criterion becomes functioning (embedded performance).

We arrive at an expanded definition:

Formalization of a theory of an adaptive system is the implementation of its principles as a software architecture capable of continuous interaction with physical reality through sensory and motor output channels, wherein this implementation itself constitutes the only complete expression of the theory.

Under such an approach:

1. Analytical mathematics becomes a special case (when adaptivity is unnecessary or minimized).
2. Software circuit design emerges as the default language of formalization for complex adaptive systems.
3. The criterion of truth shifts from "correspondence of prediction to experiment" to "stable, efficient, adaptive functioning in a real environment."

In such an implementation, program code becomes no less complex and no less comprehensible as a powerful mathematical formalization. For example, only a handful of people were able to understand Grigori Perelman's proof of the Poincaré conjecture. Here, GPT systems in the form of IDE agents come to the rescue: such an agent sees the entire project code and can develop it while following instructions in the programmer's natural language.

Now, if a programmer decides to comprehend and continue an adaptivity system project in their own way, they simply engage something like Cursor AI, receive comprehensible answers to questions, and become able to continue the project as they see fit.

This resolves many difficulties, including the natural misunderstanding of another's coding style and the use of unfamiliar constructs—all of this becomes irrelevant.

In the philosophy of science, this is called epistemology of distributed cognition: knowledge does not reside in the mind of a single developer but is distributed among human participants, tools, the agent, and the code itself.

This opens a prospect in which software formalization + agent assistance becomes not merely an alternative to mathematics, but a new standard for those domains where classical mathematical formalization is either impossible or impractical.

If the first version of the Individual Adaptivity System was built entirely "by hand" in the Go language, then another variant in JavaScript was created with the assistance of Cursor. The goal of developing the new version was to demonstrate that implementing a software model of a living entity does not require high-speed programming languages or powerful computers. The new version runs efficiently on any computer and uses basic JS.

Moreover, this code is maximally purified of secondary developmental details and embodies the MVAP theory in nearly pure form. Now this entity is approximately at the complexity level of domestic animals. The software system enables investigation of all levels of adaptivity and development of any mechanisms to refine understanding of their functionality and implementation. The new implementation has made many elements of the adaptive system more efficient and logical, so it does not merely replicate the old BeastGO, but advances the theoretical representations to a new level.

Creating and developing a living entity in software implementation proves to be the best way to comprehend the principles of individual adaptivity, their interrelations, and sequential development. Whatever model you produce will be your personal theory, your personal understanding.

The transition from Go to JavaScript (especially in the context of Cursor-assisted development) is not merely a change of tool. It is a fundamental assertion:

The essence of an adaptive system does not depend on hardware performance.

Go is a systems language oriented toward efficiency, concurrency, and low-level control. JS is an event-driven, asynchronous language operating in a browser sandbox or lightweight environment. If a living entity (an adaptive system at the level of a domestic animal) can be implemented in JS and run on any computer, then:

1. Execution speed is not a limiting factor for individual adaptivity.
2. Behavioral complexity does not require complex infrastructure.
3. The MVAP theory proves to be computationally lightweight, which in itself is a strong statement about the nature of adaptivity.

In traditional biology, experiments on live animals are limited ethically and methodologically. In software implementation, they become boundless and fully controllable. Importantly—and this is crucial—the system is not a simulation of biology in the narrow sense. It is an implementation of adaptivity principles that may be isomorphic to biological ones but need not copy them.

In traditional science, a theory exists as text, a set of formulas, a system of propositions. You may know a theory but not understand it in the sense you intend. Here, understanding means the ability to reproduce a living adaptive system, make it function, develop it, and observe how changes in mechanisms affect behavior.

Understanding is inseparable from the ability to create.

This is radical enactivism applied to theoretical knowledge:

1. The theory of adaptivity does not exist as a set of propositions.
2. It exists only as a working implementation.
3. And this implementation is always individual—each researcher will have their own model, and thus their own theory.

But then the question arises regarding the scientific community and theory alignment. If everyone has their own implementation, how is shared knowledge possible? The answer likely lies in:

1. Code openness — implementations can be compared.
2. Common architectural principles — MVAP (or what underlies it) defines a shared conceptual space.
3. The capacity of agents (humans and LLMs) to read and correlate different implementations.

The new version of BeastJS is available without restrictions: download to run on your computer simply by clicking on index.html.