Logic-Conditioned Hybrid Control

• Logic-Conditioned Hybrid Control Framework is a unified approach that integrates continuous dynamics with complex Boolean logic constraints to enable scalable optimal control in cyber-physical systems.
• It reformulates logical constraints into smooth, differentiable expressions using functions like smoothMax and smoothMin, eliminating the need for mixed-integer formulations.
• Benchmark studies demonstrate that this method improves solution optimality, feasibility, and computation time in applications such as quadrotor trajectory planning and hybrid two-tank systems.

A Logic-Conditioned Hybrid Control Framework refers to a class of control system architectures that embed complex logical requirements directly into hybrid dynamical system optimization, planning, and synthesis tasks. These frameworks integrate continuous dynamics with logic constraints—spanning Boolean combinations of state and control predicates, temporal specifications, switching logic, or high-level task rules—into a unified, solver-friendly mathematical representation. The principal goal is to support mature continuous optimization and verification tools, eliminating reliance on non-scalable mixed-integer or ad hoc methods, while enabling rigorous handling of temporal logic, switching, events, and safety/liveness requirements.

1. Formal Problem Definition and Motivation

Hybrid optimal control problems naturally require that the system trajectory not only satisfy dynamic equations and boundary conditions, but also complex logic-encoded constraints:

• The continuous-time optimal control problem is posed as

$$\text{minimize}_{x(\cdot),\,u(\cdot)}\, J(x,u) = \int_{0}^{T} L(x(t),u(t))\,dt$$

subject to

$$\dot{x}(t) = f(x(t),u(t)), \quad x(0)=x_0, \quad x(T) \in \mathcal{X}_T$$

$$\varphi \text{ is true on the trajectory } \{x(t), u(t)\}$$

where $\varphi$ is a Boolean combination of point-wise predicates $g(x(t), u(t)) \leq 0$ or $g(x(t), u(t)) = 0$ (Wehbeh et al., 7 Jan 2026).

Such problems occur in robotics, autonomous vehicles, process control, and systems with mode-dependent behavior, obstacles, or safety envelopes. Traditionally, logic constraints have been encoded via mixed-integer programming or complemented by external discrete-event supervisory controllers. However, these approaches suffer from computational intractability, poor scaling, and lack of transparency for high-dimensional or real-time implementations.

2. Exact Continuous Reformulation of Logic Constraints

The central methodology is an exact reformulation of arbitrary logic constraints as continuously differentiable, nonlinear programming (NLP)-compatible expressions:

• Logical specification $\varphi$ can always be transformed into conjunctive normal form (CNF):

$$\varphi = \bigwedge_{i=1}^{m} \left( \bigvee_{j=1}^{n_i} \ell_{ij} \right)$$

where each literal $\ell_{ij}$ is an atomic predicate $g_{ij}(x(t),u(t)) \leq 0$.

• Each CNF clause $C_i: \bigvee_{j=1}^{n_i} (g_{ij}(x,u) \leq 0)$ is equivalent to

$$\varphi_i(x,u) := \min_{j=1,\ldots,n_i} g_{ij}(x,u) \leq 0$$

The overall CNF conjunction becomes

$\max_{i=1,\ldots,m} \varphi_i(x,u) \leq 0$

• All max and min operators are approximated by smooth, differentiable functions:

$$\operatorname{smoothMax}(a, b) = \frac{a + b + \sqrt{(a-b)^2 + \varepsilon}}{2}$$

$$\operatorname{smoothMin}(a, b) = \frac{a + b - \sqrt{(a-b)^2 + \varepsilon}}{2}$$

with small $\varepsilon > 0$ (Wehbeh et al., 7 Jan 2026).

• The result is a continuously differentiable set of constraints preserving the feasible set of the original logic, with the degree of regularity determined by the smoothness of the $g_{ij}$ predicates.

This continuous embedding removes the need for binary or complementarity variables, supporting efficient and reliable application of off-the-shelf continuous NLP solvers (SQP, interior-point, etc.).

3. Unified Framework Structure and Properties

All logic, dynamics, and performance objectives are captured in a single continuous optimization problem:

$$\text{min}_{x(\cdot), u(\cdot)} \;\; J(x,u) = \int_{0}^{T} L(x,u)dt$$

Subject to:

$$\dot{x} = f(x, u),\;\; x(0)=x_0,\;\; x(T) \in \mathcal{X}_T$$

$$\operatorname{smoothMax}_{i=1..m}[\,\operatorname{smoothMin}_{j=1..n_i}\,g_{ij}(x,u)\,] \leq 0$$

