A humanoid robot multi-joint coordination consistency governance method and system based on execution state causal chain bifurcation

Abstract

The application discloses a humanoid robot multi-joint collaborative consistency management method and system based on execution state causal chain bifurcation, and belongs to the technical field of robot motion control and collaborative management. The execution state of each motion unit is modeled by being divided into three layers of deterministic state, behavior state and disturbance state; a shadow execution environment for control domain isolation is built by using three deterministic constraints of instruction sequence locking, disturbance replay and execution trajectory sealing; a time state difference chain is evolved according to the difference between the real execution state and the shadow execution state, and the chain head is embedded to bridge the hash, so that the chain is continuous and cannot be changed; when a state conflict occurs, instead of covering and erasing, parallel branches are kept by using the ownership identifier, and a single-track execution context is built along the matching branch by using a pruning mask; finally, a multi-joint collaborative consistency engine is used to perform consistency checking and repair management across motion units. In this way, the execution result can be reproduced, and the state bifurcation can be traced.

Description

Technical Field

[0001] This invention belongs to the field of robot motion control and collaborative governance technology, specifically relating to a multi-joint collaborative consistency governance method and system for humanoid robots based on causal chain bifurcation of execution state. Background Technology

[0002] Humanoid robots consist of multiple motion units that work together to perform complex movements. These include bipedal walking mechanisms, bi-arm manipulators, and head, neck, and torso mechanisms. Each motion unit generates its own execution state during operation, including various state information such as joint angles, motion command sequences, joint scheduling paths, sensor sampling trajectories, and motion control scheduling interferences. Ensuring the consistency and reproducibility of this state information distributed across different motion units is one of the core technological challenges in building highly reliable humanoid robots. Humanoid robots consist of multiple motion units that work together to perform complex movements. These include bipedal walking mechanisms, bi-arm manipulators, and head, neck, and torso mechanisms. Each motion unit generates its own execution state during operation, including various state information such as joint angles, motion command sequences, joint scheduling paths, sensor sampling trajectories, and motion control scheduling interference. Ensuring that this state information, distributed across different motion units, remains consistent and reproducible is an essential aspect of building highly reliable humanoid robots. Existing multi-motion unit coordination consistency schemes can be roughly divided into three categories: one relies on data replica consistency control, using consensus protocols to ensure eventual consistency of state replicas on each unit; another relies on communication consistency control, using atomic broadcasts and globally ordered distribution to ensure consistent instruction sequence; and the third relies on state log synchronization, using synchronized replay of logs to align the states between motion units. However, these three categories all deal with the static state at the "data snapshot" level, while the truly troublesome dynamic state at the "execution process" level is basically ignored. The first type of problem is the lack of a unified governance framework for execution states. The system only performs consistency control on state replicas, communication, and log synchronization. There is no unified approach to how execution paths, scheduling behaviors, action command states, and execution contexts evolve. Each motion unit has different control and scheduling strategies and different sensor timings, resulting in completely mismatched execution trajectories. Once the state branches, it becomes impossible to trace back to the end. The second type of problem is that traditional state snapshots only contain static data. Checkpoint-based snapshot technology only stores joint angles and torques, and cannot record the sequence of motion commands, scheduling paths, sensor sampling trajectories, and changes in execution context. If a motion unit malfunctions and needs to be restored from a snapshot, the restored execution path is already far removed from the state before the malfunction, making it impossible to accurately replay the action at the command level. The third type of problem is the lack of deterministic constraints in shadow execution. Shadow execution involves running a copy of a task in parallel in an isolated environment to detect anomalies, and it has been used in robot safety analysis and fault tolerance. However, current shadow execution solutions lack three key constraints: instruction sequence locking, perturbation input replay, and execution trajectory archiving. Without these three, the deviation between the shadow execution results and the actual results cannot be quantitatively analyzed and verified. The fourth type of problem is that state conflicts do not preserve causality. When traditional consistency systems encounter state conflicts, they use write-after-over, forced merge, or eventual consistency synchronization, and the state evolution history and causal relationships before the conflict occur are directly discarded. Summary of the Invention

