🤖 machine learning

Logic-Guided Vector Fields for Constrained Generative Modeling

This paper introduces Logic-Guided Vector Fields (LGVF), a neuro-symbolic framework that integrates differentiable logical constraints into flow matching generative models through a combination of training-time penalty losses and inference-time gradient adjustments, significantly reducing constraint violations while maintaining or improving distributional fidelity across diverse constrained generation tasks.

Original authors: Ali Baheri

Published 2026-05-26

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Ali Baheri

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are teaching a robot to draw a picture. You want the robot to create beautiful, realistic images (like a sunset or a cat), but you also have a strict rule: the robot must never draw a red line.

In the world of AI, this is a common problem. Most AI models are great at learning what to draw, but they are terrible at following strict "don't do this" rules while they are drawing. Usually, if the robot accidentally draws a red line, we just throw that picture away and try again. But if the "forbidden" area is tiny, the robot might try thousands of times before getting it right. That's slow and wasteful.

This paper introduces a new method called Logic-Guided Vector Fields (LGVF). Think of it as giving the robot a "smart compass" that helps it navigate around the forbidden red lines while it is drawing, rather than just checking the picture at the very end.

Here is how it works, broken down into simple steps:

1. The Problem: The "Straight Line" Trap

Imagine the robot starts with a blank canvas (noise) and needs to turn it into a picture of a cat.

Old Way: The robot learns a straight path from "blank canvas" to "cat." But sometimes, that straight line cuts right through a forbidden zone (like a red line or a wall). The robot doesn't care until the very last second, when it realizes, "Oops, I drew a red line!"
The Issue: If the forbidden zone is in the middle of the path, the robot keeps crashing into it, even if the final picture could have been perfect.

2. The Solution: LGVF (The "Smart Compass")

The authors propose a two-step training process to fix this:

Step A: Training with a "Gentle Nudge" (The Logic Loss)
During the learning phase, the AI is told: "Don't just look at the final picture; look at your path."

Imagine the robot is walking through a foggy forest. The goal is to reach a specific tree (the final image).
The "Logic Loss" is like a teacher standing in the forest. Every time the robot takes a step that gets too close to a forbidden red line, the teacher gives it a gentle push back.
Over time, the robot learns to curve its path. Instead of walking straight through the red zone, it learns to walk around it, finding a safe, curved route to the tree.

Step B: The "Last-Mile Correction" (Inference Adjustment)
Even with the teacher's help, the robot might still get a little too close to the edge.

When the robot is actually drawing a picture (not just practicing), the system adds a final "safety brake."
If the robot's path starts to drift toward a forbidden zone, a small mathematical force instantly pushes it back to safety. It's like a GPS that says, "You're getting too close to the cliff; let's turn slightly left."

3. What Did They Find?

The researchers tested this on three different "obstacle courses":

A Simple Wall: A straight line dividing the room.
A Donut Shape: The robot had to stay inside a ring and avoid the hole in the middle and the outside world.
A Maze: The robot had to navigate around three separate circular obstacles.

The Results:

Fewer Mistakes: Compared to standard AI models, LGVF reduced the number of "forbidden" mistakes by 59% to 82%.
Better Quality: In simple cases (like the wall and the donut), the pictures were not only safer but also looked more like the target images.
The Trade-off: In the complex maze (multi-obstacle) case, the robot became very good at avoiding the walls, but the pictures were slightly less perfect than the standard model. This is a classic trade-off: being super safe sometimes means you can't be 100% perfect in every other way.
Scaling Up: They tested this in high dimensions (like 100-dimensional space, which is like a room with 100 directions to move). Standard models failed miserably as the room got bigger, but LGVF kept the mistakes near zero.

The Big Takeaway

This paper shows that you can teach AI to respect strict rules while it is moving, not just after it stops. By combining a "training-time nudge" with a "real-time safety brake," the AI learns to naturally route itself around forbidden areas, much like a driver who instinctively steers around potholes rather than crashing into them and hoping for the best.

In short: It's about teaching the AI to be a good navigator, not just a good artist.

Technical Summary: Logic-Guided Vector Fields for Constrained Generative Modeling

1. Problem Statement

Generative models are increasingly deployed as proposal mechanisms in robotics, planning, and design, where outputs must satisfy explicit domain constraints (e.g., safety rules, physical feasibility). However, standard generative pipelines, particularly continuous-time models like Flow Matching, are largely "constraint-blind." While these models learn to transport probability mass from a base distribution to a target distribution, they often route trajectories through forbidden regions during the generation process, even if the final target distribution lies entirely within the valid set.

Existing workarounds, such as rejection sampling, projection, or heuristic guidance, suffer from significant limitations:

Rejection sampling becomes computationally impractical when feasible regions are small.
Projection can distort samples and fails when constraints are non-convex or disconnected.
Standard guidance methods (e.g., classifier guidance) provide soft control but do not guarantee constraint satisfaction.
Endpoint-only enforcement is insufficient because the generation trajectory itself may cross invalid regions, leading to rare but critical failures in safety-critical settings.

The core challenge addressed is how to incorporate logical and geometric constraints into flow-matching generative models to improve validity without sacrificing sample quality or distributional fidelity.

2. Methodology: Logic-Guided Vector Fields (LGVF)

