Non-Conflicting Synthesis in System Design

• Non-conflicting synthesis is a design approach that ensures implementations meet system requirements without blocking environment behavior, emphasizing cooperation.
• It employs automata-theoretic, GR(1), and optimization techniques to construct controllers and schedulers that avoid specification conflicts.
• Applications span cyber-physical and component-based systems, guaranteeing safety and liveness while maintaining clear trade-offs among conjunctive requirements.

Non-conflicting synthesis is the task of constructing correct-by-construction implementations—be they controllers, transducers, or prioritized schedulers—that satisfy system requirements without exploiting or forcing environment or specification conflicts. The aim is to ensure that every system-environment interaction preserves intent: the system does not win by causing or relying on specification violations in the environment, nor does it mask trade-offs among conjunctive requirements. Non-conflicting synthesis arises in diverse formal synthesis settings, including automata-theoretic approaches to LTL and GR(1), optimization-based synthesis for cyber-physical systems, learning-based protocol construction, and combinatorial conflict repair in component-based architectures.

1. Formal Definitions and Core Motivations

Non-conflicting synthesis generalizes classical assume-guarantee and conjunctive specification settings. Conventionally, specifications take the form $A \Rightarrow G$: the system is required to ensure $G$ (the guarantee) whenever the environment satisfies $A$ (the assumption). In standard approaches, the synthesized system may "win" by invalidating $A$, for example, by actively inhibiting the environment’s ability to fulfill liveness constraints or by masking specification conflicts. This anti-cooperative behavior undermines intended design semantics (Bloem et al., 2015, Majumdar et al., 2019).

A system strategy or implementation is non-conflicting if, informally, it never restricts the environment's ability to satisfy its assumptions or liveness whenever such satisfaction is in principle possible, and, in optimization, if it does not obscure trade-offs among conjunctive requirements. For LTL and game-based synthesis, this is formalized via branching-time and tree automata semantics that demand system-environment plays admit, at each point, at least one branch extending to an assumption-satisfying (or maximally cooperative) outcome (Bloem et al., 2015, Majumdar et al., 2019).

2. Non-conflicting Synthesis in Temporal Logic Frameworks

In LTL-based assume-guarantee synthesis, non-conflictingness requires more nuanced enforcement than classical correctness. Instead of merely ensuring $A \Rightarrow G$ across traces, one seeks to maximize cooperation: the system should, to the greatest degree possible, realize both $A$ and $G$ without intentionally blocking $A$. Bloem, Ehlers, and Könighofer introduce a formal lattice of cooperation levels, distinguishing 15 semantically distinct enforcement tiers ranging from enforcing both $A$ and $G$ (strongest cooperation) to merely enforcing $A \Rightarrow G$ (weakest). A maximally cooperative implementation achieves the highest possible level across all environment behaviors, dynamically lifting to stronger levels if the environment cooperates (Bloem et al., 2015).

The formal machinery includes:

• Synchronous products of Rabin tree automata for each conjunct specifying how $A$, $G$, and their combinations are to be enforced (never, always, sometimes, etc.).
• An automata-theoretic construction that, at runtime, transitions to strictly higher cooperation levels when possible, ensuring no opportunity for greater cooperation is missed.
• Soundness and completeness theorems asserting that the synthesized Mealy transducers exhibit maximal attainable cooperation under every environment scenario.

3. Non-conflicting GR(1) Synthesis

GR(1)-synthesis, a special case of LTL synthesis for generalized reactivity(1) specifications, also exhibits the foundational conflict: standard solutions optimize $G$ provided $A$ is met but may win by preventing $A$ outright. Environmentally friendly or non-conflicting GR(1) synthesis modifies the solution space to exclude strategies that irrevocably block environment liveness.

The core definition in this context is: for every finite prefix $\alpha$ of a system strategy $\sigma$, there must remain an infinite play extending $\alpha$ that satisfies all environment liveness (Büchi) assumptions. Algorithmically, classic GR(1) relies on a 3-nested $\mu$-calculus fixpoint; non-conflicting variants introduce a 4-nested fixpoint, adding an inner least fixpoint to enforce the system's deferral of environment blocking as long as possible (Majumdar et al., 2019).

Key properties:

• Complexity remains $O(|Q|^2)$ symbolic steps, matching standard GR(1).
• Synthesized strategies are memoryless and ensure both GR(1)-winningness and non-blocking of environment liveness wherever feasible.
• Empirical results show only moderate increases in time and strategy size for non-conflicting synthesis.

