💻 computer science

Robot Arm Control via Cognitive Map Learners

This paper demonstrates that independently trained Cognitive Map Learners (CML) can be hierarchically composed to control multi-jointed robot arms in 2D and 3D spaces by factorizing target phasor hypervectors into segment angles, thereby achieving precise positioning without relying on traditional inverse kinematic equations.

Original authors: Nathan McDonald, Colyn Seeley, Christian Brazeau

Published 2026-03-31

📖 5 min read🧠 Deep dive

CC0 1.0

Original authors: Nathan McDonald, Colyn Seeley, Christian Brazeau

Original paper dedicated to the public domain under CC0 1.0 (http://creativecommons.org/publicdomain/zero/1.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 have a robotic arm, like a mechanical spider leg, made of several segments connected by joints. Your goal is to tell this arm to reach a specific spot on a table.

Traditionally, engineers solve this using complex math called "Inverse Kinematics." Think of this like trying to solve a giant, tangled knot of equations every single time the arm needs to move. It's precise, but it's rigid. If you want to add a new segment or change how the arm moves, you often have to re-calculate everything from scratch.

This paper proposes a completely different, more "human-like" way to do it using Cognitive Map Learners (CMLs) and Hyperdimensional Computing (HDC). Here is how it works, explained through simple analogies.

1. The Team of Specialists (Cognitive Map Learners)

Instead of one giant brain trying to control the whole arm, imagine the arm has a team of specialists.

Each joint (or arm segment) has its own tiny, independent "brain" (a CML).
Each brain only knows about its own joint: "I can turn left, I can turn right, and here is how I get from my current angle to any other angle."
The Magic: These brains are trained separately. You don't need to retrain the whole team if you add a new arm segment; you just add a new specialist to the team. They are "composable," meaning you can snap them together like LEGO bricks to build bigger, more complex robots.

2. The Secret Language (Hypervectors & Phasors)

How do these specialists talk to each other? They don't use numbers like "45 degrees" or "10 inches." They use a secret code called Hypervectors.

Think of a hypervector as a unique, high-dimensional fingerprint or a color code.

In this system, a location on a table (like a target point) is turned into a "color code" using a technique called Fractional Power Encoding (FPE).
Imagine the X-axis is a "Red" frequency and the Y-axis is a "Blue" frequency. A point at (3, 4) isn't just numbers; it's a specific shade of purple created by mixing Red and Blue in a specific ratio.
Because of how this math works, multiplying these codes is like adding the actual positions. This makes the math incredibly easy to manipulate.

3. The Puzzle Solver (Factorization)

Here is the core trick. The robot needs to figure out: "What combination of joint angles creates this specific 'purple' target color?"

In traditional math, this is a hard puzzle. In this paper's system, it's treated like a knapsack problem or a mixing puzzle.

The target point is a "mixture" (a product) of the three arm segments' angles.
The system uses a "puzzle solver" (either a Resonator Network or a Hopfield Network) to break that mixture apart.
The Analogy: Imagine you have a smoothie (the target point) made of strawberries, bananas, and blueberries. You don't know the recipe. The puzzle solver tastes the smoothie and tries to separate it back into the three distinct fruits.
Once the solver separates the "smoothie" back into the three "fruits" (the specific angles for each joint), it hands those angles to the respective specialists.

4. The Journey (Path Planning)

Once a specialist receives its target angle (e.g., "Turn to 45 degrees"), it doesn't just teleport there.

The CML acts like a GPS navigator. It knows all the possible steps to get from its current angle to the target angle.
It plots a path step-by-step, moving the joint smoothly until it reaches the destination.
Since all three specialists do this at the same time, the whole arm moves in harmony to the target.

Why is this a big deal?

No Re-training: If you want to change the robot's job or add a new joint, you don't have to re-teach the whole system. You just plug in a new specialist.
No "Singularity" Failures: Traditional math sometimes gets stuck when the arm is in a weird position (like when the arm is fully straight and can't move). This system is flexible; if it can't find a perfect answer immediately, it just relaxes its rules slightly and tries again until it finds a solution.
Scalability: This method works for a 2D arm, a 3D arm, and the authors suggest it could even control a quadruped robot (a four-legged robot). Instead of one giant brain controlling four legs, you'd have 12 specialists (3 per leg) working together.

Summary

Think of this system as a conductor leading an orchestra of independent musicians.

The Target is the song they need to play.
The Hypervectors are the sheet music written in a universal language.
The Factorization is the conductor figuring out which notes each musician needs to play to create that song.
The CMLs are the musicians who know exactly how to move their fingers to hit those notes.

They don't need to know the whole song; they just need to know their part. And because they speak the same language, they can be swapped, added, or rearranged to play any song the robot needs to perform.

1. Problem Statement

Traditional Deep Neural Networks (DNNs) are typically monolithic, meaning they are trained as single units for specific tasks. This architecture limits composability: it is difficult to combine pre-trained modules to solve new, complex problems without extensive retraining or fine-tuning. Furthermore, standard robotic control often relies on Inverse Kinematics (IK) equations, which can be computationally expensive, suffer from singularity failures, and require explicit mathematical derivation for every new robot configuration.

The authors aim to develop a composable machine learning framework where independently trained modules can be arbitrarily combined to control a multi-jointed robot arm. The goal is to move a robot arm to a target point in 2D or 3D space without using traditional inverse kinematic equations, leveraging Hyperdimensional Computing (HDC) and Cognitive Map Learners (CMLs).

2. Methodology

The proposed solution integrates three core concepts: Cognitive Map Learners (CMLs), Hyperdimensional Computing (HDC), and Fractional Power Encoding (FPE).

A. Cognitive Map Learners (CMLs)

Structure: A CML is a collection of three single-layer neural networks (matrices) representing:
1. Node States ( $S$ ): Representations of discrete states (e.g., specific joint angles).
2. Edge Actions ( $A$ ): Transitions between states.
3. Gating ( $G$ ): Availability of actions from specific states.
Function: Instead of being explicitly trained for path planning, CMLs iteratively calculate the "utility" of edge actions to move from a current state ( $s_t$ ) to a desired state ( $s_d$ ). They use a winner-take-all algorithm to select the most useful legal transition, effectively performing path planning similar to A* or Dijkstra but without explicit graph search training.
Composition: In this work, one CML is assigned to each arm segment. Each CML operates independently on its specific joint angle but shares a common communication protocol (HDC vectors).

B. Hyperdimensional Computing & Fractional Power Encoding (FPE)

Representation: Robot states and target points are encoded as high-dimensional phasor hypervectors (complex vectors with unit amplitude).
FPE: A target point $(a, b)$ in Cartesian space is encoded as $p = x^a \odot y^b$ , where $x$ and $y$ are base vectors and $\odot$ denotes element-wise multiplication.
Key Property: Multiplication of phasors corresponds to the addition of their exponents. This allows the system to treat the problem of finding arm angles as a factorization problem: decomposing the target vector $p$ into a product of individual arm segment vectors ( $p \approx s_1 \odot s_2 \odot s_3$ ).

C. The Control Workflow

Target Encoding: The desired end-effector position is converted into a phasor hypervector using FPE.
Factorization (Inverse Kinematics via HDC): The system must "factorize" the target hypervector into the specific angle states of the individual arm segments. This is treated as a Knapsack/Subset Sum problem.
- Two methods are used for factorization:
  - Resonator Network: An iterative network that unbinds factors from the target vector using codebooks of valid angle states.
  - Modern Hopfield Network: A single-step (or few-step) energy-minimization approach to recover the pattern.
Path Planning: Once the target angle for each segment is recovered, it is fed as the "desired state" ( $s_d$ ) to the respective segment's CML.
Execution: Each CML independently plots a path from its current angle to the target angle. The segments move in parallel, repositioning the entire arm to the target.

D. 3D Extension

For 3D control (specifically a 3-segment arm with a rotating base), the authors handle non-commutative rotations by:

Converting the 3D target $(x, y, z)$ to spherical coordinates $(\rho, \theta, \phi)$ .
Using FPE to solve for the radial distance and elevation ( $\rho, \phi$ ) in a 2D plane.
Using a separate Circular CML (using circular coding rather than FPE) to handle the base rotation ( $\theta$ ), as rotations are not commutative.

3. Key Contributions

Composable Control Framework: Demonstrated a workflow where independent CML modules (one per joint) can be composed to control a complex robot without retraining the individual modules.
HDC-Based Inverse Kinematics: Reinterpreted the inverse kinematics problem as a hypervector factorization task solvable via Resonator or Hopfield networks, eliminating the need for explicit IK equations.
Fractional Power Encoding (FPE): Defined a method to encode Cartesian coordinates and arm angles into a shared representation space, enabling the mathematical decomposition of the target position.
Generalizability: Provided a general solution for 2D arms with arbitrary segments and a specific solution for 3D arms with a rotating base.

4. Results

The authors tested the system on a 3-segment robot arm in both unconstrained 2D and constrained 3D environments.

Coverage & Reachability:
- Using uniform angle states ( $m=29$ for all segments), the system covered 74.5% of a discretized grid.
- By using co-prime numbers of states ( $m=[19, 23, 29]$ ), coverage increased to 98.8% due to a more diffuse distribution of reachable points.
- In the constrained 3D case (avoiding floor collisions), the system maintained 99.4% coverage of the valid workspace.
Accuracy:
- Mean Displacement: The system achieved high precision.
  - Resonator Network: $\epsilon \approx 0.071$ (2D) and $0.082$ (3D).
  - Hopfield Network: $\epsilon \approx 0.061$ (2D) and $0.065$ (3D).
- A hypervector similarity threshold of $\theta \geq 0.99$ correlated well with a Euclidean displacement of $<0.1$ .
Convergence:
- The factorization algorithms required multiple initialization attempts (injecting random noise) to find a solution.
- The Resonator network found a solution on the first attempt ~14-15% of the time (mean ~15 attempts).
- The Hopfield network found a solution on the first attempt ~10-13% of the time (mean ~32 attempts).
- Both methods successfully found multiple valid arm configurations for the same target point.

5. Significance and Future Work

Robustness: Unlike traditional IK solvers, this framework avoids singularity failures by iteratively relaxing the similarity threshold until a solution is found.
Scalability: The approach is highly scalable. The authors propose extending this to quadruped robots by assigning 3 CMLs per leg (12 total), controlled by a central pattern generator, rather than training a monolithic network.
Hardware Potential: The use of phasor HDC operations is compatible with spiking neural networks on neuromorphic hardware (e.g., Intel Loihi), suggesting potential for low-power, edge-deployed robotic control.
Adaptability: Since CMLs can adapt to changes in state or action availability, the system is inherently suited for dynamic environments (e.g., obstacle avoidance) without retraining.

In conclusion, this paper presents a novel, mathematically distinct approach to robotic control that leverages the composability of CMLs and the algebraic properties of Hyperdimensional Computing to solve inverse kinematics efficiently and robustly.