[0003] There are several intractable problems in the collaborative governance of multiple motion units in existing humanoid robots: state forks cannot be traced to the end, execution results cannot be reproduced, shadow execution cannot be verified, and the source of branches cannot be traced back to the root. Based on these points, this invention provides a multi-joint collaborative consistency governance method and system capable of unified governance of execution states across motion units, preserving both execution semantics and state causality. The method includes: hierarchical modeling of the execution states of each motion unit in the ontology, classifying execution states into three categories: deterministic states, behavioral states, and perturbation states; constructing a shadow execution environment based on control domain isolation, locking the action instruction execution sequence by modifying the motion control scheduler, and replaying the time offset of the perturbation state using a high-precision timer to generate a shadow execution result semantically consistent with the real execution result; constructing a temporal difference chain based on the evolution of the difference between the real execution state and the shadow execution state, embedding a bridging hash at the head of the difference chain to maintain its continuity; rejecting the overwrite erasure strategy when multi-motion unit state conflicts are detected, retaining multiple parallel state branch nodes under a unified state root; when constructing the execution context, using the target object's verification identifier as a directed acyclic graph pruning mask operator, performing exclusive branch pruning, and constructing a single-track execution context only along the temporal difference chain of the matching branch; and the multi-joint collaborative consistency engine performing consistency verification and repair governance of the execution state across motion units. This invention also provides a humanoid robot multi-joint collaborative consistency governance system based on execution state causal chain forking, including a state hierarchical modeling module, a shadow execution reproduction module, a temporal difference chain management module, a state causal forking management module, an exclusive branch pruning module, and a collaborative consistency governance module. The execution state is split into three layers, which clearly defines the reproducible boundaries for each state component: shadow execution only reproduces the behavioral state and replays the perturbed state, without cloning all state components completely, thus saving the resource overhead of the shadow execution environment. Bridge hashing links the chains of temporal differences, and with freeze verification, the chains are neither modified nor lost, and broken chains are easily detected. Parallel branches under the unified state root are preserved, and the causal evolution relationship before the conflict is not lost. The pruning mask is tied to the verification identifier, and when constructing the execution context, the global search is reduced to traversing only a single chain along the matching branch, so that even with many branches, the construction is not slowed down. Attached Figure Description

[0004] Figure 1 This is a schematic diagram of the execution state layering model in an embodiment of the present invention.

[0005] Figure 2 This is a schematic diagram of the overall system architecture and data flow in an embodiment of the present invention.

[0006] Figure 3 This is a schematic diagram of the bridging hash continuity verification and state causal fork retention process in an embodiment of the present invention.

[0007] Figure 4 This is a schematic diagram of the multi-joint collaborative consistency engine architecture in an embodiment of the present invention. The meanings of the markings in the diagram are as follows: Figure 1 : 101-Deterministic state layer, 102-Behavioral state layer, 103-Disturbance state layer, 104-Joint angle and torque state, 105-Action command sequence, 106-Motion control scheduling jitter; Figure 2 201 - Real Execution Environment, 202 - Shadow Execution Environment, 203 - Control Domain Isolation, 204 - Instruction Sequence Locking, 205 - Perturbation Input Replay, 206 - Execution Trajectory Sealing, 207 - Deterministic State, 208 - Behavioral State, 209 - Perturbation State, 210 - Temporal Difference Chain Construction, 211 - Bridged Hash Embedding, 212 - Unified State Root, 213 - Parallel State Branch Node, 214 - Directed Acyclic Graph Causal Reference, 215 - Exclusive Branch Pruning, 216 - Single-Track Execution Context Construction, 217 - Fast Path Verification, 218 - Deep Path Verification; Figure 3301 - Initialization of the time-state difference chain; 302 - Generation of difference nodes; 303 - Calculation of the current window bridging hash; 304 - Embedding the bridging hash in the chain head; 305 - Committing the difference node; 306 - Difference chain freeze operation; 307 - Bridging continuity verification; 308 - Verification pass determination (diamond judgment box); 309 - Difference chain recovery; 310 - Conflict state detection; 311 - State conflict determination (diamond judgment box); 312 - Maintenance of unified state root; 313 - Creation of parallel state branch nodes; 314 - Establishment of causal references in directed acyclic graph; 315 - Assignment of ownership identifier; 316 - Pruning of exclusive branches; 317 - Construction of single-track execution context. Figure 4 401-Fast Verification Path, 402-Deep Verification Path, 403-State Snapshot Verification, 404-Fast Difference Filtering, 405-Fast Verification Pass Decision (Diamond Decision Box), 406-Deep Analysis of State Differences, 407-Shadow Execution Reproduction, 408-Behavioral Consistency Analysis, 409-Deep Verification of Difference Chain, 410-Repair Decision, 411-State Replay and Difference Merging, 412-State Freeze and Continuity Restoration, 413-Cross-Motion Unit Consistency Maintenance Module, 414-First Motion Unit State, 415-Second Motion Unit State. Detailed Implementation

