Primary source, and the demonstration's only reference — the Classiq notebook cites this paper and nothing else. Read in full text rather than in abstract. It supplies the Bloch-sphere encoding of a link's posture, the forward-kinematics circuit, the COBYLA loop that closes inverse kinematics around it, and the RXX/RYY/RZZ construction that entangles a parent link's qubit with its child's. It reports a Fujitsu 40-qubit mpiQulacs simulation and a run on the 64-qubit superconducting machine of the RIKEN RQC-Fujitsu Collaboration Center. Consult it for the D-H parameters of the model arm in its Table 1, for the per-axis figures in Tables 3 and 4, and for the derivation relating the RXX rotation angle to concurrence — and note that it states no complexity bound and no comparison against a production inverse-kinematics solver.
doi.org/10.1038/s41598-025-12109-0 ↗Quantum computation for robot posture optimization
Given a target position for a robot manipulator's end effector, find joint angles that reach it — the inverse kinematics problem, which has no analytical solution for a general 6-degree-of-freedom arm and admits many joint configurations at once for a redundant one.
Atlas stars stay in the public catalog. Saving this entry to your workspace starts an unstarred private copy.
Given a target position for a robot manipulator's end effector, find joint angles that reach it — the inverse kinematics problem, which has no analytical solution for a general 6-degree-of-freedom arm and admits many joint configurations at once for a redundant one. The method turns a qubit into a link. A qubit's state is a point on the Bloch sphere, so one qubit can carry the posture of one robot link: applying RX, RY and RZ rotation gates orients it, and the expectation values measured along X, Y and Z are coordinates on that sphere, which a classical computer multiplies by the link's length and sums to give the end-effector position. That is forward kinematics on a quantum circuit. Inverse kinematics is then a loop around it: the circuit computes the end-effector position for a set of joint angles, the difference from the target is evaluated classically, and COBYLA adjusts the angles until the difference falls below a threshold. The paper's second contribution is to replace independent per-qubit rotations with the two-qubit RXX, RYY and RZZ gates, which entangle the qubit for a parent link with the qubit for its child. The authors argue this represents the physical fact that rotating a parent link moves the child, and report that it converges in fewer iterations and to a better solution. On their two-joint six-degree-of-freedom model they report that after 30 iterations the total error was about 1.85 m without entanglement and 1.18 m with it, which they describe as a 36% reduction in overall positional error, and that the entangled circuit reached nearly the same accuracy in 10 iterations (1.17 m) as in 30 (1.21 m) — from which they infer that entanglement contributes most strongly to the early phase of the optimisation. Repeating the comparison on a 64-qubit superconducting machine, they report the total error after 30 iterations falling from about 1.84 m to 1.04 m, which they call a roughly 43% improvement, and note that hardware accuracy is below the simulation's because of noise. Because the posture of a link costs exactly one qubit, they state that a three-link manipulator needs three qubits and a sixteen-link humanoid sixteen, which they call well within present-day hardware.
Circuit & simulation
What this takes and returns
TakesNothingWhat joins here
No input port at this edge: the record publishes no gate sequence and no register, so there is nothing here to read one off — and unlike a declared hole, nothing has been recorded about what belongs here.
Nothing in the Atlas meets this end.
ReturnsNothingWhat joins here
No output port at this edge: the record publishes no gate sequence and no register, so there is nothing here to read one off — and unlike a declared hole, nothing has been recorded about what belongs here.
Nothing in the Atlas meets this end.
This record publishes no gate sequence and no register, so there is nothing here to read an interface off. Absent rather than empty. See all 152 →
How it works
The method turns a qubit into a link. A qubit's state is a point on the Bloch sphere, so one qubit can carry the posture of one robot link: applying RX, RY and RZ rotation gates orients it, and the expectation values measured along X, Y and Z are coordinates on that sphere, which a classical computer multiplies by the link's length and sums to give the end-effector position. That is forward kinematics on a quantum circuit. Inverse kinematics is then a loop around it: the circuit computes the end-effector position for a set of joint angles, the difference from the target is evaluated classically, and COBYLA adjusts the angles until the difference falls below a threshold. The paper's second contribution is to replace independent per-qubit rotations with the two-qubit RXX, RYY and RZZ gates, which entangle the qubit for a parent link with the qubit for its child. The authors argue this represents the physical fact that rotating a parent link moves the child, and report that it converges in fewer iterations and to a better solution. On their two-joint six-degree-of-freedom model they report that after 30 iterations the total error was about 1.85 m without entanglement and 1.18 m with it, which they describe as a 36% reduction in overall positional error, and that the entangled circuit reached nearly the same accuracy in 10 iterations (1.17 m) as in 30 (1.21 m) — from which they infer that entanglement contributes most strongly to the early phase of the optimisation. Repeating the comparison on a 64-qubit superconducting machine, they report the total error after 30 iterations falling from about 1.84 m to 1.04 m, which they call a roughly 43% improvement, and note that hardware accuracy is below the simulation's because of noise. Because the posture of a link costs exactly one qubit, they state that a three-link manipulator needs three qubits and a sixteen-link humanoid sixteen, which they call well within present-day hardware. The Classiq library carries this subject under applications · optimization. The sources read state no complexity bound for this record (The full text of doi:10.1038/s41598-025-12109-0 was read for this record — the publisher PDF the owner supplied, not an abstract — and it states no complexity bound of any kind: no asymptotic scaling in the number of links or degrees of freedom, no gate or query count, no iteration bound, and no comparison of running time against a classical inverse- kinematics solver. What it reports instead are measured iteration counts and positional errors for one two-joint six-degree-of-freedom arm, which are quoted in this record's explanation and bounded by its caveat. The paper's only resource statement is a qubit count: one qubit per link, so three qubits for a three-link manipulator and sixteen for a sixteen-link humanoid. The Classiq index entry this record covers gives the directory path applications/optimization/robust_posture_optimization and two file names, and states no bound.).
Implementation
ALGORITHM: Quantum computation for robot posture optimization
PROBLEM: Given a target position for a robot manipulator's end effector, find joint angles that reach it — the inverse kinematics problem, which has no analytical solution for a general 6-degree-of-freedom arm and admits many joint configurations at once for a redundant one.
IDEA: The method turns a qubit into a link. A qubit's state is a point on the Bloch sphere, so one qubit can carry the posture of one robot link: applying RX, RY and RZ rotation gates orients it, and the expectation values measured along X, Y and Z are coordinates on that sphere, which a classical computer multiplies by the link's length and sums to give the end-effector position. That is forward kinematics on a quantum circuit. Inverse kinematics is then a loop around it: the circuit computes the end-effector position for a set of joint angles, the difference from the target is evaluated classically, and COBYLA adjusts the angles until the difference falls below a threshold. The paper's second contribution is to replace independent per-qubit rotations with the two-qubit RXX, RYY and RZZ gates, which entangle the qubit for a parent link with the qubit for its child. The authors argue this represents the physical fact that rotating a parent link moves the child, and report that it converges in fewer iterations and to a better solution. On their two-joint six-degree-of-freedom model they report that after 30 iterations the total error was about 1.85 m without entanglement and 1.18 m with it, which they describe as a 36% reduction in overall positional error, and that the entangled circuit reached nearly the same accuracy in 10 iterations (1.17 m) as in 30 (1.21 m) — from which they infer that entanglement contributes most strongly to the early phase of the optimisation. Repeating the comparison on a 64-qubit superconducting machine, they report the total error after 30 iterations falling from about 1.84 m to 1.04 m, which they call a roughly 43% improvement, and note that hardware accuracy is below the simulation's because of noise. Because the posture of a link costs exactly one qubit, they state that a three-link manipulator needs three qubits and a sixteen-link humanoid sixteen, which they call well within present-day hardware.
REPORTED COST: Not stated by the sources read
BASIS: The full text of doi:10.1038/s41598-025-12109-0 was read for this record — the publisher PDF the owner supplied, not an abstract — and it states no complexity bound of any kind: no asymptotic scaling in the number of links or degrees of freedom, no gate or query count, no iteration bound, and no comparison of running time against a classical inverse- kinematics solver. What it reports instead are measured iteration counts and positional errors for one two-joint six-degree-of-freedom arm, which are quoted in this record's explanation and bounded by its caveat. The paper's only resource statement is a qubit count: one qubit per link, so three qubits for a three-link manipulator and sixteen for a sixteen-link humanoid. The Classiq index entry this record covers gives the directory path applications/optimization/robust_posture_optimization and two file names, and states no bound.
DEMONSTRATED BY: the Classiq library entry applications/optimization/robust_posture_optimization
PRIMARY SOURCE: Takuya Otani, Atsuo Takanishi, Nobuyuki Hara, Yutaka Takita, Koichi Kimura (2025), Quantum computation for robot posture optimization — https://doi.org/10.1038/s41598-025-12109-0
This is a literature reference record, not an executable circuit.A reference record, not runnable source. Leona cannot execute it, so it cannot be saved to your Library as a circuit.
Quantum vs classical
Classical baseline
Compare Optimization · variational kinematics with the strongest classical method for the same instance, input budget, and output metric.
Quantum claim
This reference exposes a quantum circuit pattern; it does not imply an application-level speedup without a matched benchmark.
How to compare
Report input loading, circuit depth, repetitions, classical preprocessing, post-processing, and wall-clock time together.
Declared gaps
Nobody has reviewed this record for gaps yet.