Logical Robots: Declarative Multi-Agent Programming in Logica

Abstract: We present Logical Robots, an interactive multi-agent simulation platform where autonomous robot behavior is specified declaratively in the logic programming language Logica. Robot behavior is defined by logical predicates that map observations from simulated radar arrays and shared memory to desired motor outputs. This approach allows low-level reactive control and high-level planning to coexist within a single programming environment, providing a coherent framework for exploring multi-agent robot behavior.

• The paper presents a unified framework that integrates high-level symbolic reasoning and low-level reactive control using Logica.
• It employs SQL-based declarative aggregations to efficiently fuse sensor inputs and support distributed pathfinding in complex environments.
• Practical scenarios validate scalable coordination and real-time performance in multi-robot systems through declarative programming paradigms.

Declarative Multi-Agent Programming in Logica: A Unified Symbolic-Subsymbolic Framework

Overview and Motivation

"Logical Robots: Declarative Multi-Agent Programming in Logica" (2604.06629) presents a platform where autonomous robot behavior is fully specified in Logica, a declarative logic programming language compiling to SQL. This system addresses a longstanding gap between symbolic planning and low-level reactive control within multi-agent systems (MAS). Traditionally, logical MAS programming operates at a high level, relegating sensor integration and motor control to imperative, subsymbolic code. Logical Robots enables seamless composition of both reasoning and control, leveraging declarative aggregations that naturally model robotics problems at scale.

Platform Architecture and Simulation Environment

The Logical Robots platform simulates a two-dimensional labyrinth comprised of four primary entities: robots, stationary beacons, spatial areas with dynamic accessibility, and explicit win conditions. Each robot, uniquely identified, executes an atomic Logica program per timestep. Sensor input is modeled as an array of radar rays, each labeled with angle, distance, object type, and identifier; local and shared memories are accessible through the Memory predicate.

This architecture grounds robot control in logical predicates that emit motor desires and updated internal state. Sensor fusion, aggregation, and symbolic reasoning are invoked through SQL-optimized constructs such as WeightedAverage and ArgMin, enabling real-time navigation and planning in environments with substantial sensor throughput.

Figure 1: Multi-robot exploration with sensor rays (red endpoints: wall, green endpoints: beacon) and dynamic area toggling triggered by specific beacon detection (e.g., Fire Station).

Declarative Reactive Control and Planning

Control logic is purely declarative, using aggregations to convert radar observations into motion commands. For example, obstacle avoidance is realized by weighting ray votes for open directions, directly mapping to engine controls via the Robot predicate. The framework supports both stateless reactive strategies and stateful behaviors, such as distributed pathfinding and formation control.

State-based planning is exemplified by the Bellman-Ford-inspired distributed pathfinding rule. Robots explore and store beacon positions locally; a leader robot aggregates global state, reconstructs the navigation graph, and computes shortest paths via declarative minimization. Memory predicates are configured for both autonomous and collaborative operation, supporting varied coordination levels.

Figure 2: Distributed mapping scenario: robots collaboratively explore a beacon-filled labyrinth, building a shared navigation graph to find their way ``Home.''

Scenario Demonstrations and Performance

Ten coordination scenarios ranging in complexity are provided. Notable cases include:

• Station Management: Robots maintain contact with beacons to control area accessibility and mitigate hazards while others pursue separate objectives.
• Formation Navigation: Robots dynamically read peer memory to achieve collective group navigation, establishing ordered traversal and synchronized goal attainment.
• Distributed Mapping: Robots discover unknown beacon positions, propagate discovery information via shared memory, and execute centrally planned navigation using declaratively computed shortest paths.

The platform is capable of real-time execution with large-scale sensor data due to Logica’s SQL compilation, bypassing grounding bottlenecks typically encountered in ASP/Prolog-based approaches. Declarative aggregations such as WeightedAverage ($x.distance \rightarrow x.angle$) are directly mapped to sensor fusion operations, yielding efficient, interpretable control flows.

Practical and Theoretical Implications

Logical Robots demonstrates that logic programming can express both symbolic and subsymbolic behavior in agent systems, with SQL compilation enabling practical scalability. This unification allows declarative specification of cooperative and competitive strategies, formation behaviors, and reactive planning, serving both as an educational tool for MAS programming and a foundation for scalable multi-agent robotics.

The approach implies that future MAS development can increasingly rely on declarative paradigms for end-to-end agent specification. The integration of sensor data fusion, planning, and stateful coordination within a single logic environment lowers the barrier to both formal verification and rapid prototyping. The SQL backend hints at extensibility for hardware deployment and parallel execution, suggesting broader applicability beyond simulation.

Conclusion

"Logical Robots" (2604.06629) advances the MAS landscape by providing a unified declarative framework for specifying low-level control, sensor aggregation, and symbolic planning. The platform validates efficient, interpretable robot control at scale and facilitates multi-agent coordination directly within logic programs. Its implications extend to practical robot programming, formal method integration, and scalable distributed AI systems, with Logica offering a promising bridge between symbolic abstraction and subsymbolic actuation.