[0008] Let's go through the implementation process with reference to the attached diagram. It's important to clarify here that shadow execution doesn't simply run the actual execution again; instead, it only simulates the parts that need to be verified. This approach applies to all subsequent steps. First, perform layered modeling of the execution state, corresponding to Figure 1 The execution state is divided into three levels: the deterministic state level (marked 101) contains state components that can be deterministically recorded and accurately reproduced, such as joint angle and torque states (marked 104); the behavioral state level (marked 102) contains components describing the behavioral trajectory of the motion unit, such as action command sequences (marked 105); and the disturbance state level (marked 103) contains components from the external environment that the motion unit cannot control, such as motion control scheduling jitter (marked 106). Figure 1 As shown in markings 101 to 106. These three layers each have a different function: the deterministic state is the foundation that can be fully reproduced; the behavioral state is the behavioral trajectory that needs to be locked and reproduced; and the perturbation state is to be replayed with the input parameters, rather than reproduced. With this breakdown, the reproducible boundary becomes clear, and the state space that shadow execution really needs to fully simulate is reduced to just the behavioral state layer, thus reducing the complexity and resource overhead of building the shadow execution environment. After completing the layered modeling, the next step is to build a deterministic shadow reproduction mechanism, corresponding to... Figure 2The system creates a shadow execution environment (labeled 202) based on control domain isolation (labeled 203) within the real execution environment (labeled 201). Control domain isolation (labeled 203) provides the shadow motion unit with an independent control domain instance, giving it its own independent motion state view and instruction sequence context, while sharing read-only motion planning data with the real motion unit, saving some overhead. Three constraint operations are performed in the shadow execution environment. Instruction sequence locking (marked 204): The motion control scheduler is modified to inject instruction sequence counters into the shadow motion units. Each time a shadow unit executes an action instruction, it compares its execution sequence with the recorded real execution sequence. If a sequence deviation is detected, execution trajectory rollback is immediately triggered. Disturbance input replay (marked 205): A high-precision timer is used to replay the time offsets recorded in the disturbance state layer with microsecond-level precision. Execution trajectory archiving (marked 206): A hash calculation is performed on the complete execution path generated during shadow execution. The path hash value is bound to the bridging hash of the current time window to generate an execution trajectory index, which is then stored on disk in the state metadata storage. These three constraints apply to deterministic states (marked 207), behavioral states (marked 208), and disturbance states (marked 209), respectively, ensuring their complete reproduction in the shadow environment. Figure 2 As shown in markings 201 to 218. Having established both the real and shadow execution states, we proceed to construct a temporal difference chain, mathematically recording the evolution and deviations between the two states, corresponding to... Figure 3 The difference chain initialization (marked 301) starts the chain up. The difference node (marked 302) records the state difference for each time window. The current window bridging hash (marked 303) calculates a one-way hash by combining the state difference with the time window and the random number. The chain head embedding bridging hash (marked 304) embeds the bridging hash value into the chain head for continuity proof. The time-state difference chain is defined as Δ(t) = S_real(t) - S_shadow(t), and the complete structure is Δ_chain = [BH_0, Δ_1, Δ_2, ..., Δ_n]. The bridging hash BH_t on the chain is generated according to BH_t = H(State_t,TimeWindow_t, Nonce_t) using a one-way hash algorithm. The time-state difference chain construction (marked 210) and bridging hash embedding (marked 211) are sequentially appended to the state components. The difference node commit (marked 305) persists the difference node to the difference chain storage; the bridging continuity check (marked 307) verifies the consistency between the bridging hash and the time window of each node on the chain. If the check passes, a decision is made (marked 308); otherwise, the difference chain recovery is triggered (marked 309). If successful, it proceeds to the freeze and commit phase; the difference chain freeze operation (marked 306) records the freeze flag during freezing. There are four types of anomalies in the bridging hash continuity check: bridging hash mismatch, difference chain break, time window conflict, and invalid state reference. The complete lifecycle of the difference chain consists of five stages: generation, verification, commit, freeze, and recovery. Figure 3 As shown in markings 301 to 317. Once the multi-joint collaborative consistency engine detects a state conflict across motion units, it performs state causal fork preservation instead of the traditional overwrite merging. Figure 2 and Figure 3 Conflict state detection (marked 310) initiates state conflict determination (marked 311). The system maintains a unified state root (marked 212, which is continuously tracked by the unified state root). When the conflict detection determination (marked 311) confirms the existence of a conflict, parallel state branch nodes are created under the unified state root (marked 212) (marked 213, which is implemented by creating parallel state branch nodes). Each parallel branch node maintains its independent directed acyclic graph relationship through directed acyclic graph causal references (marked 214, which is implemented by establishing directed acyclic graph causal references). Each state branch node is assigned a home identifier (marked 315). Nodes directly generated by the local motion unit are marked with the first home identifier; those relayed from the third motion unit or from a non-local motion unit are marked with the second home identifier. The system allows branches with different home identifiers to evolve in parallel and be independently addressed over a long period at three levels: the motion control layer, the state storage layer, and the execution context layer. At the step of building the single-track execution context, exclusive branch pruning is performed (marked 215), corresponding to Figure 2 Mark 316. First, obtain the verification identifier of the target object to be constructed as the directed acyclic graph pruning mask operator: if the verification identifier matches the first attribution identifier, suspend all branches with the second attribution identifier and only follow the temporal difference chain of the branch with the first attribution identifier; after pruning, apply the state difference summary of the difference nodes one by one along the difference chain of the matching branches to reconstruct the execution context of the target object, thus completing the single-track execution context construction (marked 216, corresponding to mark 317). Then, proceed to the fast verification path (marked 217) to perform fast path state verification, and when unsure, switch to the deep verification path (marked 218) to perform deep path verification. The consistency verification and repair governance across motion units are completed by the multi-joint collaborative consistency engine using a dual-path architecture, corresponding to... Figure 4 The fast verification path (marked 401) concludes with state snapshot verification (marked 403) and rapid difference filtering (marked 404). Once the fast verification passes the judgment (marked 405), it is handed over to the cross-motion unit consistency maintenance module (marked 413) for coordination. The deep verification path (marked 402) handles abnormal scenarios where the fast verification fails, using state difference deep analysis (marked 406), shadow execution reproduction (marked 407), behavior consistency analysis (marked 408), and difference chain deep verification (marked 409) to complete the verification process. The repair judgment (marked 410) triggers state replay and difference merging (marked 411), state freezing and continuity restoration (marked 412) as needed for repair. The cross-motion unit consistency maintenance module (marked 413) coordinates the state synchronization between multiple motion units, using a push-pull message pattern to schedule the state evolution of the first motion unit state (marked 414) and the second motion unit state (marked 415). Figure 4 As shown in markings 401 to 415. Through the verification of this embodiment, the effectiveness of this scheme is reflected in several aspects: hierarchical modeling of execution state reduces the resource overhead of the shadow execution environment; bridging hashing makes it almost instantly possible to find broken difference chains; parallel state causal forking preserves the causal evolution relationship of conflicting branches; after exclusive branch pruning, the context construction time is basically decoupled from the total number of branches. The above description is only a preferred embodiment of the present invention.