The authors propose Logic-Guided Vector Fields (LGVF), a neuro-symbolic framework that integrates symbolic constraints directly into the generative dynamics of flow matching. The framework assumes constraints are specified as logical predicates $\phi(x)$ with differentiable relaxations (violation functions) $\ell_{logic}(x) \geq 0$ , where $\ell_{logic}(x) = 0$ if and only if the constraint is satisfied.

LGVF operates via two complementary mechanisms:

A. Training-Time Logic Loss

Standard flow matching learns a vector field $v_\theta(x, t)$ to minimize the distance between the learned velocity and the conditional velocity $x_1 - x_0$ along straight-line paths. LGVF augments this with a trajectory-level logic loss. Instead of checking validity only at the endpoint, the model penalizes constraint violations at intermediate states $x_t$ along the flow trajectory.

The total objective is:
$\mathcal{L}_{LGVF}(\theta) = \mathcal{L}_{FM}(\theta) + \mathbb{E}_{t, x_0, x_1} [\lambda(t) \cdot \ell_{logic}(x_t)]$

$\mathcal{L}_{FM}$ : Standard flow matching loss.
$\lambda(t) = \lambda_{max} \cdot t^\alpha$ : A time-dependent weighting schedule. This reflects the geometry of flow matching: at $t \approx 0$ , samples are near the base distribution where violations may be unavoidable; at $t \approx 1$ , samples approach the target where constraints must strictly hold.
Effect: This encourages the learned vector field to discover curved paths that route samples around forbidden regions rather than cutting through them.

B. Inference-Time Logic Adjustment

Training guidance alone cannot guarantee zero violations, especially for complex geometries. LGVF introduces a lightweight, gradient-based correction during sampling (ODE integration). The vector field is modified by subtracting the constraint gradient:
$\tilde{v}(x_t, t) = v_\theta(x_t, t) - \eta(t) \cdot \nabla_x \ell_{logic}(x_t)$

Mechanism: The term $-\nabla_x \ell_{logic}(x_t)$ points toward the steepest decrease in violation, pushing the trajectory toward valid regions.
Scheduling: The adjustment strength $\eta(t)$ is zero for early times ( $t \leq t_0$ ) and ramps up quadratically for $t > t_0$ (e.g., $t_0 = 0.3$ ). This ensures the correction acts as a "last-mile" refinement without destabilizing the integration or significantly altering the learned distribution.

3. Key Contributions

Identification of a Gap: The paper demonstrates that unconstrained flow-based transport can traverse forbidden regions even when the target distribution is entirely valid, highlighting the insufficiency of endpoint-only enforcement.
LGVF Framework: A novel method integrating symbolic constraints into flow matching via a two-stage approach:
- A training-time logic loss that penalizes violations along continuous flow trajectories.
- An inference-time gradient adjustment that steers sampling away from constraint violations.
Emergent Behavior: The method yields constraint-aware vector fields that exhibit emergent obstacle-avoidance behavior, routing samples around forbidden regions without explicit path planning.
Empirical Validation: Comprehensive evaluation across linear, nonlinear, and multi-region constraints, demonstrating consistent improvements in validity with minimal impact on sample quality.

4. Experimental Results

The authors evaluated LGVF on three 2D case studies and a high-dimensional scaling study:

Case Study 1 (Linear Half-Plane): LGVF + Adjusted reduced violation rates by 82% (from 2.2% to 0.4%) compared to standard Flow Matching.
Case Study 2 (Nonlinear Ring): LGVF + Adjusted reduced violations by 79% (from 5.65% to 1.20%), effectively handling both inner and outer boundary constraints.
Case Study 3 (Multi-Obstacle): In this complex, non-convex setting, training-time logic loss alone slightly increased violations due to the difficult loss landscape. However, the inference-time adjustment successfully compensated, reducing violations by 59% (from 1.7% to 0.7%).
Case Study 4 (High-Dimensional Scaling): In dimensions $d \in \{10, 25, 50, 100\}$ , standard Flow Matching violations grew significantly (up to 14.8% at $d=100$ ). LGVF + Adjusted maintained near-zero violation rates (0.0%–0.4%) across all dimensions.

Trade-offs:

In linear and ring settings, LGVF improved both validity and distributional fidelity (measured by MMD).
In the multi-obstacle setting, a satisfaction–fidelity trade-off was observed: while feasibility improved, MMD increased slightly, indicating a deviation from the target distribution shape.

Ablation Studies:

Stronger training-time weights ( $\lambda_{max}$ ) monotonically reduced violations.
Training-time guidance and inference-time adjustment are complementary: combining both yielded the best results (0.02% violation vs. 0.50% baseline), outperforming either component alone.

5. Significance and Claims

The paper claims that LGVF provides a reliable mechanism for enforcing constraints in generative modeling without requiring explicit path planning or expensive rejection sampling. By coupling global shaping of transport (via training loss) with local correction (via inference adjustment), the framework achieves robust constraint satisfaction across diverse geometries.

The authors position LGVF as a step toward making generative models viable for safety-critical applications where validity is non-negotiable. They acknowledge remaining challenges, including extending the method to complex high-dimensional data (e.g., images, molecules), improving robustness under highly non-convex landscapes, and further analyzing the satisfaction–fidelity trade-off. The work does not claim to solve all constrained generation problems but offers a scalable, differentiable approach that significantly outperforms standard baselines in the tested settings.