Key properties:

• Exactness: The feasible set of the continuous reformulation exactly matches that of the original logic (for small enough $\varepsilon$), even at max/min ties.
• High-order differentiability: All nonsmoothness is confined to the smooth approximations; differentiability matches that of the underlying $g_{ij}$.
• Scalability: Benchmark studies show improved solution consistency and reduced computation time compared to mixed-integer or big-M approaches, especially as the logic complexity increases (Wehbeh et al., 7 Jan 2026).

4. Benchmark Case Studies and Empirical Performance

The framework has been evaluated on canonical hybrid optimal control tasks with embedded complex logic:

Quadrotor Trajectory Optimization with Logic-Conditioned Spatial and Temporal Constraints

• Dynamics: Discretized planar quadrotor (position, pitch, velocity).
• Logic requirement: "If the quadrotor fails the green gate at $t=2$ or $3$, then for $t=5\dots9$ it must avoid the red obstacle." Encoded as an implication, expanded and smoothed as above.
• Outcome: The reformulated, smooth NLP finds the global-minimum solution 81.3% of the time (versus lower rates for big-M/complementarity), and is infeasible in only 4.4% of runs with average solve time 22.4 ms (Wehbeh et al., 7 Jan 2026).

Hybrid Two-Tank System with Temporal Logic

• Dynamics: Nonlinear cascaded tanks with Bernoulli flow.
• Logic requirement: $$(h^1_k \geq 4.5) \; \mathcal{U} \; (h^2_k \geq 4.5)$$.
• Formulation: "Until" operator mapped to conjunction-of-disjunctions and smoothed accordingly.
• Performance: With terminal-level only, 74.1% optimality rate; with "until", 86.2% feasibility and 38.3% global optimality. Integer-based competitors failed more frequently (Wehbeh et al., 7 Jan 2026).

These benchmarks demonstrate that the continuous logic-conditioned framework delivers increased global optimality likelihood, higher feasibility rates, and computational efficiency, while entirely sidestepping combinatorial complexity.

5. Comparison to Classical and Alternative Approaches

Traditional approaches for logic-conditioned hybrid control include:

• Mixed-integer programming (MIP): Encodes logic via binary variables; suffers poor scaling and may introduce non-differentiabilities and solver overhead.
• Big-M/complementarity formulations: Introduces large constants or penalty terms, often resulting in ill-conditioned NLPs and suboptimal convergence behavior.

In contrast, the continuous reformulation based on smooth max-min embedding (Wehbeh et al., 7 Jan 2026):

• Avoids integer variables
• Admits direct solution by mature NLP technologies
• Retains feasibility and solution quality for arbitrary Boolean logic structures
• Scales better to moderate increases in logic complexity

A plausible implication is that for practical hybrid systems where logic complexity is moderate and predicates are smooth, this approach is now the method of choice for scalable, real-time, or embedded optimization.

6. Applicability, Limitations, and Future Directions

Applicability:

The framework applies directly to tasks involving:

• Arbitrary Boolean combinations of trajectory- or control-dependent atomic constraints
• Temporal logic fragments expressible as CNF over pointwise predicates
• Any smooth, nonlinear system where logic over continuous variables must be enforced

Limitations:

• Current smoothing techniques are practical when the number of logic clauses is moderate; extremely large logic formulas may cause NLP overhead.
• All predicates must be available in analytic form for differentiability.
• Heavily non-smooth or discontinuous dynamics/predicates may erode the practical benefit of this method.

Future Directions:

An immediate direction is the extension to logic clauses involving higher-level quantification (e.g., “for all time t, exists control u such that ...”) or more general classes of temporal logic beyond simple CNF. Additionally, integration with learning-based predicate identification and online adaptive logic embedding may further expand scope and robustness.

7. Significance in the Broader Hybrid Control Landscape

The logic-conditioned hybrid control framework delivers a fundamental advance: It fully unifies discrete logic and nonlinear hybrid dynamics into a single, continuous, high-order differentiable programming model suitable for established optimization and verification tools. In doing so, it:

• Bridges the historical divide between continuous control and logical/symbolic specification
• Enhances scalability, reliability, and solution optimality for hybrid system tasks
• Enables formal verification, certification, and direct implementation in real-time/embedded contexts

By eliminating explicit discrete/Boolean auxiliary variables and leveraging smooth, exact encodings, it positions logic-conditioned hybrid control as the leading paradigm for next-generation cyber-physical control systems—where complex mission logic is an intrinsic, natively optimized component (Wehbeh et al., 7 Jan 2026).