Unit of Interaction: Foundations & Applications

• Unit of Interaction is the atomic, contextually invariant element that defines communication and state transformation in complex interoperable systems.
• It underpins protocol design and modular reasoning, bridging formal methods in software engineering, mathematical modeling, and physical systems.
• Its applications span UI authoring, robotic safety, automated coding, and quantum systems, ensuring observable accountability and practical system verification.

A unit of interaction denotes the atomic, contextually invariant element—such as a protocol-defined message exchange, a function/action morphism, a quantized evaluation outcome, or a discrete physical/metainformatic transformation—that grounds the structure, semantics, and accountability of complex interoperable systems. Its precise definition, operational role, and typology vary significantly across domains including software engineering, mathematical modeling, physical systems, data visualization, robotics, and automated code generation.

1. Interaction as a Primitive in Sociotechnical Systems

Within interaction-oriented software engineering (IOSE), a unit of interaction is not a mere event or function call but an explicit communication exchange among autonomous principals, typically formalized as protocol messages (Chopra et al., 2012). IOSE reconceptualizes classical principles as follows:

• Modularity: Principals (agents, organizations, people) themselves are modules; each is accountable for its own commitments within the interaction, rather than for behaviors imposed by a central system.
• Abstraction: Interaction is specified at the level of formal social meaning. A protocol message is abstractly interpreted in terms of social commitments, e.g.,

$$C(phy, pat, requestAppointment(pat, phy), availableSlots(phy, pat, \vec{s}))$$

signifying the commitment by a physician to respond with available slots after a patient's appointment request.

• Encapsulation & Separation of Concerns: The specification refers only to externally observed messages and commitments, never to a participant’s internal state or implementation details.

Interaction protocols enumerate legal sequences of such units, prescribe accountability, and decouple system membership from hardwired logic, supporting open and evolving sociotechnical systems.

2. Mathematical Foundations: Function + Action and Category Theory

In mathematical modeling of interactive systems, the unit of interaction is jointly defined by the combination of a pure function (λ-calculus mapping) and a context-transforming action (stateful transition) (Kanaya et al., 2014). Formalization leverages categorical frameworks (Kleisli category, monads):

• Injection and Binding Operators:
  • $\text{inject}\ x = \lambda s. [x, s]$
  • $$f \# m = \lambda s. \text{let}\ [x, s'] = m\ s\ \text{in}\ f\ x\ s'$$
• Unit of Interaction: A morphism $f: X \times S \rightarrow Y \times S'$, encapsulating both stateless computation and side-effect propagation.
• Compositionality: Arbitrarily large interactive systems are composed from smaller units of interaction following strict monadic laws (identity, associativity), enabling modular design with referential transparency and formal verification.

Practical systems, e.g., interactive art installations, instantiate chains of such units to realize complex, stateful behaviors, strictly separating function from effect.

3. Physical Systems: Magnetic and Quantum Interaction Units

In condensed matter and quantum systems, a unit of interaction is physically grounded in the atomic or quantum mechanical construct (e.g., a unit cell for crystalline films, or a unit filling in optical lattices):

• Magnetic Dipole Interaction: In ferrite thin films, the unit cell is the locus of both exchange and dipole interactions (Samarasekara et al., 2017). Its energy is captured as:

$E_{\text{exchange}} = 87NJ + 4(N-1)J$

$$E_{\text{dipole,unit-cell}} = \alpha(46.52229 \sin^2\theta - 2.82843 - 8.48528\cos^2\theta)$$

where $J$ is the exchange interaction and $\alpha$ the dipole strength; magnetic anisotropy and applied field further modulate the total energy.

• Quantum Lattice Interaction: In ultracold bosonic lattices, a linear interaction quench (LIQ) parameter $g$ acts as the unit of interaction (Mistakidis et al., 2017), driving the system through superfluid–Mott transitions. The time-dependent interaction is $g(t, \tau) = g_i + (g_f - g_i) t/\tau$, fundamentally controlling tunneling pathways, band population, and many-body resonances.

4. Interaction Landscapes and Functional Descriptors

For physical and virtual object analyses, a unit of interaction is formalized as a spatio-temporal descriptor capturing motion-driven functional relationships (Pirk et al., 2016):

• Descriptor Construction: Sensors observe motion particles as they traverse a bounded interaction space; local vector fields are derived, processed into attribute histograms (vorticity, shear, dilation, etc.), aggregated to form a global functional descriptor.
• Mathematical Signature:

$$d(V_1, V_2) = \frac{1}{|A|} \sum_{a \in A}w_a D_B(h_a, k_a)$$

(Bhattacharyya distance between histograms $h_a$ and $k_a$ for attributes $a$).

• Application: Enables shape retrieval, functional correspondence, and interaction prediction independent of the objects’ identities.

5. Interaction Authoring and UI Modeling

In interactive software and visualization authoring, a unit of interaction is a specification-level entity connecting user intent, implementation technique, and low-level component (Song et al., 2 Sep 2024):

• Hierarchy:

| Level | Abstract Entity | Example | |---------------|----------------------------------|-----------------| | Intent | Authoring goal | "Select" | | Technique | Specific interaction pattern | "Point select" | | Component | Implementation primitive | Mouse event, predicate evaluator |

• Authoring Framework: Encapsulates over 592 units of interaction from 47 applications, bridging design, evaluation, and tool-building tasks; units span selection, annotation, navigation, mapping change, and data transformation.

User interfaces themselves can be defined diagrammatically as "thinging machines", wherein each unit of interaction flows through ordered stages: creation, release, transfer, reception, and processing (Al-Fedaghi, 2019).

6. Robotic and Human-Machine Interaction Safety Units

In robotics, a unit of interaction encompasses biomechanical and cognitive safety boundaries (Kirschner et al., 2021). For instance, an Expectable Motion Unit (EMU) dynamically restricts robot velocity according to proximity and empirically derived risk of involuntary human motion, ensuring psychological safety. The velocity command is

$$v_{\text{safe}} = \min \{ v_d, v_{\text{SMU}}, v_{\text{EMU}} \}$$

with $v_{\text{EMU}}$ determined by mapping distance–velocity pairs to an acceptable occurrence probability of startle reactions.

Haptic devices employ amplitude-modulating units defined by hierarchical, multilayer material assemblies, modeled via viscoelastic attenuation:

$$u_{ri} = f_1(\rho_i, \mu_i, \lambda_i, z, \omega) J_1(kr) e^{- \frac{\omega \eta_i r}{E_i v_{p,i}} }$$

enabling both mechanical isolation and fine-grained tactile rendering (Huang et al., 13 Sep 2024).

7. Automated Coding and Unit Testing Frameworks

In machine learning-driven programming assistants, the unit of interaction is operationalized as the mutual execution of generated candidate solutions and unit tests, with outcome matrices guiding joint RL optimization (Wang et al., 3 Jun 2025):

• Interaction Matrix $\mathcal{B}$: For $n$ solutions and $m$ unit tests, entry $B_{j,l}$ indicates if solution $j$ passes test $l$.
• Reward Functions:
  • For solutions: $\mathcal{R}_{sj} = \sum_{l=1}^m B_{j,l}$
  • For unit tests: $$\mathcal{R}_{uk}^* = - \sum_{l=1}^n (1 - \mathcal{I}_{sl}) B_{l,k}^* + \left( \prod_{l=1}^n \mathcal{I}_{sl} B_{l,k}^* \right)\left( \sum_{l=1}^n (1 - \mathcal{I}_{sl}) \right)$$
• Policy Optimization: Ensures both coding and unit testing performance co-evolve based solely on interaction outcomes, enabling label-free RL regimes with significant code-generation gains.

8. Interaction Equivalence and Program Semantics

Interaction equivalence offers a refinement to contextual equivalence in programming language semantics by quantifying interaction steps while abstracting from internal computation (Accattoli et al., 27 Sep 2024):

• Quantitative Subject Reduction: If $t \to_h t'$ is a head (interaction) step, application count $k$ decreases by one; silent steps leave $k$ unchanged. Expansion properties guarantee restoration of indices, forming a robust multi-type system.
• Equational Theory: Characterized by B\"ohm tree equality, interaction equivalence yields a fine-grained, observationally motivated notion of program equality, distinct from cost-sensitive but reduction-variant alternatives.

---

In summary, the unit of interaction, across diverse domains, serves as a foundational construct that mediates structure, modulation, and observability in systems comprising autonomous, heterogeneous, or contextually interdependent entities. Whether as protocol message, morphism, object analytic descriptor, authoring granule, physical metaparticle, or RL feedback pair, its formalization enables modular reasoning, accountability, and empirical justification in both analysis and synthesis of interactive behaviors.