Software Structure Invariants: Correct-by-Construction for AI Code Generation

The author builds on previous discussions of software structure, likening software to a building with functional components (rooms, floors) expressed through code as a 2D representation of a 3D mental model. This mental model consists of nodes (abstract concepts: entities, functions, behaviors), edges (relationships: composition, implementation, usage), boundaries, and information flows representing interactions.

While visualization helps, the author seeks a more formal expression of software structure. Inspiration comes from an article on the boundary between statistical and structural intelligence, which defines structural intelligence as the ability to actively construct system structures under given constraints. The foundation of this ability lies not in data itself but in invariants hidden behind the data—akin to conservation laws in physics (energy, charge, momentum) that persist regardless of system scale. In engineering, similar invariants include network connectivity, system stability, and resource conservation. An intelligent system must identify and leverage these invariants to generate feasible structures under complex constraints.

The author presents a formal notation: Consistency(S)=True, meaning the structure S is self-consistent (proves structural self-consistency).

In software, invariants serve as a design method. Extracting core invariant rules and expressing them via tests or textual representations can control whether AI code agents violate existing structures. Four categories of invariants are proposed:

Conceptual consistency constraints: Restrict the AI to a unified vocabulary, preventing different expressions for the same concept.

Connection consistency constraints: Define allowable references between modules and data structures, limiting what can connect.

Runtime consistency constraints: Enforce thread calls, IPC calls, and other dynamic behaviors through constructed test loops.

Class-level invariants: Traditional class invariants (preconditions, postconditions, state constraints).

The article advocates the Correct-by-Construction philosophy: ensure all constraints are satisfied during the design phase rather than verifying after completion. Embedding system constraints directly into the design process makes generated structures inherently compliant. This approach is positioned as a fundamental method for guaranteeing software quality in the era of AI code agents.

References:

Ribbo Mathematical Workshop·Structural Intelligence column: https://www.chaspark.com/?sessionid=#/hotspots/1249861090061246464

https://www.chaspark.com/#/hotspots/1253146175242625024