Claims

1. A method for managing the collaborative consistency of multi-joint humanoid robots based on causal chain bifurcation of execution states, characterized in that, include: The execution states of each motion unit of the body are modeled hierarchically, and the execution states are divided into three categories: deterministic states, behavioral states, and disturbance states. The deterministic states include joint angle and torque states, as well as structured motion parameters and body mapping states. The behavioral states include motion command sequences and joint scheduling paths, as well as sensor sampling trajectories and motion execution transaction behaviors. The disturbance states include motion control scheduling jitter and time window drift, as well as communication delay offset and motion command loss behaviors. A shadow execution environment based on control domain isolation is constructed. By modifying the motion control scheduler to lock the action instruction execution sequence, a high-precision timer is used to replay the time offset of the disturbance state. In the shadow execution environment, a shadow execution result with semantics consistent with the real execution result is generated. The execution path is hashed, and the execution path hash value is bound to the bridge hash to generate an execution trajectory index for verifying the integrity of the execution path when the state is restored. A temporal difference chain is constructed based on the evolution of the difference between the actual execution state and the shadow execution state. The mathematical structure of the temporal difference chain satisfies Δ_chain = [BH_0, Δ_1, Δ_2, ..., Δ_n], where BH_0 is the initial bridging hash, Δ_n = (TW_n, EP_n, SD_n, BH_{n-1}, SO_n) is the nth difference node, TW_n is the time window identifier, EP_n is the execution path identifier, SD_n is the state difference digest, BH_{n-1} is the preceding bridging hash reference, and SO_n is the state source identifier. A bridging hash is embedded at the head of the temporal difference chain to maintain the continuity of the difference chain. The bridging hash is generated according to BH_t = H(State_t, TimeWindow_t, Nonce_t), where H is the cryptographic hash function, State_t is the execution state snapshot data corresponding to the tth time window, and TimeWindow_t is the execution state snapshot data corresponding to the tth time window. The time window identifier and Nonce_t are the random numbers corresponding to the t-th time window. The anomaly detection conditions of the bridge hash include bridge hash mismatch, broken time state difference chain, time window conflict, and invalid state reference. When a multi-motion unit state conflict is detected, the overwrite erasure strategy is rejected. Multiple parallel state branch nodes are retained under a unified state root. Each parallel state branch node maintains an independent directed acyclic graph causal reference relationship. Before compliance verification by the multi-joint collaborative consistency engine, forced overwrite operations are prohibited on any of the parallel state branch nodes. Each state branch node is assigned an ownership identifier. The local motion unit generator is marked as the first ownership identifier, and the one derived from the third motion unit or a non-local motion unit is marked as the second ownership identifier. The long-term parallel evolution and independent addressing of the state branches corresponding to the two ownership identifiers are maintained in the motion control layer, state storage layer, and execution context layer. When constructing the execution context, the verification identifier of the target object is used as the directed acyclic graph pruning mask operator to perform exclusive branch pruning: if the verification identifier matches the first attribution identifier, all state branches carrying the second attribution identifier are suspended, and only the temporal difference chain corresponding to the state branch carrying the first attribution identifier is traversed to construct a single-track execution context; if the verification identifier matches the second attribution identifier, all state branches carrying the first attribution identifier are suspended, and only the temporal difference chain corresponding to the state branch carrying the second attribution identifier is traversed to construct a single-track execution context, and the state difference summary is applied to each difference node of the matching branch to reconstruct the execution context; The multi-joint collaborative consistency engine performs consistency checks on the execution state across motion units according to the consistency model S_i ≈ S_j ± ε, where S_i is the execution state of the i-th motion unit, S_j is the execution state of the j-th motion unit, and ε is the state deviation threshold corresponding to the allowable perturbation time window. When the consistency deviation exceeds the deviation threshold corresponding to the allowable perturbation time window, it triggers state repair governance, which includes at least one repair operation among state replay, difference merging, shadow reconstruction, state freezing, and continuity recovery.

