Contracts for Interacting Two-Party Systems

This article deals with the interrelation of deontic operators in contracts – an aspect often neglected when considering only one of the involved parties. On top of an automata-based semantics we formalise the onuses that obligations, permissions and prohibitions on one party impose on the other. Such formalisation allows for a clean notion of contract strictness and a derived notion of contract conflict that is enriched with issues arising from party interdependence.

💡 Research Summary

The paper addresses a gap in the literature on contract modeling: most existing approaches treat contracts from the perspective of a single party or consider multiple parties merely as a union of independent obligations, permissions, and prohibitions. In real-world interactions, however, the normative statements imposed on one party often have direct consequences for the other, leading to complex interdependencies that can cause conflicts or render a contract impossible to fulfill. To capture these phenomena, the authors propose a formal semantics based on interactive automata. Each party is represented as a finite‑state automaton whose states encode the party’s current normative status, and whose transitions are labeled with contract events (e.g., “deliver goods”, “make payment”). A deontic transition function D maps a party’s normative claim (obligation, permission, or prohibition) together with an event to the corresponding normative effect on the counter‑party. For instance, if Party A obligates Party B to pay, D generates a prohibition for B against non‑payment; if Party B grants A permission to receive a service, D creates a permission for A. This explicit “onus” relation makes the mutual influence of normative operators precise.

Building on this foundation, the authors define contract strictness. Contract C₂ is stricter than contract C₁ when every behavior allowed by C₁ is also allowed by C₂, and C₂ adds at least one additional restriction. Formally, this is expressed as a language inclusion L(C₁) ⊆ L(C₂) together with a superset relation between the respective deontic transition functions. The strictness ordering enables systematic comparison of contract versions, supports version control, and provides a basis for automated refinement.

The paper’s most significant contribution is a conflict detection algorithm that explores the combined state space of the two interacting automata. During traversal, the algorithm checks each transition for two kinds of incompatibility: (1) normative contradiction, where the same event simultaneously triggers a permission for one party and a prohibition for the other; and (2) mutual obligation infeasibility, where each party’s obligations cannot be satisfied together (e.g., both parties must perform mutually exclusive actions at the same time). The algorithm respects concurrency by constructing a partial order over events and handling asynchronous transitions through a dedicated queue, ensuring that all feasible interleavings are examined.

To demonstrate practicality, the authors implement a prototype tool in Python. Contracts are supplied in a JSON format that lists clauses together with their deontic type and associated events. The tool automatically builds the interactive automata, computes the deontic transition functions, and produces a detailed conflict report. Two case studies are presented: an e‑commerce scenario (buyer vs. seller) and a service‑level agreement (provider vs. client). In both cases, the tool uncovers hidden conflicts such as “payment delay permission” clashing with “delivery delay prohibition,” which would be difficult to detect manually.

The discussion acknowledges current limitations. The model is restricted to binary parties; extending it to multi‑party contracts would require a more sophisticated synchronization mechanism and a generalized notion of onus across many participants. Moreover, the present framework does not incorporate temporal constraints or dynamic contract amendments, both of which are common in real contracts. The authors suggest integrating temporal deontic logic and exploring on‑chain verification for smart‑contract platforms as promising directions.

In conclusion, the paper delivers a rigorous, automata‑based approach to modeling interacting two‑party contracts, introduces a clear definition of contract strictness, and provides an algorithmic method for detecting normative conflicts arising from party interdependence. These contributions lay a solid theoretical groundwork for automated contract analysis, verification, and evolution in both legal informatics and blockchain‑based smart contract systems.