LoGoPlanner: Hybrid Logic & Geometric Planners

• LoGoPlanner is a hybrid planning framework that combines logical constraints with geometric, probabilistic, and learning-based optimization to solve complex tasks.
• It spans diverse applications including stochastic task and motion planning, global logistics optimization, unified trajectory planning, receding horizon TAMP, and end-to-end navigation.
• Its architectures leverage mixture models, ASP-based solvers, CHOMP heuristics, and transformer-driven policies to ensure robust, scalable, and adaptable planning in real-world settings.

LoGoPlanner is a term used for multiple distinct, state-of-the-art planners integrating logic, geometry, and optimization principles for robotics, planning, and logistics. This article surveys the major LoGoPlanner frameworks: logic-geometric programming under uncertainty, logic-based optimization for global logistics, unified trajectory planning with implicit surfaces, discrete-continuous task and motion planning, and localization-grounded navigation with metric-aware visual geometry. Each instantiation exhibits a characteristic hybridization of logical constraints or symbolic modes with geometric, probabilistic, or learning-based optimization, enabling high performance in complex, real-world domains.

1. Logic-Geometric Programming Under Uncertainty

LoGoPlanner, as presented in (Ha et al., 2020), extends Logic-Geometric Programming (LGP) for stochastic task and motion planning under uncertainty. LGP augments a continuous trajectory optimizer (nonlinear program, NLP) with a discrete “logic” layer encoding skeletons—sequences of high-level modes (e.g., free-motion, touch, grasp, push). For each skeleton, the continuous optimizer enforces path constraints ($h_{\text{path}},g_{\text{path}}$) and switch constraints ($h_{\text{sw}},g_{\text{sw}}$), yielding a deterministic, piecewise-smooth trajectory.

To address stochasticity, the LoGoPlanner framework leverages the control-inference duality: under control-affine dynamics with actuator noise, the stochastic optimal control objective can be expressed as minimizing the Kullback-Leibler divergence between the controlled path distribution and a target (optimal) posterior. This posterior, incorporating logic constraints, is approximated as a mixture-of-Gaussians:

$$p^*(z_{[0,T]}) \approx \sum_{i=1}^{N_a} w_i\, \mathcal{N}(z_{[0,T]} \mid \mu_i, \Sigma_i)$$

where each component corresponds to a logic skeleton $a^{(i)}$, with mean $\mu_i$ the solution of the constrained NLP and covariance $\Sigma_i$ constructed by Laplace approximation, projected into the nullspace of active constraints.

Cost functions regularize dynamics (e.g., penalizing joint acceleration) and ensure task achievement (e.g., goal proximity, collision avoidance), while constraints encode contact and kinematic switches. Path planning is performed offline by enumerating skeletons and optimizing each; online, mixture weights are updated reactively as the system state evolves, supporting robustness and rapid switching in response to disturbances. Empirical demonstrations include contact-rich manipulations (e.g., elbow-on-table reaching, multi-finger box pushing), consistently showing the emergence of contact exploitation and mode switching as optimal strategies (Ha et al., 2020).

2. Logic Programming for Global Logistics Optimization

In a global logistics context, LoGoPlanner denotes a logic-programming-driven optimizer for co-designing production and supply chains (Dietz et al., 2023). Here, the planner integrates an RDF/OWL knowledge graph encoding locations, parts, transport modes, and assembly dependencies with an Answer Set Programming (ASP) model, supporting joint optimization over production assignments and part routing.

The pipeline involves:

• Extracting system models from a knowledge graph (ontology TBox and assertion ABox), including automated inference via SWRL and distance computation.
• Translating the model into ASP facts (e.g., productionLoc, warehouseLoc, transportRoute, partProduceableAt).
• Defining formal ASP rules for feasible sourcing, transport path selection, integrity constraints (e.g., single/multi-sourcing, risk mitigation), and multi-objective optimization (#minimize total transport distance, #maximize resilience via multi-sourcing).
• Enumerating Pareto-optimal configurations via clingo solver in multi-objective mode, followed by interactive visualization mapping candidate solutions to KPIs and world maps.
• Achieving significant reductions in computational load by inlining precomputed routes and encoding domain-specific constraints.

This LoGoPlanner instance supports rapid re-planning in co-design settings and robust optimization against uncertain events and bottlenecks in distributed manufacturing and supply logistics (Dietz et al., 2023).

3. Unified Trajectory Planning with Log-GPIS

Within the Log-GPIS-MOP probabilistic mapping and navigation framework, LoGoPlanner refers specifically to the trajectory optimizer using the Log-Gaussian Process Implicit Surface (Log-GPIS) representation (Wu et al., 2022). The optimizer parameterizes a trajectory as a discrete sequence of waypoints $\{x_0, x_1, ..., x_N\}$, minimizing the functional

$$\mathcal{C}[x(\cdot)] = \int_0^T \frac12\|\dot{x}(t)\|^2 dt + \lambda \int_0^T c(x(t))\|\dot{x}(t)\|dt$$

where the collision cost $c(x)$ is determined via the Log-GPIS distance field $d(x)$ and its gradient $\nabla d(x)$, implementing a hinge-shaped penalty with quadratic ramp near obstacles.

Optimization proceeds via preconditioned gradient descent a la CHOMP, leveraging a sparse tridiagonal smoothness matrix and querying the Log-GPIS surface at each iteration to compute obstacle costs and gradients. Collision avoidance is handled softly via the penalty or can be enforced with hard constraints ($d(x_i) \geq d_{\min}$). This approach enables direct, unified treatment of trajectory optimization, mapping, and odometry within a single probabilistic surface framework (Wu et al., 2022).

4. Receding Horizon and Heuristics-Driven TAMP

The RHH-LGP algorithm exemplifies a scalable Logic-Geometric Planner for long-horizon task and motion planning (TAMP) (Braun et al., 2021). The planning problem is formulated as mixed-integer nonlinear programming: finding mode sequences $m=(m_1, ..., m_K)$ and continuous trajectories $q(t)$ under path/switch constraints. To address combinatorial explosion, RHH-LGP incorporates:

• Geometry-based heuristics for rapid infeasibility detection and action cost-to-go estimation directly within the symbolic search (e.g., reachability, distance-to-goal, grasp feasibility).
• A receding horizon scheme: the planning horizon is windowed (size $H$), and only the first $\delta\leq H$ phases are committed per iteration, decomposing the long TAMP into tractable subproblems.

The algorithm alternates discrete search (guided by heuristics), fast NLP bounds, and path-level NLP optimization within each window, rolling forward until the final goal is reached. Across multi-robot and modular-robot benchmarks, RHH-LGP demonstrates an order-of-magnitude reduction in planning time and the ability to solve instances with up to 50 discrete actions, outperforming previous LGP methods (Braun et al., 2021).

5. End-to-End Localization-Grounded Navigation with Metric-aware Geometry

In navigation, LoGoPlanner refers to a localization-grounded, end-to-end policy that fuses visual geometry and metric-scale awareness to generate robust control in unstructured environments (Peng et al., 22 Dec 2025). The system architecture combines:

• A long-horizon visual-geometry backbone (VGGT), extracting metric-feature tokens from RGB and depth streams via rotary position embedding.
• Geometry reconstruction heads predicting local 3D points and camera poses, with auxiliary losses enforcing metric consistency (local point, pose trace, and global world-point supervision).
• An explicit geometric memory accumulating predicted world-coordinate point clouds, providing persistent scene awareness.
• Policy conditioning via transformer-based cross-attention over state and geometry queries, with a diffusion policy decoding chunked motion commands.

The training pipeline first fine-tunes geometry heads, then the diffusion policy head on denoising objectives. LoGoPlanner demonstrates significant improvements over oracle-localization and SLAM-based baselines in both simulation and real-world deployment on diverse robotic platforms, leveraging calibration-free implicit alignment and domain-bridging metric features.

Experimental evaluation confirms robust SR and SPL improvements, with statistical significance ($p < 0.01$), and the ability to generalize across camera configurations and platforms without explicit extrinsic calibration (Peng et al., 22 Dec 2025).

6. Comparative Summary

LoGoPlanner, as term and methodology, spans a family of planners distinguished by their synthesis of logical structuring (symbolic modes, constraints, or logic programs) with geometric, probabilistic, or learned trajectory optimization. The key instantiations include:

Domain	Logic Layer	Geometric/Probabilistic Layer	Notable Features
Manipulation, TAMP	Mode skeletons	Trajectory NLP + uncertainty	Contact exploitation, mixture-of-Gaussians (Ha et al., 2020)
Logistics	ASP encoding	Knowledge-graph constraints, KPIs	Multi-objective Pareto front, visualization (Dietz et al., 2023)
Navigation & Mapping	N/A (implicit)	Log-GPIS surface, CHOMP optimizer	Unified mapping/odometry/planning (Wu et al., 2022)
Long-horizon TAMP	Mode search	Heuristics, receding horizon NLP	Fast pruning, large-scale scalability (Braun et al., 2021)
RL Navigation	N/A (transformer attention)	Metric-aware geometry, diffusion policy	No explicit localization, strong sim2real (Peng et al., 22 Dec 2025)

The LoGoPlanner paradigm enables tractable planning in high-dimensional, uncertain, and combinatorial domains via tight integration of logical reasoning and geometry-aware optimization or learning. Each algorithm includes a tailored pipeline—ranging from symbolic skeleton enumeration and multi-objective ASP solving to deep transformer- and diffusion-based end-to-end policies—validated in simulation and real-world applications.

7. Directions and Implications

Current LoGoPlanner frameworks support modularity, adaptability, and multi-objective optimization in dynamic settings. Across manipulation, logistics, mapping, and navigation, they provide concrete algorithmic advances: improved robustness through mixture models or Pareto enumeration, dramatically reduced planning times via heuristic search and horizon decomposition, and end-to-end metric-aware policies bypassing classical state estimation pipelines.

Ongoing and future work addresses the automation of logic rule template generation, bridging open- and closed-world knowledge for richer ASP reasoning, incorporating additional KPIs (e.g., carbon footprint, lead-time), and leveraging incremental or multi-shot solves and simulation-based risk assessment. In learning-based navigation, further integration of richer metric geometry and explicit reasoning may offer additional gains in robustness and generalization. The collective architectures instantiate a reference methodology for hybrid logic-geometric planning under real-world uncertainty and complexity.