2. A humanoid robot multi-joint collaborative consistency governance system based on execution state causal chain bifurcation, characterized in that, include: The state hierarchical modeling module is used to perform hierarchical modeling of the execution states of each motion unit of the body. The execution states are divided into three categories: deterministic states, behavioral states, and disturbance states. The deterministic states include joint angle and torque states, the behavioral states include motion command sequences and joint scheduling paths, and the disturbance states include motion control scheduling jitter and time window drift. The shadow execution reproduction module is used to construct a shadow execution environment based on control domain isolation. By modifying the motion control scheduler to lock the action instruction execution sequence, it uses a high-precision timer to replay the time offset of the disturbance state and generates a shadow execution result in the shadow execution environment that is semantically consistent with the real execution result. The temporal difference chain management module is used to construct a temporal difference chain based on the difference evolution between the actual execution state and the shadow execution state, and to embed a bridging hash at the head of the temporal difference chain to maintain the continuity of the difference chain; The state causal branching management module is used to reject the overwrite erasure strategy when multiple motion unit state conflicts are detected, and retain multiple parallel state branch nodes under a unified state root. Each of the parallel state branch nodes maintains an independent directed acyclic graph causal reference relationship. The exclusive branch pruning module is used to perform exclusive branch pruning when constructing the execution context, using the verification identifier of the target object as the directed acyclic graph pruning mask operator, suspending the state branches where the verification identifiers do not match, and constructing a single-track execution context only along the temporal difference chain of the state branches where the verification identifiers match. The collaborative consistency governance module is used to perform consistency checks on the execution state across motion units, and to trigger state repair governance when the consistency deviation exceeds the deviation threshold corresponding to the allowable disturbance time window.

Images