4. Conflict-Repair and Compositionality in Component-based Systems

In component-based architectures (e.g., BIP systems), non-conflicting synthesis addresses the construction of priority relations among actions to guarantee both safety and deadlock-freedom without introducing cyclic (and therefore inconsistent) priorities. Here, a priority $\sigma_1 \prec \sigma_2$ means action $\sigma_1$ cannot fire when $\sigma_2$ is also enabled. Cyclic priorities constitute conflicts; thus, non-conflicting synthesis formulating the priority relation as an acyclic, transitive partial order is essential (Cheng et al., 2011).

The methodology involves:

• Fault localization using a two-player safety game to identify “fault” transitions where the controller could cause risk or deadlock.
• SAT-based conflict-repair, encoding the search for a consistent, acyclic set of additional priorities to block only the fault edges.
• Scaling via orthogonal abstraction/preprocessing: data abstraction, alphabet abstraction with $\sharp$-deadlocks, and compositional synthesis using learning-based assumptions (Angluin's L* algorithm).

The approach guarantees that the synthesized priorities are implementable in a distributed runtime, stateless, and minimal, while never introducing cycles that would prevent system execution.

5. Optimization-based Non-conflicting Synthesis under Conjunctive Requirements

In optimization-driven synthesis for cyber-physical systems, non-conflictingness addresses the masking problem: large-magnitude robustness of one conjunct may obscure violation of others when synthesizing input signals against conjunctive Signal Temporal Logic (STL) specifications. To resolve such issues, conjunctive requirements are handled as multiple constraints rather than a single aggregate objective (Sato et al., 2020).

The core algorithm decomposes conjunctive synthesis into:

• Maximizing the robustness of a selected "main" requirement while maintaining each other conjunct strictly above the satisfaction threshold via inequality constraints.
• Employing Multiple Constraint Ranking (MCR) within CMA-ES evolutionary optimization to prioritize solutions that minimize the number and degree of constraint violations before optimizing the chosen objective.

This approach improves success rates substantially on difficult benchmarks and eliminates the scale problem inherent in naïve min-based robustness aggregation, ensuring that the synthesized input achieves satisfaction of all conjuncts whenever possible.

Example Table: Non-Conflicting Synthesis Mechanisms

Domain	Non-Conflicting Criterion	Algorithmic Core
LTL/GR(1) synthesis	System never forces violation of A	Fixpoint/Automata construction
Component-based priorities	No cyclic (conflicting) priority relations	Fault-localization + SAT
CPS optimization (STL)	No masking among conjunctive constraints	Constraint ranking in CMA-ES

6. Learning-based Synthesis from Conflicting Specifications

When target behaviors are given as black-box, possibly conflicting sets (specified as inclusion in a target language $U$), non-conflicting synthesis aims to construct a transducer whose language is a subset of $U$, never forcing the implementation of incompatible traces (Bloem et al., 2020).

Primary features include:

• Symbolic membership queries to an oracle for discovering output sets that continue inclusion within $U$.
• Split operations on observation tables when conflicting outputs are detected, strictly reducing incompatibility.
• Bounded algorithmic complexity in terms of target language rank and incompatibility measure, with efficient synthesis demonstrated for practical hardware/software protocol domains.

This guarantees that only safe, non-conflicting (with respect to observed and inferred environment behaviors) implementations are produced.

7. Practical Implications, Limitations, and Extensions

Non-conflicting synthesis frameworks yield strategies and implementations that more faithfully represent specification intent, prevent specification "hacks," and respect the autonomy of environment components or requirements. They are applicable in distributed control, protocol synthesis, optimization-driven system configuration, and black-box inference tasks. In most temporal logic frameworks, their algorithmic complexity matches or only marginally exceeds that of classical methods.

Extensions address cooperation beyond binary non-conflictingness, quantitative cooperation measures, richer classes of specifications (e.g., ω-regular beyond LTL), and heuristic refinements for scalable synthesis in common practical fragments (such as GR(1)). A plausible implication is that, as systems scale and exhibit richer interactions among assumptions, guarantees, and data, non-conflicting synthesis will become increasingly critical to ensure correct-by-design systems align with high-level specifications and stakeholder intent (Bloem et al., 2015, Sato et al., 2020, Bloem et al., 2020, Cheng et al., 2011, Majumdar et al., 2019).