A system lifecycle management method and system based on MBSE

Abstract

This invention provides a system and method for full lifecycle management based on MBSE, relating to the field of data synchronization technology. The method includes acquiring data to be synchronized from the source system and constructing a semantic graph structure; generating a mapping strategy based on implicit associations between systems using semantic matching; executing transactional data transmission; constructing a temporal source tree to track change propagation; and adaptively reconstructing when constraint conflicts are detected. This invention solves the data synchronization problem between heterogeneous systems, improving model consistency maintenance capabilities and adaptive conflict handling efficiency.

Description

Technical Field

[0001] This invention relates to data synchronization technology, and more particularly to a system and method for full lifecycle management based on MBSE. Background Technology

[0002] With the accelerated advancement of industrial digital transformation, model-based systems engineering (MBSE) has become a key methodology for the R&D and lifecycle management of modern complex systems. MBSE replaces the traditional document-driven approach with digital models, achieving integrated management of system requirements, architecture, behavior, and verification. In current engineering practice, enterprises often deploy multiple professional tools and system platforms, which are typically independently developed and run, each maintaining specialized data in different domains. System lifecycle management requires seamless data flow and synchronization between these heterogeneous systems to ensure collaboration and consistency across stages and disciplines. Traditional data synchronization methods primarily rely on predefined static mapping rules or point-to-point customized integration via API interfaces, which requires significant manual configuration and maintenance.

[0003] Lacking a deep understanding of data semantics, most synchronization mechanisms rely solely on field matching or simple format conversion, failing to grasp the inherent semantic relationships between data in different systems and struggling to handle implicit relationships and context-dependent business rules. Data integrity is difficult to guarantee during synchronization; when complex object dependencies exist, synchronization operations may lead to data inconsistencies or violate data integrity constraints, especially in distributed environments where transactional guarantees are difficult to achieve. Furthermore, the lack of dynamic analysis and adaptive handling capabilities for change impacts means existing systems cannot effectively identify and handle change propagation paths after data changes, nor can they automatically adjust synchronization strategies based on constraint conflicts discovered at runtime. This leads to the gradual accumulation of data inconsistencies between systems, ultimately affecting the overall system reliability.

[0004] With the increasing complexity of systems and the growing demand for cross-domain collaboration, there is an urgent need for a full lifecycle data management method that can understand data semantics, ensure data integrity, and adaptively handle change conflicts to support the development of modern complex systems based on MBSE. Summary of the Invention

[0005] This invention provides a system and method for full lifecycle management based on MBSE, which can solve the problems in the prior art.

[0006] A first aspect of this invention provides a system lifecycle management method based on MBSE, comprising:

[0007] Obtain the data objects to be synchronized, change event identifiers, and business context information from the source system; perform semantic analysis on the data objects to be synchronized; extract the entity types, attribute features, and inter-object dependencies of the data objects to be synchronized; and construct a semantic graph structure in conjunction with the business context information.

[0008] Based on the semantic graph structure, the data models of the source system and the target system are analyzed. The implicit association between the source system and the target system is learned through semantic matching. Based on the dependency relationship between the objects, a mapping strategy that considers data integrity constraints is dynamically generated.

[0009] The execution order of synchronization operations is determined according to the mapping strategy. When a dependency relationship is detected between objects, multiple related data objects are organized into an atomic synchronization transaction, and transactional data transmission is performed to the target system according to the data flow path in the semantic graph structure.

[0010] During the synchronization process, a temporal tracing tree is constructed, and the synchronization result is obtained from the target system. The synchronization result is associated with the corresponding node of the temporal tracing tree, and the change propagation range is calculated. Based on the business constraint rules in the semantic graph structure, the nodes within the change propagation range are dynamically deduced. When a constraint conflict is detected, the change path of the temporal tracing tree is traced back to the root cause of the conflict, and the mapping strategy is adaptively reconstructed based on the result of the dynamic deduction.

[0011] Based on the semantic graph structure analysis of the source system and target system data models, implicit associations between the source system and target system are learned through semantic matching, and mapping strategies considering data integrity constraints are dynamically generated according to the dependencies between objects, including:

[0012] Based on the entity type and attribute semantics in the semantic graph structure, semantic similarity is calculated between the data model nodes of the source system and the data model nodes of the target system to identify node pairs with equivalent semantics or inclusion relationships, thereby obtaining a semantic alignment candidate set.

[0013] By aggregating the neighborhood features of node pairs in the semantic alignment candidate set on the semantic graph structure through graph convolution propagation mechanism, the implicit association pattern between the source system and the target system across explicit attribute mapping is learned, and an implicit association representation is obtained.

[0014] Based on cross-entity dependencies in semantic data representation, a dependency propagation path is constructed between the data object to be synchronized and its associated data objects, and the set of data objects that need to maintain integrity is determined according to the dependency propagation path.

[0015] Based on the implicit association representation and the set of data objects, a mapping strategy containing a mapping priority sequence and integrity constraint verification rules is generated.

[0016] By aggregating neighborhood features of node pairs in the semantic alignment candidate set on the semantic graph structure through graph convolution propagation mechanism, implicit association patterns across explicit attribute mappings between the source system and the target system are learned, resulting in implicit association representations including:

[0017] For each node pair in the semantic alignment candidate set, the initial feature vectors of the data model nodes of the source system and the data model nodes of the target system in the semantic graph structure are extracted;

[0018] Based on the initial feature vector, multi-hop neighborhood expansion is performed along the edges constructed along the cross-entity dependency relationship on the semantic graph structure. For each node pair, the feature vectors of the neighboring nodes in its multi-hop neighborhood are aggregated, and the influence weights of different neighboring nodes on the current node pair are calculated through the graph convolution propagation mechanism to obtain the neighborhood aggregation feature.

[0019] The data model node features of the source system and the data model node features of the target system in the neighborhood aggregation features are projected onto the shared semantic space. By minimizing the distance between semantically equivalent node pairs in the shared semantic space and maximizing the distance between semantically irrelevant node pairs, the neighborhood aggregation features are cross-domain aligned to obtain the aligned cross-domain feature representation.

[0020] Based on the aligned cross-domain feature representation, the semantic similarity between the data model nodes of the source system and the data model nodes of the target system is calculated in the shared semantic space. The structured association pattern that does not rely on explicit attribute name matching is identified, and the node correspondence in the structured association pattern is encoded into an implicit association representation.

[0021] The execution order of synchronization operations is determined according to the mapping strategy. When a dependency relationship is detected between objects, multiple related data objects are organized into an atomic synchronization transaction, and transactional data transmission is performed to the target system according to the data flow path in the semantic graph structure, including:

[0022] The priority information and constraint rules contained in the mapping strategy are parsed to obtain the execution order of the synchronization operations of the data objects to be synchronized, and the data objects to be synchronized are traversed according to the execution order to detect the dependency relationships between the data objects to be synchronized.

[0023] When a dependency relationship is detected between the data objects to be synchronized, multiple related data objects are identified, and the multiple related data objects are organized into an atomic synchronization transaction to construct a set of transaction data objects.

[0024] For the set of transactional data objects, the data flow path of each data object in the set of transactional data objects is obtained from the semantic graph structure. Based on the transmission route and transmission order identified in the data flow path, the transactional data transmission of the set of transactional data objects is executed to the target system.

[0025] During the execution of the transactional data transmission, the synchronization status of all data objects in the transactional data object set is monitored in real time. When the transmission of any data object in the transactional data object set fails, the synchronization operation of all data objects in the transactional data object set is rolled back according to the synchronization status.

[0026] During the synchronization process, a temporal tracing tree is constructed, synchronization results are obtained from the target system, the synchronization results are associated with the corresponding nodes of the temporal tracing tree, and the change propagation range is calculated. Dynamic deduction of nodes within the change propagation range based on business constraint rules in the semantic graph structure includes:

[0027] Construct a time-series tracing tree and record the change status and time-series information of the nodes. Obtain the synchronization result of the data object to be synchronized from the target system. Compare the final status information in the synchronization result with the change content of the corresponding node in the time-series tracing tree in multiple dimensions. Identify the set of nodes that have undergone status changes through the comparison results.

[0028] For each node in the node set, the temporal dependencies recorded in the temporal tracing tree are traced downstream, and the cross-entity dependencies in the semantic graph structure are combined to identify related entities, thus constructing a change propagation network that includes nodes that directly affect nodes and nodes that indirectly affect nodes.

[0029] Based on the business constraint rules in the semantic graph structure, the node states in the change propagation network are dynamically deduced. By verifying the degree of matching between the current state of the node and the constraint conditions, the constraint satisfaction of each node in the change propagation network is evaluated. Based on the connection strength, the impact range of constraint violation is calculated, and constraint verification results including violation levels are generated.

[0030] When a constraint conflict is detected, the change path of the time-series source tree is traced back to the root cause of the conflict, and the mapping strategy is adaptively reconstructed based on the results of the dynamic inference, including:

[0031] When a constraint conflict is detected, the conflict node where the constraint conflict occurs is located in the time-series tracing tree. Based on the change path information recorded in the time-series tracing tree, the conflict node is traced backward to identify the root cause node of the constraint conflict.

[0032] From the root node of the conflict to the conflict node, construct a mapping operation dependency graph on the change path, analyze the contribution of each mapping rule in the mapping operation dependency graph to the constraint conflict, and establish an influence weight model of the mapping rule.

[0033] The results of the dynamic simulation are analyzed, and the differences between the constraints and actual states of each node within the propagation range are modeled. Combined with the influence weight model of the mapping rules, the relevant mapping rules in the mapping strategy are adjusted in a targeted manner to generate a reconstruction mapping strategy that satisfies the constraints.

[0034] From the root node of the conflict to the conflict node, a mapping operation dependency graph is constructed on the change path. The contribution of each mapping rule in the mapping operation dependency graph to the constraint conflict is analyzed, and an influence weight model of the mapping rules is established, including:

[0035] A mapping operation dependency graph is constructed from the conflict root node to the conflict node, and the triggering conditions and execution effects of the mapping rule nodes are marked in the mapping operation dependency graph;

[0036] The effect of each dependency edge in the mapping operation dependency graph on the constraint conflict propagation process is analyzed, and the contribution of the dependency edge is calculated based on the effect. A weight matrix reflecting the distribution of the contribution of the dependency edge is constructed.

[0037] The influence of the mapping rule nodes in the mapping operation dependency graph is quantified according to the weight matrix, the degree of influence of each mapping rule node on constraint conflict is calculated, and the degree of influence is used as a weight factor to establish an influence weight model.

[0038] A second aspect of this invention provides a system lifecycle management system based on MBSE, comprising:

[0039] The first unit is used to obtain the data objects to be synchronized, change event identifiers and business context information in the source system, perform semantic analysis on the data objects to be synchronized, extract the entity type, attribute features and inter-object dependencies of the data objects to be synchronized, and construct a semantic graph structure in combination with the business context information.

[0040] The second unit is used to analyze the data models of the source system and the target system based on the semantic graph structure, learn the implicit association between the source system and the target system through semantic matching, and dynamically generate a mapping strategy that considers data integrity constraints based on the dependencies between the objects.

[0041] The third unit is used to determine the execution order of synchronization operations according to the mapping strategy. When a dependency relationship is detected between objects, it organizes multiple related data objects into an atomic synchronization transaction and performs transactional data transmission to the target system according to the data flow path in the semantic graph structure.

[0042] The fourth unit is used to construct a temporal tracing tree during the synchronization process, obtain the synchronization result from the target system, associate the synchronization result with the corresponding node of the temporal tracing tree and calculate the change propagation range, dynamically deduce the nodes within the change propagation range based on the business constraint rules in the semantic graph structure, and when a constraint conflict is detected, trace back to the root cause of the conflict along the change path of the temporal tracing tree, and adaptively reconstruct the mapping strategy based on the result of the dynamic deduction.

[0043] A third aspect of the present invention provides an electronic device, comprising:

[0044] processor;

[0045] Memory used to store processor-executable instructions;

[0046] The processor is configured to invoke instructions stored in the memory to execute the aforementioned method.

[0047] A fourth aspect of the present invention provides a computer-readable storage medium having stored thereon computer program instructions that, when executed by a processor, implement the aforementioned method.

[0048] The beneficial effects of this application are as follows:

[0049] This invention achieves intelligent data mapping between the source system and the target system by performing semantic analysis on the data objects to be synchronized and constructing a semantic graph structure. This effectively solves the integration difficulties caused by differences in data models between heterogeneous systems and improves the efficiency and accuracy of system integration.

[0050] This invention introduces a transactional data transmission mechanism and a time-series tracing tree, which ensures data consistency in the synchronization process of multiple objects with complex dependencies. It can monitor the synchronization status in real time and quickly locate the root cause of the problem when an anomaly occurs, significantly enhancing the reliability and stability of data exchange between systems.

[0051] This invention performs dynamic deduction based on business constraint rules in a semantic graph structure and can adaptively reconstruct the mapping strategy when constraint conflicts are detected, enabling the system to have self-correction and continuous optimization capabilities. It effectively supports the full lifecycle management of model-based system engineering, reduces maintenance costs, and improves system operating efficiency. Attached Figure Description

[0052] Figure 1 This is a flowchart illustrating the system lifecycle management method based on MBSE according to an embodiment of the present invention;

[0053] Figure 2 This is a flowchart of the system lifecycle management constraint conflict detection and analysis process based on MBSE in an embodiment of the present invention. Detailed Implementation

[0054] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0055] The technical solution of the present invention will be described in detail below with reference to specific embodiments. These specific embodiments can be combined with each other, and the same or similar concepts or processes may not be described again in some embodiments.

[0056] Figure 1 This is a flowchart illustrating the system lifecycle management method based on MBSE according to an embodiment of the present invention. Figure 1 As shown, the method includes:

[0057] Obtain the data objects to be synchronized, change event identifiers, and business context information from the source system; perform semantic analysis on the data objects to be synchronized; extract the entity types, attribute features, and inter-object dependencies of the data objects to be synchronized; and construct a semantic graph structure in conjunction with the business context information.

[0058] Based on the semantic graph structure, the data models of the source system and the target system are analyzed. The implicit association between the source system and the target system is learned through semantic matching. Based on the dependency relationship between the objects, a mapping strategy that considers data integrity constraints is dynamically generated.

[0059] The execution order of synchronization operations is determined according to the mapping strategy. When a dependency relationship is detected between objects, multiple related data objects are organized into an atomic synchronization transaction, and transactional data transmission is performed to the target system according to the data flow path in the semantic graph structure.

[0060] During the synchronization process, a temporal tracing tree is constructed, and the synchronization result is obtained from the target system. The synchronization result is associated with the corresponding node of the temporal tracing tree, and the change propagation range is calculated. Based on the business constraint rules in the semantic graph structure, the nodes within the change propagation range are dynamically deduced. When a constraint conflict is detected, the change path of the temporal tracing tree is traced back to the root cause of the conflict, and the mapping strategy is adaptively reconstructed based on the result of the dynamic deduction.

[0061] In one optional implementation, the data models of the source system and the target system are analyzed based on the semantic graph structure, the implicit associations between the source system and the target system are learned through semantic matching, and a mapping strategy considering data integrity constraints is dynamically generated based on the dependencies between the objects, including:

[0062] Based on the entity type and attribute semantics in the semantic graph structure, semantic similarity is calculated between the data model nodes of the source system and the data model nodes of the target system to identify node pairs with equivalent semantics or inclusion relationships, thereby obtaining a semantic alignment candidate set.

[0063] By aggregating the neighborhood features of node pairs in the semantic alignment candidate set on the semantic graph structure through graph convolution propagation mechanism, the implicit association pattern between the source system and the target system across explicit attribute mapping is learned, and an implicit association representation is obtained.

[0064] Based on cross-entity dependencies in semantic data representation, a dependency propagation path is constructed between the data object to be synchronized and its associated data objects, and the set of data objects that need to maintain integrity is determined according to the dependency propagation path.

[0065] Based on the implicit association representation and the set of data objects, a mapping strategy containing a mapping priority sequence and integrity constraint verification rules is generated.

[0066] Data model analysis based on semantic graph structure employs a graph database to construct a semantic graph storage architecture, abstracting the data models of the source and target systems into a graph structure representation of nodes and edges. The semantic graph structure construction steps include three stages: data model parsing, node creation, and relationship establishment. Data model parsing extracts information such as table structure, field definitions, and constraints from the metadata of the source and target systems. It obtains a system directory view through a database connector and parses metadata attributes such as table names, column names, data types, primary keys, and foreign keys. Node creation maps each data table to an entity type node and each field to an attribute semantic node. Entity type nodes contain attribute fields such as entity type, entity name, description information, and business domain. Attribute semantic nodes contain core fields such as attribute name, data type, semantic label, and constraint type. Relationship establishment creates attribute edges by analyzing the attribution relationships between fields and tables, creates dependent edges by analyzing foreign key constraints, and creates inherited edges by analyzing inheritance relationships, ultimately forming a complete semantic representation network.

[0067] Semantic similarity calculation employs a weighted fusion method of word vector similarity and structural similarity. Text preprocessing involves word segmentation of entity and attribute names, removal of stop words, stemming, and handling of camelCase naming and underscore-separated compound words. Vectorization uses a pre-trained word embedding model to convert the text into 300-dimensional vectors. Out-of-vocabulary words are processed using character-level subsequences with sequence lengths ranging from two to four. The overall representation is obtained by averaging the sub-word vectors. Similarity calculation uses cosine similarity to quantify the distance between vectors. Entity type similarity thresholds are set as follows: above 0.75 is considered high similarity, between 0.5 and 0.75 is medium similarity, and below 0.5 is low similarity. Result fusion weights word vector similarity, data type matching, and constraint compatibility at 0.4, 0.4, and 0.2 respectively. A perfect data type match scores 1.0, compatible types (e.g., integer and floating-point) score 0.8, and incompatible types score 0.0.

[0068] Semantic alignment candidate set identification employs a bidirectional matching strategy. Forward matching calculates the similarity between each node in the source system and all nodes in the target system, selecting the top three target nodes with the highest similarity for each source node as candidates. Backward matching calculates the similarity between each node in the target system and all nodes in the source system, selecting the top three source nodes with the highest similarity for each target node as candidates. Result merging involves taking the intersection of the forward and backward matching results, retaining only node pairs that satisfy the conditions in both directions as the candidate set. Conflict resolution uses a competitive selection mechanism. When multiple source nodes compete for the same target node, the source node with the highest similarity is selected, and other source nodes reselect the next best target node. This process iterates until all conflicts are resolved. Equivalent semantic relations require a semantic similarity greater than 0.85 and complete data type matching. Inclusion relations are verified through ontology reasoning to establish hierarchical conceptual relationships, with a similarity threshold of 0.7 for hierarchical concepts.

[0069] The graph convolutional propagation mechanism achieves neighborhood feature aggregation. Neighborhood sampling employs a fixed-size sampling strategy, sampling a fixed number of neighboring nodes for each node. The first layer samples 25 neighbors, and the second layer samples 10 neighbors, avoiding excessive computational complexity. Feature aggregation aggregates the feature vectors of neighboring nodes using mean pooling to obtain the aggregated feature representation of the neighborhood. A nonlinear transformation maps the aggregated features to a 128-dimensional hidden space through a linear transformation layer, then applies a modified linear unit activation function to introduce nonlinearity. Residual connections add the original node features to the transformed features, maintaining gradient flow and improving model performance. The graph convolutional network consists of two graph convolutional layers and one fully connected layer, with a learning rate of 0.01, a batch size of 64, 200 training epochs, and a random deactivation probability of 0.1.

[0070] Implicit association pattern learning is achieved through a contrastive learning method. Sample construction involves selecting matching node pairs from a semantic alignment candidate set as positive samples and generating non-matching node pairs as negative samples through random sampling, with a positive-to-negative sample ratio of 1:3. Model training employs a contrastive loss function with a boundary parameter set to 0.5 and a temperature parameter set to 0.1. The number of negative samples per batch is 16, and the training data is divided into training, validation, and test sets in an 8:1:1 ratio. Association calculation utilizes a graph convolutional network to obtain the 128-dimensional embedding vector representation of nodes, calculating the cosine similarity between node pairs as the implicit association strength. Strength quantification categorizes implicit association strength into three levels: above 0.6 indicates strong association, 0.3 to 0.6 indicates moderate association, and below 0.3 indicates weak association. An early stopping strategy is employed to prevent overfitting.

[0071] Cross-entity dependency analysis constructs a dependency graph to represent the constraints between data objects. The specific steps include four stages: constraint resolution, dependency graph construction, strength calculation, and path analysis. Constraint resolution extracts foreign key constraints, referential integrity constraints, and business rule constraints from semantic data representation, analyzing the type, strictness, and scope of influence of the constraints. Dependency graph construction uses a directed acyclic graph structure, where nodes represent data entities, edges represent dependencies, and edge weights represent dependency strength. Strength calculation combines three factors: constraint type strictness, data update frequency, and business importance. Weights are assigned at 0.5, 0.3, and 0.2, respectively. Foreign key constraint dependency strength is 1.0, referential integrity constraint strength is 0.8, and business rule constraints range from 0.4 to 0.7 depending on complexity. Path analysis uses a breadth-first search algorithm to traverse the dependency graph starting from the data objects to be synchronized. The path depth is limited to five levels, and the path weight is the product of all edge weights. Paths with weights below 0.1 are filtered out.

[0072] The dependency propagation path construction determines the set of data objects that need to maintain integrity. The specific steps include four stages: starting point determination, path traversal, object classification, and set construction. Starting point determination uses the data objects to be synchronized as the starting point for traversal, initiating dependency propagation analysis. Path traversal uses a breadth-first search algorithm to expand layer by layer on the dependency graph, recording the shortest path from the starting point to each node and the path weight. Object classification categorizes related objects into direct dependencies and indirect dependencies based on the dependency path length. Direct dependencies are those with a path length of one, while indirect dependencies are those with a path length greater than one and less than or equal to five. Set construction employs a layered processing strategy: first-level dependencies must be synchronized, second and third-level dependencies are conditionally synchronized, fourth and fifth-level dependencies are optional to synchronize, and dependencies beyond five levels are not considered, forming the final set of data objects.

[0073] The mapping strategy generation is based on a comprehensive analysis of implicit association representation and data object sets. The specific steps include four stages: priority calculation, sequence generation, constraint rule creation, and verification mechanism design. Priority calculation combines three dimensions: node importance, dependency strength, and data consistency requirements, with weights allocated to 0.4, 0.4, and 0.2. Node importance is calculated using a page ranking algorithm, with a damping coefficient set to 0.85, and iterations are performed fifty times until convergence. Sequence generation uses a topological sorting algorithm to ensure dependency satisfaction. Mapping operations with the same priority but no dependencies can be executed in parallel, with a maximum concurrency of eight. Constraint rule creation includes three types of rules: pre-constraint checks, process constraint monitoring, and post-constraint verification. Pre-constraint checks verify the integrity of the source data, process monitoring uses a trigger mechanism for real-time detection, and post-constraint verification performs a comprehensive integrity check. The verification mechanism design uses a two-phase commit protocol to ensure transaction consistency. The first phase involves preprocessing and resource locking, and the second phase executes data changes. The transaction timeout is set to 300 seconds, and automatic rollback and repair suggestions are generated upon failure.

[0074] In one optional implementation, neighborhood features of node pairs in the semantic alignment candidate set are aggregated on the semantic graph structure via a graph convolutional propagation mechanism to learn the implicit association pattern between the source system and the target system across explicit attribute mappings, resulting in an implicit association representation including:

[0075] For each node pair in the semantic alignment candidate set, the initial feature vectors of the data model nodes of the source system and the data model nodes of the target system in the semantic graph structure are extracted;

[0076] Based on the initial feature vector, multi-hop neighborhood expansion is performed along the edges constructed along the cross-entity dependency relationship on the semantic graph structure. For each node pair, the feature vectors of the neighboring nodes in its multi-hop neighborhood are aggregated, and the influence weights of different neighboring nodes on the current node pair are calculated through the graph convolution propagation mechanism to obtain the neighborhood aggregation feature.

[0077] The data model node features of the source system and the data model node features of the target system in the neighborhood aggregation features are projected onto the shared semantic space. By minimizing the distance between semantically equivalent node pairs in the shared semantic space and maximizing the distance between semantically irrelevant node pairs, the neighborhood aggregation features are cross-domain aligned to obtain the aligned cross-domain feature representation.

[0078] Based on the aligned cross-domain feature representation, the semantic similarity between the data model nodes of the source system and the data model nodes of the target system is calculated in the shared semantic space. The structured association pattern that does not rely on explicit attribute name matching is identified, and the node correspondence in the structured association pattern is encoded into an implicit association representation.

[0079] The graph convolutional propagation mechanism extracts initial feature vectors for each node pair in the semantic alignment candidate set. The initial feature vectors of the source system's data model nodes are obtained through node attribute encoding, containing four dimensions: node type, attribute name, data type, and constraint information. Node types are represented using one-hot encoding, supporting entity nodes, attribute nodes, and relation nodes, with a three-dimensional encoding length. Attribute names are converted into 300-dimensional vectors using a pre-trained word embedding model, with average pooling used for multi-word attribute names. Data type encoding supports five basic types: integer, floating-point, character, date, and boolean, represented using a five-dimensional one-hot vector. Constraint information includes four types: primary key constraints, foreign key constraints, non-null constraints, and unique constraints, represented using a four-dimensional binary vector, with the corresponding position set to one when a constraint exists and zero when it does not. The target system's data model nodes use the same feature extraction method to ensure that the feature vectors of the source and target systems have the same dimensional structure; the total dimension of the initial feature vectors is 312.

[0080] Multi-hop neighborhood expansion is implemented based on edges constructed from cross-entity dependencies in the semantic graph structure. The expansion depth is set to two to three hops to avoid excessive dilution of information propagation. The one-hop neighborhood includes all neighboring nodes directly connected to the current node, obtained by traversing edges with attributes, dependent edges, and inherited edges. The two-hop neighborhood continues to expand from the one-hop neighborhood, including the neighboring nodes of neighboring nodes. During the expansion process, visited nodes are filtered to avoid duplicate calculations. The three-hop neighborhood further expands to the neighboring nodes of the two-hop neighborhood. The expansion range is limited by a maximum threshold for the number of neighboring nodes; the total number of neighboring nodes for a single node is capped at fifty. When the threshold is exceeded, the node with the highest edge weight is retained and sorted by edge weight. Neighboring node feature vector aggregation uses an attention mechanism to calculate influence weights. Attention weights are calculated by the dot product of the query vector and the key vector. The query vector represents the current node's features, and the key vector represents the neighboring node's features. The attention score is normalized using a soft maximization function to ensure that the weights sum to one.

[0081] The graph convolutional propagation mechanism calculates the influence weights of different neighboring nodes on the current node pair using a multi-head attention structure with eight attention heads, each with a hidden dimension of 64. The query matrix, key matrix, and value matrix are generated from the input features through a linear transformation layer, with the weight matrix of the linear transformation layer having a dimension of 312 x 64. The multi-head attention outputs are concatenated into a 512-dimensional vector, then mapped back to 312 dimensions through an output projection layer. The graph convolutional layer uses a residual connection structure, adding the input features to the attention output, and then normalizing the layers to improve training stability. A gated linear unit is used as the activation function to provide better gradient flow characteristics. Neighborhood aggregation features are calculated using a weighted summation method, with weights equal to the influence weights of the attention mechanism outputs, maintaining the 312-dimensional feature vector format in the aggregation result.

[0082] The shared semantic space projection is achieved through two independent multilayer perceptron networks. The source system node feature projection network and the target system node feature projection network have the same network structure but independent parameters. The projection network contains three fully connected layers with hidden layer dimensions of 256, 128, and 64, respectively, and an output layer dimension of 128, which serves as the embedding dimension of the shared semantic space. The activation function is a modified linear unit, and the dropout probability is set to 0.1 to prevent overfitting. The neighborhood aggregation features of the source system are mapped to the shared semantic space through the source system projection network, and the neighborhood aggregation features of the target system are mapped to the shared semantic space through the target system projection network. The projected feature vectors have comparable semantic representations in the shared semantic space.

[0083] Cross-domain alignment is achieved through a contrastive learning loss function. Cosine similarity is used to minimize the distance between semantically equivalent node pairs in the shared semantic space, with a similarity target value set above 0.95. The distance between semantically irrelevant node pairs is maximized through a negative sampling strategy, with a negative sample ratio three times that of positive samples. Negative samples are generated by randomly pairing unmatched nodes. The contrastive loss function employs an information-noise contrastive estimation method, with a temperature parameter set to 0.07 to control the sharpness of the softmax distribution. The loss for positive sample pairs is the negative log-likelihood, and the loss for negative sample pairs is the positive log-likelihood. The total loss is the weighted sum of the losses for positive and negative samples, with a weight ratio of 1:1. Model training uses a stochastic gradient descent optimizer with a learning rate of 0.001, a batch size of 128, and 500 training epochs. Cosine annealing is used for learning rate scheduling, with a minimum learning rate of 0.0001 and a restart cycle of 100 epochs.

[0084] Semantic similarity calculation is performed in a shared semantic space based on aligned cross-domain feature representations, using cosine similarity as the distance metric. The feature vectors of source system data model nodes and target system data model nodes in the shared semantic space are used to calculate cosine similarity by dividing the vector dot product by the vector magnitude. The similarity value ranges from -1 to +1, with a similarity closer to +1 indicating stronger semantic similarity. Structured association pattern recognition is achieved through clustering analysis. Node pairs with similarity higher than 0.8 are considered strong association patterns, those between 0.6 and 0.8 are considered moderately associated patterns, and those lower than 0.6 are considered weakly associated patterns. The clustering algorithm uses a density-based spatial clustering method, with a minimum number of nodes set to five and a neighborhood radius set to 0.1. The clustering results form different clusters of association patterns.

[0085] Implicit association representation encoding converts the node correspondences in structured association patterns into vector representations. The encoding method employs graph embedding, concatenating the shared semantic space feature vectors of node pairs to form a 256-dimensional association vector. This association vector is then compressed into a compact 64-dimensional representation using hash encoding. The hash function employs locality-sensitive hashing to maintain the proximity of similar association patterns in the hash space. Implicit association representation storage uses a key-value pair structure, where the key is a combination of the source and target system node identifiers, and the value is a 64-dimensional association vector. The storage system supports fast similarity retrieval, accelerates association pattern queries through an inverted index, and updates the index hourly, supporting incremental updates.

[0086] In a specific data example, the semantic alignment candidate set contains node pairs of the customer ID field from the source system's customer table and the user identifier field from the target system's user table. The initial feature vector of the customer ID field includes attribute node type encoding, field name embedding, integer data type encoding, and primary key constraint identifier, forming a 312-dimensional feature vector. The user identifier field uses the same feature extraction method to obtain its corresponding initial feature vector. Multi-hop neighborhood expansion yields a one-hop neighborhood for the customer ID field containing customer table entity nodes, customer name field nodes, and customer email field nodes; and a two-hop neighborhood containing order table entity nodes and order number field nodes. Neighborhood expansion for the user identifier field yields neighbor nodes for user table entity nodes, user name field nodes, transaction table entity nodes, etc. The graph convolutional propagation mechanism calculates the association weight between the customer ID field and the order number field to be 0.85, and the association weight with the customer name field to be 0.72. Shared semantic space projection maps the customer ID field features to a 128-dimensional vector, and the user identifier field features to a vector of the same dimension. After cross-domain alignment optimization, the cosine similarity between the two fields in the shared semantic space reaches 0.91, exceeding the strong association threshold of 0.8. The implicit association representation is encoded to generate a 64-dimensional association vector. The first 32 dimensions of the vector represent structural association features, and the last 32 dimensions represent semantic association features. The final encoding result is stored as an implicit association representation of the customer ID and user identifier field pairs.

[0087] In one optional implementation, the execution order of synchronization operations is determined according to the mapping strategy. When a dependency relationship is detected between objects, multiple related data objects are organized into an atomic synchronization transaction, and transactional data transmission is performed to the target system according to the data flow path in the semantic graph structure, including:

[0088] The priority information and constraint rules contained in the mapping strategy are parsed to obtain the execution order of the synchronization operations of the data objects to be synchronized, and the data objects to be synchronized are traversed according to the execution order to detect the dependency relationships between the data objects to be synchronized.

[0089] When a dependency relationship is detected between the data objects to be synchronized, multiple related data objects are identified, and the multiple related data objects are organized into an atomic synchronization transaction to construct a set of transaction data objects.

[0090] For the set of transactional data objects, the data flow path of each data object in the set of transactional data objects is obtained from the semantic graph structure. Based on the transmission route and transmission order identified in the data flow path, the transactional data transmission of the set of transactional data objects is executed to the target system.

[0091] During the execution of the transactional data transmission, the synchronization status of all data objects in the transactional data object set is monitored in real time. When the transmission of any data object in the transactional data object set fails, the synchronization operation of all data objects in the transactional data object set is rolled back according to the synchronization status.

[0092] The mapping strategy parsing module extracts priority information and constraint rules from the mapping strategy. Priority information is represented by numerical weights, ranging from zero to one hundred, with higher values ​​indicating higher priority. Constraint rules include three types: preconditions, concurrency limits, and dependency constraints. Preconditions specify the data states that must be met before object synchronization; concurrency limits set the maximum number of objects allowed to execute simultaneously; and dependency constraints describe the execution order between objects. The parser uses a recursive descent parsing method to process the strategy file, which is in a structured text format and contains four fields: object identifier, priority value, constraint type, and constraint parameters. The parsing result generates an execution order list of data objects to be synchronized, sorted from highest to lowest priority, with objects of the same priority arranged lexicographically by their object identifiers. After the execution order is determined, the traverser visits the data objects to be synchronized one by one in sequence, recording the identifier and status information of each visited object during the traversal.

[0093] Dependency detection is achieved by analyzing three types of relationships between objects: foreign key references, data constraints, and business rules. Foreign key reference detection scans the field definitions of objects, identifies foreign key fields pointing to the primary keys of other objects, and establishes a reference graph. Data constraint detection analyzes the integrity constraints of objects, including NOT NULL constraints, unique constraints, and check constraints, and identifies combinations of objects requiring joint verification. Business rule detection parses predefined rule configuration files, which define the logical dependencies between objects and support combinations of conditional expressions and action sequences. Dependencies are stored in a directed graph structure, where nodes represent data objects, edges represent dependencies, and edge weights represent dependency strength. Dependency strength is calculated based on three factors: reference frequency, constraint strictness, and business importance, with weights allocated at 0.4, 0.3, and 0.3 respectively. The detection algorithm uses a depth-first search to traverse the dependency graph and identifies strongly connected components as related object combinations.

[0094] Atomicity-based synchronous transaction construction organizes multiple related data objects into indivisible execution units. Transaction boundaries are determined based on transitive closure computation of dependencies. Starting from the object with detected dependencies, all directly or indirectly dependent objects are recursively searched to form a complete set of object dependencies. Transaction identifiers are generated using a combination of timestamps and random numbers to ensure global uniqueness; the identifier format is a 16-bit timestamp plus an 8-bit random number. The transaction data object set is stored as an ordered list, with each list element containing four attributes: object identifier, object type, data version, and lock status. Object locking employs a pessimistic locking mechanism, locking all objects in the set at the start of the transaction to prevent data inconsistency caused by concurrent modifications. The lock timeout is set to 300 seconds; after the timeout, the lock is automatically released and the transaction is marked as failed. Transaction state management maintains four states: prepare, execute, commit, and rollback, with state transitions following strict finite state machine rules.

[0095] The data flow path acquisition mechanism extracts transmission path information from the semantic graph structure, focusing on the set of transaction data objects. Path query employs a breadth-first search algorithm, searching for the shortest path from the source object node to the target object node. Path weight calculation is based on three metrics: network latency, bandwidth capacity, and node load; lower weights indicate higher path quality. Transmission routing supports two modes: primary route and backup route. The primary route is the path with the lowest weight, while the backup route is the path with the second lowest weight and less than 50% overlap with the primary route. Transmission order is determined using a topology sorting algorithm based on object dependencies, ensuring that dependent objects are transmitted before their dependent objects. Path information is cached in memory for 60 minutes with a cache hit rate of at least 90%. The path monitoring module detects changes in path quality in real time, automatically switching to a backup path when path latency exceeds a threshold or a node fails.

[0096] Transactional data transmission employs a two-phase commit protocol to ensure atomicity. The first phase is the preparation phase, where a transaction preparation request is sent to the target system, including information such as the transaction identifier, object set, and expected data volume. Upon receiving the request, the target system performs resource pre-allocation and conflict detection, returning a response indicating success or failure. The second phase is the commit phase. Once all participating nodes return success, a commit request is sent to execute the actual data transmission; otherwise, an abort request is sent to cancel the transaction. Data transmission uses a block transmission method, with a block size of 4,000 bytes, supporting breakpoint resumption and retransmission mechanisms. The transmission protocol uses a reliable transport layer protocol, with a timeout of 30 seconds and a retransmission limit of three times. Data compression uses a lossless compression algorithm, achieving an average compression ratio of 60%, reducing network transmission overhead. Transmission encryption uses a symmetric encryption algorithm with a key length of 256 bits, and each transaction uses an independent session key.

[0097] Synchronous status monitoring tracks the transmission progress of all objects in the transaction data object set in real time through a status collector. Status information includes four fields: object identifier, transmission progress, error code, and timestamp, with a status update frequency of ten times per second. Monitoring agents are deployed at key nodes in the transmission path, responsible for collecting local object status information and reporting it to the central monitoring service. The status aggregation service receives status reports from each monitoring agent and maintains a global view of transaction execution. Anomaly detection identifies transmission failures based on status change patterns, with detection rules including three types: transmission timeout, connection interruption, and data verification failure. The transmission timeout threshold is set to a single object transmission time exceeding sixty seconds. Connection interruption is identified through a heartbeat detection mechanism with a heartbeat interval of five seconds. Data verification uses cyclic redundancy check codes to verify data integrity; if verification fails, transmission failure is immediately marked.

[0098] The transaction rollback mechanism is triggered when any data object transmission failure is detected. The rollback operation is implemented using a compensatory transaction approach. The rollback state record maintains the original state of each object before the transaction began, including data snapshots, version numbers, timestamps, and other information. The compensatory operation employs different rollback strategies based on the object type: newly added objects are deleted, modified objects are restored, and deleted objects are re-inserted. The rollback order is the reverse of the original transmission order, using inverse topology sorting to determine the rollback sequence. Rollback execution is synchronous, performing the rollback operation on each object one by one until all objects are restored to their original state. The rollback timeout is set to 180 seconds; after the timeout, the rollback is marked as failed, and detailed error information is recorded. A manual intervention process is triggered upon rollback failure, generating a report containing the failed object, the cause of the error, and recovery suggestions. State consistency verification is performed after the rollback is complete, confirming success by comparing the current state with the original state snapshot.

[0099] In a specific data example, the mapping strategy includes an execution order with customer object priority of 90, order object priority of 80, and payment object priority of 70. Dependency detection reveals that the order object depends on the customer object through the customer identifier field, and the payment object depends on the order object through the order identifier field, forming a dependency chain from customer to order to payment. Atomicity synchronization transactions organize the three objects into a set of transactional data objects with transaction identifier 202411031234567890. Data flow path query obtains the transmission path from the source database node to the target database node, which includes three hops: the source node, the gateway node, and the target node, with a total latency of 15 milliseconds. Transactional data transmission in the first phase sends a preparation request containing the three objects. The target system pre-allocates a 4,000-byte buffer and returns a successful preparation response. In the second phase, data transmission is executed. Customer object transmission takes 3 seconds, order object transmission takes 5 seconds, and payment object transmission fails due to network connection interruption. Synchronization status monitoring detects the payment object transmission failure and triggers a transaction rollback. The rollback operation deletes the transmitted order and customer objects, restoring the target system to its state before the transaction began. The entire rollback process takes 12 seconds to complete.

[0100] In one optional implementation, a temporal tracing tree is constructed during the synchronization process. Synchronization results are obtained from the target system, and the synchronization results are associated with the corresponding nodes of the temporal tracing tree. The change propagation range is calculated, and dynamic deduction of the nodes within the change propagation range based on the business constraint rules in the semantic graph structure includes:

[0101] Construct a time-series tracing tree and record the change status and time-series information of the nodes. Obtain the synchronization result of the data object to be synchronized from the target system. Compare the final status information in the synchronization result with the change content of the corresponding node in the time-series tracing tree in multiple dimensions. Identify the set of nodes that have undergone status changes through the comparison results.

[0102] For each node in the node set, the temporal dependencies recorded in the temporal tracing tree are traced downstream, and the cross-entity dependencies in the semantic graph structure are combined to identify related entities, thus constructing a change propagation network that includes nodes that directly affect nodes and nodes that indirectly affect nodes.

[0103] Based on the business constraint rules in the semantic graph structure, the node states in the change propagation network are dynamically deduced. By verifying the degree of matching between the current state of the node and the constraint conditions, the constraint satisfaction of each node in the change propagation network is evaluated. Based on the connection strength, the impact range of constraint violation is calculated, and constraint verification results including violation levels are generated.

[0104] The time-series tracing tree is constructed using a multi-branch tree data structure to record node change states and timing information during the synchronization process. Each tree node contains eight core fields: node identifier, data object identifier, change type, change time, pre-change state, post-change state, parent node reference, and a list of child nodes. The node identifier is generated using a globally unique identifier, a 32-character hexadecimal string. The change type supports three operations: add, modify, and delete, represented by the numerical values ​​one, two, and three, respectively. The change time uses a timestamp format accurate to milliseconds to ensure accurate recording of event sequence. The pre-change and post-change states store complete snapshots of the data objects, recording the values ​​of all fields in a key-value pair format. The tree structure is maintained through a two-layer architecture of in-memory index and persistent storage. The in-memory index supports fast queries, while persistent storage ensures data reliability. The index structure uses a combination of hash tables and red-black trees. The hash table is indexed by node identifier, and the red-black tree is arranged in chronological order, resulting in a logarithmic time complexity for queries.

[0105] The target system synchronization results are obtained through two methods: polling and event notification. The polling mechanism actively queries the target system's data status at fixed time intervals, with a five-second interval, suitable for low-frequency change scenarios. The event notification mechanism receives status change notifications from the target system via a message queue. The message format includes four fields: object identifier, operation type, timestamp, and status data, suitable for high-frequency change scenarios. Synchronization results contain four dimensions of information: object identifier, final state, operation result, and error message. The final state records the object's current value in the target system, the operation result indicates whether the synchronization operation was successful, and the error message describes the reason for failure and the error code. The result collector aggregates synchronization results from different data sources and arranges them in chronological order to form a result sequence. Result caching adopts a least recently used strategy, with a cache size limited to 10,000 records and a cache hit rate requirement of at least 85%.

[0106] Multi-dimensional comparison is achieved through field-level state comparison, encompassing three dimensions: data value changes, data type changes, and constraint state changes. Data value change detection compares the final state in the synchronization result with the changed state recorded in the time-series source tree, field by field. Different strategies are employed based on the field type: exact comparison for numeric fields, string matching for character fields, and time difference comparison for date fields. Data type change detection analyzes field type conversions, such as integer to floating-point or character to numeric conversion. Constraint state change detection verifies the fulfillment of integrity constraints, including changes in the state of NOT NULL, QUESTION, and FILE constraints. The comparison threshold is set to allow an error range of 0.01% for numeric fields, a perfect match for character fields, and a one-second time difference for time fields. The comparison results generate difference records containing three attributes: change identifier, change type, and change degree. The change degree is represented by a value from zero to ten, with higher values ​​indicating a greater degree of change.

[0107] Node set identification filters nodes with changed states based on comparison results. The filtering criteria include three standards: change severity exceeding a threshold, change in constraint state, and change in key field values. The change severity threshold is set to three; changes below the threshold are considered normal system noise. Constraint state changes include transitions from constraint satisfaction to constraint violation or vice versa. Key fields are defined in the business rule configuration file and typically include important attributes such as primary key fields, foreign key fields, and status identifier fields. Node sets are stored using a set data structure, supporting fast member checks and traversal operations. The set size is limited to 5,000 nodes; if this limit is exceeded, nodes with the highest importance are retained based on change severity. Node importance assessment combines change severity, number of dependencies, and business priority, with weighting ratios of 0.5%, 0.3%, and 0.2%, respectively.

[0108] The change propagation network is constructed based on temporal dependencies using a temporal origination tree and cross-entity dependencies using a semantic graph structure. Temporal dependency tracing starts from the change node and traverses downstream along the temporal origination tree to identify subsequent nodes affected by the current change. The downstream tracing depth is limited to five levels to avoid excessive propagation. Cross-entity dependencies are identified through edge relationships in the semantic graph structure, with edge types including foreign key references, aggregation relationships, and composition relationships. Foreign key references represent referential relationships between entities, aggregation relationships represent whole-part relationships, and composition relationships represent strong dependency inclusion relationships. Related entity identification employs a breadth-first search algorithm, traversing the semantic graph structure starting from the change node, with a search depth limited to three levels. Directly affected nodes are those directly connected to the change node, while indirectly affected nodes are those connected via multi-hop paths. The propagation network is represented using a directed graph data structure, where nodes represent data objects, edges represent influence relationships, and edge weights represent the strength of the influence.

[0109] Impact strength calculation is based on three factors: dependency type, data importance, and change frequency. The weighting for dependency type is as follows: foreign key references 1.0, aggregation relationships 0.8, and composition relationships 0.6. Data importance is determined by business rule configuration, with core business data weighted at 1.0 and auxiliary data weighted at 0.5. Change frequency is calculated based on historical statistical data, with high-frequency change objects having their weight reduced by 0.2 and low-frequency change objects having their weight increased by 0.2. The final impact strength is the product of the three factor weights, ranging from 0 to 1.2. Network pruning uses an impact strength threshold of 0.3 for filtering; relationships below this threshold are removed. Network size control is limited by two parameters: the maximum number of nodes and the maximum number of edges. The maximum number of nodes is 1,000, and the maximum number of edges is 5,000.

[0110] Dynamic inference verifies the node status in the change propagation network based on business constraint rules in the semantic graph structure. These business constraint rules include three categories: data integrity constraints, business logic constraints, and consistency constraints. Data integrity constraints verify the validity of field values, such as NOT NULL constraints, data type constraints, and value range constraints. Business logic constraints verify the logical relationships between objects, such as rules that the total order amount equals the sum of the order item amounts and that inventory quantity cannot be negative. Consistency constraints verify data consistency in a distributed environment, such as the data synchronization status of master-slave databases and the data consistency between cache and database. Constraint rules are executed using a rule engine, and rule expressions support basic functions such as conditional judgment, numerical calculation, and string manipulation. The inference process executes according to the topological order of nodes in the propagation network, ensuring that dependent nodes are verified after the nodes they depend on.

[0111] Constraint matching degree evaluation is achieved through a quantitative score of rule execution results. The matching degree of each constraint rule is represented by a value from zero to one, where zero indicates that the constraint is not satisfied at all, and one indicates that the constraint is fully satisfied. The matching degree of composite constraints is calculated by weighted average of the matching degrees of sub-constraints, with the weights determined according to the importance of the constraints. The overall constraint satisfaction of a node is represented by the average matching degree of all related constraints. A constraint violation detection threshold of 0.8 is set; nodes below this threshold are marked as constraint violations. Violation levels are divided into three levels based on matching degree: minor violation, moderate violation, and severe violation, with matching degree ranges of 0.6 to 0.8, 0.3 to 0.6, and 0 to 0.3, respectively. Violation node statistics include information such as the number of violation nodes, the distribution of violation types, and the severity of the violation.

[0112] Connection strength calculation is based on the influence relationships between nodes in the change propagation network. The strength calculation considers two dimensions: direct connection strength and indirect connection strength. Direct connection strength equals the influence strength of an edge, while indirect connection strength is calculated through path propagation attenuation. Path propagation uses a product attenuation model with an attenuation coefficient set to 0.9. For each additional hop in the path length, the connection strength is multiplied by the attenuation coefficient. The influence range is determined by a connection strength threshold set to 0.2. Nodes with connection strengths higher than the threshold are included in the influence range. The influence range is divided into three levels according to connection strength: core influence area, important influence area, and peripheral influence area, with connection strength ranges of 0.8 and above, 0.5 to 0.8, and 0.2 to 0.5, respectively. The constraint verification results generate information including five dimensions: node identifier, constraint satisfaction status, violation level, influence range, and remediation suggestions.

[0113] In a specific data case, the time-series source tree records modification operations on customer objects. Customer object C001 changed its status from active to paused at timestamp 1699123456789. The target system's synchronization results show the customer status successfully updated to paused, and the synchronization operation is marked as successful. Multi-dimensional comparison reveals a change in the customer status field, with a change severity score of eight, exceeding the threshold of three and thus included in the node set. During the construction of the change propagation network, subsequent order query operations were identified as affected based on time-series dependencies, and order objects and payment objects associated with the customer were identified as affected based on cross-entity dependencies. The propagation network contains six nodes: customer object, three order objects, and two payment objects, with connection strengths of 1.0, 0.8, 0.8, 0.8, 0.6, and 0.6, respectively. Dynamic inference verification reveals that the customer status constraint of the order object requires the customer to be active; the current paused status results in a constraint violation, with a matching severity of 0.2, and is marked as a serious violation. The constraint verification results show that three nodes violated the rules, with the violation level being serious. The impact covers one node in the core impact area and five nodes in the important impact area. The remediation suggestion is to restore the customer's active status or update the order status constraint rules.

[0114] In one optional implementation, when a constraint conflict is detected, tracing back along the change path of the temporal source tree to the root cause of the conflict, and adaptively reconstructing the mapping strategy based on the results of the dynamic deduction, includes:

[0115] When a constraint conflict is detected, the conflict node where the constraint conflict occurs is located in the time-series tracing tree. Based on the change path information recorded in the time-series tracing tree, the conflict node is traced backward to identify the root cause node of the constraint conflict.

[0116] From the root node of the conflict to the conflict node, construct a mapping operation dependency graph on the change path, analyze the contribution of each mapping rule in the mapping operation dependency graph to the constraint conflict, and establish an influence weight model of the mapping rule.

[0117] The results of the dynamic simulation are analyzed, and the differences between the constraints and actual states of each node within the propagation range are modeled. Combined with the influence weight model of the mapping rules, the relevant mapping rules in the mapping strategy are adjusted in a targeted manner to generate a reconstruction mapping strategy that satisfies the constraints.

[0118] like Figure 2 As shown, the method includes:

[0119] Constraint conflict detection monitors data status changes in real time through a constraint validation engine. When a constraint satisfaction level falls below a set threshold, a conflict alarm is triggered. Constraint conflict identification is based on the execution results of a rules engine, which applies relevant constraints to each data object. These constraints fall into three categories: integrity constraints, business logic constraints, and consistency constraints. Integrity constraints validate the validity and integrity of field values; business logic constraints validate the logical relationships between objects; and consistency constraints validate the consistency of the data. Constraint satisfaction is quantified using a value from zero to one, where zero represents a complete violation and one represents a complete satisfaction. The conflict threshold is set to 0.7; constraints below this threshold are marked as conflicting. The conflict detector executes ten detection cycles per second, covering all currently active data objects. Conflict event records include five dimensions of information: conflict node identifier, conflict type, conflict time, constraint description, and conflict severity.

[0120] Conflict node localization employs a temporal source tree indexing mechanism to quickly locate the specific node experiencing a constraint conflict. The temporal source tree maintains a mapping relationship between node identifiers and tree nodes, achieving constant-time lookup operations through hash indexes. A conflict node contains basic information such as node identifier, data object identifier, conflict description, and occurrence time. The node localization process retrieves the corresponding tree node in the temporal source tree using the node identifier field from the conflict event, verifying the node's existence and validity. The localization result includes structured data such as the node's position in the tree, parent node references, child node list, and node depth. Node validity verification checks whether the node's timestamp is within a valid range, whether the data version is the latest version, and whether the node's status is normal. If localization fails, an exception handling process is triggered, logging errors and notifying the administrator for manual intervention.

[0121] Reverse tracing is based on the change path information recorded in the temporal source tree, traversing upstream from the conflict node. The change path information includes core elements such as parent-child node relationships, change operation types, change time order, and data flow direction. The tracing algorithm employs a depth-first search strategy, recursively traversing from the conflict node along parent node references towards the root of the tree. The tracing depth is limited to ten levels to avoid excessive expansion of the tracing scope and its impact on performance. During the traversal, the visited node paths are recorded, forming a complete change chain from the conflict node to the root node. Path weights are calculated based on the strength of the causal relationship between nodes, which is evaluated through three factors: the directness of the change operation, the time interval, and the degree of data dependency. Directness is scored as 1.0 for direct change operations and 0.5 for indirect change operations. The time interval score uses an exponential decay model, with longer time intervals resulting in lower scores, and the decay coefficient is set to 0.9. Data dependency is based on field-level dependency analysis, with strong dependencies scoring 1.0 and weak dependencies scoring 0.3.

[0122] Conflict root cause node identification is determined by analyzing the contribution of each node along the change path to the conflict. The contribution assessment combines three dimensions: the scope of the change's impact, the importance of the change type, and constraint relevance. The scope of the change's impact is quantified by the number of downstream dependent nodes; the more dependent nodes, the larger the scope of impact. The importance of the change type decreases in the order of deletion, modification, and addition, with weights of 1.0, 0.8, and 0.6 respectively. Constraint relevance is calculated based on the degree of matching between the node's changed content and the conflict's constraints: a perfect match scores 1.0, a partial match scores 0.5, and no match scores 0.0. Root cause node screening uses a contribution threshold of 0.8; nodes exceeding this threshold are identified as conflict root causes. When multiple root cause nodes exist, the node with the highest contribution is selected as the primary root cause, and the remaining nodes are considered secondary root causes. Root cause node verification verifies the deterministic impact of a node on the conflict by simulating a rollback operation; if the conflict disappears after the rollback, it is confirmed as the true root cause.

[0123] The dependency graph for mapping operations is constructed based on the mapping operation relationships between adjacent nodes on the change path. The dependency graph adopts a directed acyclic graph structure, where nodes represent mapping operations and edges represent dependencies between operations. Mapping operations include attributes such as source field, target field, transformation rule, execution time, and operation status. Transformation rules describe the mapping logic between source and target fields, supporting three types: direct mapping, function transformation, and conditional mapping. Direct mapping involves direct copying of field values; function transformation processes field values ​​using predefined functions; and conditional mapping selects different mapping strategies based on conditional expressions. Dependencies are determined by analyzing the data flow between operations; dependency edges are established when the input of the current operation depends on the output of the preceding operation. Dependency strength is calculated based on the tightness of the data dependency; a full dependency has a strength of 1.0, and a partial dependency has a strength of 0.5. After the dependency graph is constructed, loop detection is performed to ensure the acyclic nature of the graph structure.

[0124] The contribution analysis of mapping rules is achieved by quantifying the impact of each mapping rule on constraint conflicts. The contribution calculation considers three factors: rule execution frequency, rule complexity, and rule error rate. Rule execution frequency is calculated by counting the number of times the rule is called in the change path; more calls indicate a higher contribution. Rule complexity is assessed based on the rule's logical complexity, including indicators such as the number of conditional branches, function call depth, and data type conversions. Rule error rate is calculated by the proportion of errors generated during rule execution; a higher error rate indicates a greater contribution to conflict resolution. The contribution is calculated using a weighted average method, with weights allocated as follows: execution frequency 0.5, complexity 0.3, and error rate 0.2%. The influence weight model uses linear regression to establish the relationship between rule features and conflict probabilities. The model training data comes from statistical analysis of historical conflict events. Model input features include rule type, execution time, data size, and constraint complexity; the output is a predicted conflict probability value. Model evaluation uses 10-fold cross-validation, requiring an accuracy of at least 85%.

[0125] The dynamic simulation results are analyzed to extract constraint verification information for each node within the change propagation range. The analysis includes detailed information such as node constraint status, constraint satisfaction level, violation type, and impact scope. Constraint status is categorized into three levels: satisfied, partially satisfied, and not satisfied. Constraint satisfaction is represented numerically. Violation types are classified according to constraint category, including integrity violations, logical violations, and consistency violations. The impact scope describes the cascading effects of violating nodes on other nodes. The analysis results are stored in a structured data table, supporting query and filtering operations by node identifier, constraint type, and violation degree. The analysis process uses streaming processing, supporting real-time analysis of large-scale data, with a processing performance requirement of 1,000 records per second.

[0126] Discrepancy modeling identifies inconsistencies by comparing node constraints with their actual states. Constraints are obtained from business rule configurations and include two levels: field-level constraints and object-level constraints. Field-level constraints verify the value range, data type, and format specifications of individual fields. Object-level constraints verify the consistency, completeness, and validity of the entire object. The actual state is extracted from the node's current data snapshot, containing the current values ​​and status indicators of all fields. Discrepancy identification is achieved by comparing constraints with the actual states item by item, generating discrepancy records. These records include discrepancy type, degree of discrepancy, difficulty of repair, and repair suggestions. The degree of discrepancy is represented by a value from zero to ten, with higher values ​​indicating more severe discrepancies. The difficulty of repair assesses the workload and complexity required to repair the discrepancy, categorized into simple, medium, and complex levels. The discrepancy modeling results provide data support for subsequent strategy adjustments.

[0127] Mapping strategy reconstruction involves targeted adjustments to relevant mapping rules based on the influence weight model and difference modeling results. The adjustment strategies include three methods: rule parameter optimization, rule logic modification, and rule execution order adjustment. Rule parameter optimization improves rule execution by adjusting parameters such as thresholds, weights, and coefficients. Parameter adjustment uses a grid search method to find the optimal parameter combination in a predefined parameter space. Rule logic modification improves rule accuracy by rewriting the conditional expressions or transformation functions. Logic modification determines the direction of modification based on difference analysis results and uses a rule template library to provide standardized modification schemes. Rule execution order adjustment avoids conflicts by rearranging the execution order of rules. Order adjustment uses a topological sorting algorithm to ensure the correctness of dependencies. Reconstruction strategy generation uses a genetic algorithm to optimize strategy combinations, with the fitness function based on three indicators: constraint satisfaction, execution efficiency, and stability. The algorithm parameters are set to a population size of 100, a generation count of 50, and a mutation probability of 0.1.

[0128] In a specific data case, constraint conflict detection revealed an inconsistency between the order status and payment status of an order object. The order status was "paid," but the payment status was "pending payment," resulting in a constraint satisfaction level of 0.3, which is below the conflict threshold of 0.7, triggering a conflict alarm. The conflict node was located in the temporal source tree, identifying the order object node with the node identifier NODE_20241103_001. Reverse tracing started from this conflict node and traversed upstream, the tracing path included three nodes: the payment status update node, the order status update node, and the order creation node, with a tracing depth of three levels. The conflict root cause node was identified as the primary root cause, with a contribution level of 0.92, exceeding the threshold of 0.8. The mapping operation dependency graph construction included two mapping operation nodes: payment status mapping rule and order status mapping rule. The contribution level of the payment status mapping rule was 0.85, and the contribution level of the order status mapping rule was 0.6. Discrepancy modeling revealed that the actual payment status was "pending payment," while the constraint required it to be "paid," resulting in a discrepancy level of 8 and a moderate difficulty in resolving the issue. The mapping strategy was refactored, adjusting the execution order of the payment status mapping rules to precede that of the order status mapping rules. Simultaneously, the conditional expression for payment status updates was modified, adding a pre-check for order status. The refactored mapping strategy was validated in the test environment, where the constraint satisfaction level improved to 0.95%, successfully eliminating constraint conflicts.

[0129] In a complete example, suppose a product configuration system has product A with three specifications: height, width, and weight, initially set at 100mm, 80mm, and 50g respectively. Constraints are: height range [100-140mm], width range [70-90mm], weight range [45-70g], and the height-to-width ratio should be between 1.2 and 1.5. When the design changes, a mapping strategy is applied: height increases by 25%, width increases by 10%, and weight increases proportionally to volume. After the change, the height becomes 125mm, the width becomes 88mm, and the weight becomes 68.75g. The system detects an aspect ratio of 1.42, within the allowable range, but the weight is close to the upper limit. When a subsequent change occurs, with the height increasing by another 20%, the height becomes 150mm, the width remains 88mm (unchanged), and the weight increases to 99g. At this point, the system detects that both the height and weight exceed the constraints. Through reverse tracing, the system identifies the root cause as an excessively high increase in height. When reconstructing the mapping strategy, the system adjusted the height increase ratio from 25% to 15%, and after recalculation, the height was 138mm and the weight was 67g, which met the constraints, thus generating an adaptive reconstruction mapping strategy.

[0130] In one optional implementation, a mapping operation dependency graph is constructed from the conflict root node to the conflict node, and the contribution of each mapping rule in the mapping operation dependency graph to the constraint conflict is analyzed. An influence weight model for the mapping rules is established, including:

[0131] A mapping operation dependency graph is constructed from the conflict root node to the conflict node, and the triggering conditions and execution effects of the mapping rule nodes are marked in the mapping operation dependency graph;

[0132] The effect of each dependency edge in the mapping operation dependency graph on the constraint conflict propagation process is analyzed, and the contribution of the dependency edge is calculated based on the effect. A weight matrix reflecting the distribution of the contribution of the dependency edge is constructed.

[0133] The influence of the mapping rule nodes in the mapping operation dependency graph is quantified according to the weight matrix, the degree of influence of each mapping rule node on constraint conflict is calculated, and the degree of influence is used as a weight factor to establish an influence weight model.

[0134] The mapping operation dependency graph is constructed based on the complete change path from the root node of the conflict to the conflict node, using a directed graph data structure to represent the dependencies between mapping operations. The graph builder traverses each node on the change path, extracts the mapping operations associated with the node, and abstracts the mapping operations as nodes in the graph. Mapping operation nodes contain seven core attributes: operation identifier, rule name, source field, target field, transformation function, execution time, and operation type. The operation identifier uses a globally unique identifier, a 32-digit hexadecimal string. The rule name identifies the business semantics of the mapping rule, and the source and target fields record the start and end positions of the data flow. The transformation function describes the specific logic of the data transformation, supporting three transformation types: direct assignment, function calculation, and conditional judgment. The execution time records the moment the operation occurs, with millisecond precision. The operation type distinguishes between three data change operations: add, modify, and delete. Dependency edges are established based on data flow analysis; directed edges are established when the output of a previous operation is used as the input of a subsequent operation. The initial edge weight is set to 0, representing a complete dependency.

[0135] The mapping rule node markers are used by the rule analyzer to parse the triggering conditions and execution effects of each mapping rule. Triggering conditions describe the preconditions for a mapping rule to be activated, including three types: data conditions, state conditions, and time conditions. Data conditions are based on the value or state of the input data, supporting operations such as equality comparison, range comparison, and pattern matching. State conditions are based on the current state of the object, such as whether the object is active or locked. Time conditions are based on a time window or point in time, such as operations within a specific time period or rules triggered at a set time. Triggering conditions are described using predicate logic expressions, supporting AND, OR, and NOT logical combinations. Execution effects describe the impact of the mapping rule execution on data and state, including three dimensions: data change effects, state transition effects, and constraint impact effects. Data change effects record the changes in data fields after rule execution; state transition effects record the path of object state changes; and constraint impact effects record the degree of influence of the rule on relevant constraints.

[0136] The marking information is stored in the attribute fields of the mapping rule nodes, the triggering conditions are stored as structured expression objects, and the execution effect is stored as a multi-dimensional influence vector. The expression object contains elements such as operators, operands, and logical relationships, and supports dynamic parsing and calculation. The influence vector is represented numerically, with dimensions corresponding to different influence types, and the numerical value representing the strength and direction of the influence. Positive values ​​represent positive influences, negative values ​​represent negative influences, and absolute values ​​represent influence strength. The marking process uses parallel processing, with multiple worker threads processing different mapping rule nodes simultaneously. The number of threads is dynamically adjusted based on the number of processor cores, defaulting to twice the number of processor cores. The marking results are cached in memory for 30 minutes, supporting incremental update mode.

[0137] The dependency edge effect analysis evaluates the contribution of each dependency edge in the constraint conflict propagation process using a propagation analyzer. Propagation analysis is based on a data flow propagation model, simulating how data changes propagate along dependency edges to downstream nodes. Propagation strength calculation considers three factors: data coupling degree, time delay, and change amplification factor. Data coupling degree is calculated based on the semantic relevance of the source and target fields; fully related fields have a coupling degree of 1.0, partially related fields have a coupling degree of 0.5, and unrelated fields have a coupling degree of 0.1. Time delay is calculated based on the time interval between operations; shorter delays result in higher propagation strength, using an exponential decay model with a decay coefficient of 0.9. The change amplification factor describes the amplification or reduction effect of changes during propagation, and is statistically derived by analyzing historical data change propagation patterns.

[0138] The effectiveness is quantified using propagation impact as the metric, which equals propagation intensity multiplied by the importance weight of downstream nodes. Downstream node importance is assessed based on three dimensions: out-degree, constraint relevance, and business priority. Out-degree represents the number of subsequent dependent nodes; a higher out-degree indicates greater importance. Constraint relevance represents the degree of association between a node and constraints, calculated by analyzing the impact of node changes on constraint satisfaction. Business priority is determined by business rule configuration, with core business nodes having higher priority than auxiliary business nodes. Importance weights are calculated using a weighted average, with weights allocated as follows: out-degree 0.4, constraint relevance 0.4, and business priority 0.2. Propagation impact ranges from 0 to 10; a higher value indicates a more significant effect of the dependent edge.

[0139] Contribution calculation is based on the product of propagation impact and conflict relevance. Conflict relevance measures the degree of association between the propagation effect of a dependency edge and the constraint conflict, calculated by analyzing the overlap between the propagation path and the conflict-generating path. Dependency edges with high overlap have higher conflict relevance, while those with low overlap have lower conflict relevance. The formula for calculating conflict relevance is the number of overlapping nodes divided by the total number of propagation nodes, with a value ranging from zero to one. Contribution is represented using a numerical range of zero to one hundred to facilitate subsequent weight calculation and comparative analysis. After contribution calculation, normalization is performed to ensure that the sum of the contributions of all dependency edges is one hundred. The contribution distribution is verified using the Pareto principle; typically, 20% of dependency edges generate 80% of the contribution.

[0140] The weight matrix is ​​constructed using a sparse matrix format to store the contribution distribution of dependent edges. The matrix dimension is the square of the number of nodes involved in the mapping operation. Row indices represent source nodes, column indices represent target nodes, and matrix elements represent the contribution of the corresponding dependent edge. The sparse matrix is ​​stored in a compressed sparse row format, storing only non-zero elements and their position information, saving storage space and improving computational efficiency. The matrix supports fast row and column lookups, matrix multiplication, eigenvalue calculations, and other linear algebra operations. Weight matrix updates use an incremental calculation method; when a dependent edge is added or deleted, only the relevant matrix elements are updated, avoiding the performance overhead of full reconstruction. Matrix storage supports persistence to disk, using binary format, with loading time controlled within ten seconds. Matrix version management maintains snapshots of historical versions, supporting version rollback and difference comparison functions.

[0141] Influence quantification comprehensively evaluates nodes in the mapping rules based on a weight matrix. The quantification algorithm employs centrality metrics from network analysis to calculate the importance of nodes in the dependency graph. Degree centrality is calculated based on the in-degree and out-degree of a node; a higher degree indicates stronger connectivity. Proximity centrality is calculated based on the shortest path length from a node to all other nodes; shorter paths indicate better reachability. Betweenness centrality is calculated based on the number of shortest paths passing through a node; more paths indicate stronger hub function. Eigenvector centrality is recursively calculated based on the importance of a node's neighbors; more important neighbors indicate higher node importance. The overall influence is calculated as a weighted average of the four centrality metrics, with weights allocated as follows: degree centrality 0.3, proximity centrality 0.2, betweenness centrality 0.3, and eigenvector centrality 0.2.

[0142] The impact degree calculation combines the overall impact of a node with the direct correlation of constraint conflicts. Direct correlation is calculated by analyzing the matching degree between the node's execution effect and the constraint conditions; the higher the matching degree, the stronger the correlation. Correlation assessment uses semantic similarity calculation, converting the node's execution effect and constraint conditions into vector representations and calculating the cosine similarity between vectors. Vectorization uses word embedding technology to convert text descriptions into high-dimensional vectors, with a vector dimension of 300. The similarity threshold is set to 0.7; nodes exceeding this threshold are considered directly related to constraint conflicts. The impact degree equals the overall impact degree multiplied by the direct correlation, ranging from 0 to 10; a larger value indicates a more severe impact of the node on constraint conflicts. The impact degree calculation uses a batch processing method, processing 100 nodes per batch, with a processing time controlled within five seconds.

[0143] Weight factors are generated by normalizing the distribution characteristics of influence levels. The normalization method uses maximum and minimum value standardization to map the influence level to the range of zero to one. The mapping formula is the current value minus the minimum value, divided by the difference between the maximum and minimum values. Weight factor precision is retained to four decimal places to ensure calculation accuracy while avoiding over-precision. Weight factor validation assesses model stability using cross-validation, employing five-fold cross-validation. Validation metrics include mean absolute error (MAO), root mean square error (RMSE), and correlation coefficient. The MAO must be less than 0.05, the RMSE less than 0.1, and the correlation coefficient greater than 0.9. After successful validation, the weight factors are stored in the influence weight model, using a key-value pair format. The key is the mapping rule node identifier, and the value is the corresponding weight factor.

[0144] The weighted model is built using machine learning methods to optimize the prediction accuracy of weight factors. Model input features include the complexity of node trigger conditions, the range of execution effects, historical execution frequency, and error rate. Trigger condition complexity is calculated based on the logical complexity of the conditional expression, including factors such as the number of conditional branches, nesting levels, and the number of variables. The range of execution effects is calculated based on the number of fields and objects affected; a larger range indicates a greater degree of influence. Historical execution frequency statistics show the number of times the rule was executed in the past week; higher frequency indicates higher rule activity. Error rate statistics show the proportion of errors generated during rule execution; a higher error rate indicates poorer rule stability. Model training uses a random forest algorithm with 100 trees, a maximum depth of 10 layers, and a minimum split sample size of 5. Model evaluation uses the hold-out method, with a training set to test set ratio of 8:2. Evaluation metrics include accuracy, recall, and F1 score, all requiring a minimum of 90%.

[0145] In the specific data example, the root cause of the conflict is the payment status update operation, and the conflict node is the order status verification operation. The change path includes four mapping operations: payment status update, account balance check, order status synchronization, and order status verification. The mapping operation dependency graph consists of four nodes and three dependency edges. The trigger condition for the payment status update node is that the payment amount is greater than zero and the account balance is sufficient. The execution effect is to update the payment status from pending payment to paid. The trigger condition for the account balance check node is that the payment operation is initiated. The execution effect is to verify whether the account balance meets the payment amount requirement. Dependency edge analysis shows that the propagation impact from payment status update to account balance check is 8.5, the propagation impact from account balance check to order status synchronization is 7.2, and the propagation impact from order status synchronization to order status verification is 9.1. The contribution calculation results are 35.2, 28.6, and 36.2, respectively. The weight matrix is ​​a 4x4 sparse matrix with three non-zero elements, located at positions 1-2, 2-3, and 3-4. The quantification of impact shows that the overall impact of the payment status update node is 7.8, the account balance check node is 6.1, the order status synchronization node is 8.3, and the order status verification node is 5.9. After normalization, the weighting factors are 0.94, 0.73, 1.00, and 0.71, respectively. The impact weighting model predicts that the payment status update node has the highest impact on constraint conflicts, with a weighting factor of 1.00, making it a key target for strategy adjustments.

[0146] The method further includes:

[0147] The specific implementation of the model-based system lifecycle management system includes a management center module, a three-person management module, a confidentiality management module, an access control module, a project modeling module, a project application module, a project creation module, a task view management module, a task basic operation module, a task approval and release module, a deliverable management module, a milestone management module, a work hour management module, a project statistics and visualization management module, an integration module, and a workbench management module.

[0148] The management center module undertakes the core management functions of the system. The organization management function receives input data such as organization name, organization number, sort value, and parent organization unique code. It performs data integrity checks, including format validation, range checks, and mandatory field checks. It also performs a global duplicate check on organization names and numbers to ensure uniqueness. The validated data is then stored in the database through persistence. The role authorization function receives role name, role description, and role type parameters. It performs format validation, range checks, and mandatory field checks on the input data. It retrieves the role name parameter and performs a global duplicate check. The processed role data is then persistently stored in the database. The user management function supports input of username, employee ID, real name, gender, email address, mobile phone number, major, and remarks. It performs data format validation and reasonableness checks, performs a global uniqueness check on usernames and employee IDs, and then persists the data.

[0149] The three-tiered management module separates the responsibilities of system administrators, security administrators, and audit administrators. System administrators create dedicated accounts via scripts, granting them the ability to set up, maintain, manage permissions, and add, delete, modify, and query user data. Security administrator accounts, also created via scripts, have the ability to freeze and unfreeze system administrator and audit user accounts, as well as manage the operation logs of ordinary users and auditors. Audit administrator accounts, similarly created via scripts, use the log management module to audit and supervise the actions of system administrators and security administrators.

[0150] The security classification management module establishes a mapping relationship between personnel security classifications and project security classifications. The user security classification list function receives user parameter information, performs data format validation and permission verification, checks security classification permissions through user role details, and queries the user security classification and project security classification association table based on user security classification information to display the merged security classification information. The user security classification setting function receives user codes and user security classification parameters, performs data integrity verification, obtains specific information about users and user security classifications and performs existence verification, and persists the processed data. The project security classification management function displays the corresponding project security classification list based on user security classifications and parent project security classifications, and retrieves project security classification details by querying the association table based on user security classification information.

[0151] The access control module is divided into policy-based access control and project-based access control. Policy-based access control determines the relevant policies for each project type by associating types and policies, establishes the relationship between the lifecycle and policies, determines the access points and user roles for each state, and configures the relationship between access points and users to achieve access control. Project-based access control establishes corresponding roles for different functional permissions within the project, determines the scope of users participating in the project, and assigns space roles to selected project items and space personnel.

[0152] The project modeling module includes project model definition and project model application functions. The attribute definition function receives attribute names, interface types, interface names, and attribute constraint parameters, performs data format validation and rationality verification, binds attribute parameters to system-defined fields, and persists them. The model definition function allows users to select multiple attributes that make up the model, choose a system-defined strategy, and input the model name, code, description, and business type information. It processes the model attributes, strategy, and its own information into system data format and persists it. The lifecycle definition function allows users to input lifecycle names, codes, and descriptions, add lifecycle nodes in the required order, perform data validation, bind parameters to system fields, and persist them.

[0153] The project application module supports project registration and project initiation. The project registration function receives basic project information parameters, performs format validation and rationality checks to ensure the completeness of the application information, supports uploading relevant supporting materials, and persists the processed project registration data. The project initiation function allows linking the corresponding project registration form when creating a project initiation form, setting information such as the person in charge, budget, and initiation time, and after data validation, binding the attribute values ​​of the initiation form to the corresponding system mapping fields and persisting them.

[0154] The project creation module enables the creation of three types of projects: projects, phases, and tasks. The project creation function supports linking project filing forms and project initiation forms, receiving basic information such as project name, description, responsible person, start time, and end time. It performs format and uniqueness checks, binds project attribute values ​​to corresponding system-mapped data fields, and persists the data. The phase creation function decomposes each phase within the project structure, receiving phase name, start time, end time, and responsible person information. After data validation, it binds phase attribute values ​​to system fields and persists the data. The task creation function supports decomposing tasks within the phase structure, supporting both manual entry and batch import methods. It receives information such as task name, start time, end time, responsible person, and estimated working hours, initializes the task lifecycle state, and persists the data.

[0155] The task view management module offers four display modes: list view, Kanban view, calendar view, and Gantt chart. The list view receives stage code, stage type, and task type parameters, performs data format validation, and verifies security and business permissions based on role and user details to obtain the task list for each stage visible to the user. The Kanban view displays task status in card format, including four states: not started, in progress, completed, and delayed, and supports drag-and-drop functionality to update task status. The calendar view provides monthly, weekly, and daily view modes, intuitively displaying task time distribution and node arrangements. The Gantt chart graphically displays task schedules, progress, and dependencies, reflecting real-time comparisons of task completion with the plan.

[0156] The basic task operation module supports tasks such as creating replicas, batch modification, assignment, workflow association, subscription, transferring ownership, permission allocation, closing, and deletion. The replica creation function receives object data parameters, performs type model validation, filing status validation, and code existence validation. It verifies whether the object contains children and retrieves all child instance data. It generates the corresponding code based on the code generator configuration and persists the initialized replica data. The batch modification function receives the task entries and field attribute values ​​to be modified, performs data integrity validation, retrieves the stage model validation including type consistency, and performs unified persistence processing on the selected tasks based on attribute fields and attribute values.

[0157] The task approval and release module enables controlled management of task data. The task approval function initiates the approval process upon receiving an application from an approver or the system, performs preliminary evaluation and review, makes decisions based on preset rules and standards, and terminates the process and records the results when the termination conditions are met. The task release function directly puts the task into the version release state with a single release. By inputting process template parameters and task parameters, the system generates a process task based on the template and assigns an approver. The approver reviews the task, executes it, and proceeds to the next node. After the process is completed, the task status is changed to the final version status.

[0158] The deliverable management module includes deliverable target definition and deliverable submission functions. The deliverable target definition function receives deliverable target attribute parameters, performs format validation and range validation, binds the deliverable target attribute values ​​to the corresponding system mapping fields, and persists them. The deliverable submission function supports selecting the deliverable to be submitted, uploading the corresponding file, performing file format checks and size limit validation, recording the submission time and submitter information, and associating the deliverable with related tasks.

[0159] The milestone management module is used to set and track important project milestones. The milestone creation function allows setting critical tasks as milestone nodes, receiving milestone name parameters and performing name duplication checks within the same phase, and marking and displaying selected tasks as milestones. The milestone management function also supports canceling milestone settings, restoring critical node tasks to ordinary nodes, and provides a critical task filtering function for quick location and viewing of critical tasks.

[0160] The work hour management module includes work hour registration and work hour recording functions. The work hour registration function receives task entry parameters, verifies the work date, work duration, and work description inputs, performs estimated work hour registration verification and remaining work hour verification, and calculates remaining work hours, progress, and estimated deviation based on registered and estimated work hours. The work hour recording function receives task code and task type parameters, performs data format verification and permission verification, and retrieves user-visible task work hour record details based on permission verification and task type code.

[0161] The project statistics and visualization management module is responsible for collecting, analyzing, and displaying project data. The overall overview function provides statistics on task progress status, phase duration, estimated work hours, registered work hours, remaining work hours, and work progress data for each project or phase. Lifecycle status statistics use pie charts to show the percentage of tasks at each lifecycle stage. Deliverable statistics use clustered bar charts to compare the delivery targets and quantities of each task. Actual work hour statistics use stacked bar charts to show the percentage of registered work hours and remaining work hours. Estimated work hour statistics use clustered bar charts to compare estimated and actual work hours. Delayed task statistics use bar charts to show the number of days of delay for each delayed task.

[0162] The integration module integrates functions from different systems. The SysML integration function identifies the tasks to be associated within the SysML model management system, determines deliverable creation permissions, and processes the model project name as the delivery target, the model name as the deliverable name, and the model code and source path as the deliverable file address, performing security level and business permission checks. The document management integration function selects the specified deliverable from the task, queries the specific file path attribute based on the deliverable object code, and passes the file path to the document management module for previewing, editing, or annotation operations.

[0163] The workbench management module provides a centralized management area. The calendar tool retrieves the current operator's code based on login information, and then displays the user's assigned task data in calendar format based on the current time and user code. The task to-do function retrieves the number of all pending tasks and the total number of tasks based on the current user's code, providing a quick access point to the task management module. The data statistics function retrieves the project data visible to the user based on the current time and user code, displaying project progress and time statistics in chart format.

[0164] This system achieves model-based system engineering management through modular design, supports flexible configuration to adapt to the needs of different project types, establishes data dependencies to reduce information silos, and ensures data consistency and effective access control throughout the entire lifecycle through unified data source management.

[0165] A second aspect of this invention provides a system lifecycle management system based on MBSE, comprising:

[0166] The first unit is used to obtain the data objects to be synchronized, change event identifiers and business context information in the source system, perform semantic analysis on the data objects to be synchronized, extract the entity type, attribute features and inter-object dependencies of the data objects to be synchronized, and construct a semantic graph structure in combination with the business context information.

[0167] The second unit is used to analyze the data models of the source system and the target system based on the semantic graph structure, learn the implicit association between the source system and the target system through semantic matching, and dynamically generate a mapping strategy that considers data integrity constraints based on the dependencies between the objects.

[0168] The third unit is used to determine the execution order of synchronization operations according to the mapping strategy. When a dependency relationship is detected between objects, it organizes multiple related data objects into an atomic synchronization transaction and performs transactional data transmission to the target system according to the data flow path in the semantic graph structure.

[0169] The fourth unit is used to construct a temporal tracing tree during the synchronization process, obtain the synchronization result from the target system, associate the synchronization result with the corresponding node of the temporal tracing tree and calculate the change propagation range, dynamically deduce the nodes within the change propagation range based on the business constraint rules in the semantic graph structure, and when a constraint conflict is detected, trace back to the root cause of the conflict along the change path of the temporal tracing tree, and adaptively reconstruct the mapping strategy based on the result of the dynamic deduction.

[0170] A third aspect of the present invention provides an electronic device, comprising:

[0171] processor;

[0172] Memory used to store processor-executable instructions;

[0173] The processor is configured to invoke instructions stored in the memory to execute the aforementioned method.

[0174] A fourth aspect of the present invention provides a computer-readable storage medium having stored thereon computer program instructions that, when executed by a processor, implement the aforementioned method.

[0175] This invention can be a method, apparatus, system, and / or computer program product. The computer program product may include a computer-readable storage medium having computer-readable program instructions loaded thereon for performing various aspects of the invention.

[0176] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some or all of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the embodiments of the present invention.

Claims

1. A system lifecycle management method based on MBSE, characterized in that, include: Obtain the data objects to be synchronized, change event identifiers, and business context information from the source system; perform semantic analysis on the data objects to be synchronized; extract the entity types, attribute features, and inter-object dependencies of the data objects to be synchronized; and construct a semantic graph structure in conjunction with the business context information. Based on the semantic graph structure, the data models of the source system and the target system are analyzed. The implicit association between the source system and the target system is learned through semantic matching. Based on the dependency relationship between the objects, a mapping strategy that considers data integrity constraints is dynamically generated. The execution order of synchronization operations is determined according to the mapping strategy. When a dependency relationship is detected between objects, multiple related data objects are organized into an atomic synchronization transaction, and transactional data transmission is performed to the target system according to the data flow path in the semantic graph structure. During the synchronization process, a temporal tracing tree is constructed, synchronization results are obtained from the target system, the synchronization results are associated with the corresponding nodes of the temporal tracing tree, and the change propagation range is calculated. Based on the business constraint rules in the semantic graph structure, the nodes within the change propagation range are dynamically extrapolated, including: Construct a time-series tracing tree and record the change status and time-series information of the nodes. Obtain the synchronization result of the data object to be synchronized from the target system. Compare the final status information in the synchronization result with the change content of the corresponding node in the time-series tracing tree in multiple dimensions. Identify the set of nodes that have undergone status changes through the comparison results. For each node in the node set, the temporal dependencies recorded in the temporal tracing tree are traced downstream, and the cross-entity dependencies in the semantic graph structure are combined to identify related entities, thus constructing a change propagation network that includes nodes that directly affect nodes and nodes that indirectly affect nodes. Based on the business constraint rules in the semantic graph structure, the node states in the change propagation network are dynamically deduced. By verifying the degree of matching between the current state of the node and the constraint conditions, the constraint satisfaction of each node in the change propagation network is evaluated. The impact range of constraint violations is calculated based on the connection strength, and constraint verification results containing violation levels are generated. When a constraint conflict is detected, the change path of the time-series source tree is traced back to the root cause of the conflict, and the mapping strategy is adaptively reconstructed based on the results of the dynamic deduction.

2. The method according to claim 1, characterized in that, Based on the semantic graph structure analysis of the source system and target system data models, implicit associations between the source system and target system are learned through semantic matching, and mapping strategies considering data integrity constraints are dynamically generated according to the dependencies between objects, including: Based on the entity type and attribute semantics in the semantic graph structure, semantic similarity is calculated between the data model nodes of the source system and the data model nodes of the target system to identify node pairs with equivalent semantics or inclusion relationships, thereby obtaining a semantic alignment candidate set. By aggregating the neighborhood features of node pairs in the semantic alignment candidate set on the semantic graph structure through graph convolution propagation mechanism, the implicit association pattern between the source system and the target system across explicit attribute mapping is learned, and an implicit association representation is obtained. Based on cross-entity dependencies in semantic data representation, a dependency propagation path is constructed between the data object to be synchronized and its associated data objects, and the set of data objects that need to maintain integrity is determined according to the dependency propagation path. Based on the implicit association representation and the set of data objects, a mapping strategy containing a mapping priority sequence and integrity constraint verification rules is generated.

3. The method according to claim 2, characterized in that, By aggregating neighborhood features of node pairs in the semantic alignment candidate set on the semantic graph structure through graph convolution propagation mechanism, implicit association patterns across explicit attribute mappings between the source system and the target system are learned, resulting in implicit association representations including: For each node pair in the semantic alignment candidate set, the initial feature vectors of the data model nodes of the source system and the data model nodes of the target system in the semantic graph structure are extracted; Based on the initial feature vector, multi-hop neighborhood expansion is performed along the edges constructed along the cross-entity dependency relationship on the semantic graph structure. For each node pair, the feature vectors of the neighboring nodes in its multi-hop neighborhood are aggregated, and the influence weights of different neighboring nodes on the current node pair are calculated through the graph convolution propagation mechanism to obtain the neighborhood aggregation feature. The data model node features of the source system and the data model node features of the target system in the neighborhood aggregation features are projected onto the shared semantic space. By minimizing the distance between semantically equivalent node pairs in the shared semantic space and maximizing the distance between semantically irrelevant node pairs, the neighborhood aggregation features are cross-domain aligned to obtain the aligned cross-domain feature representation. Based on the aligned cross-domain feature representation, the semantic similarity between the data model nodes of the source system and the data model nodes of the target system is calculated in the shared semantic space. The structured association pattern that does not rely on explicit attribute name matching is identified, and the node correspondence in the structured association pattern is encoded into an implicit association representation.

4. The method according to claim 1, characterized in that, The execution order of synchronization operations is determined according to the mapping strategy. When a dependency relationship is detected between objects, multiple related data objects are organized into an atomic synchronization transaction, and transactional data transmission is performed to the target system according to the data flow path in the semantic graph structure, including: The priority information and constraint rules contained in the mapping strategy are parsed to obtain the execution order of the synchronization operations of the data objects to be synchronized, and the data objects to be synchronized are traversed according to the execution order to detect the dependency relationships between the data objects to be synchronized. When a dependency relationship is detected between the data objects to be synchronized, multiple related data objects are identified, and the multiple related data objects are organized into an atomic synchronization transaction to construct a set of transaction data objects. For the set of transactional data objects, the data flow path of each data object in the set of transactional data objects is obtained from the semantic graph structure. Based on the transmission route and transmission order identified in the data flow path, the transactional data transmission of the set of transactional data objects is executed to the target system. During the execution of the transactional data transmission, the synchronization status of all data objects in the transactional data object set is monitored in real time. When the transmission of any data object in the transactional data object set fails, the synchronization operation of all data objects in the transactional data object set is rolled back according to the synchronization status.

5. The method according to claim 1, characterized in that, When a constraint conflict is detected, the change path of the time-series source tree is traced back to the root cause of the conflict, and the mapping strategy is adaptively reconstructed based on the results of the dynamic inference, including: When a constraint conflict is detected, the conflict node where the constraint conflict occurs is located in the time-series tracing tree. Based on the change path information recorded in the time-series tracing tree, the conflict node is traced backward to identify the root cause node of the constraint conflict. From the root node of the conflict to the conflict node, construct a mapping operation dependency graph on the change path, analyze the contribution of each mapping rule in the mapping operation dependency graph to the constraint conflict, and establish an influence weight model of the mapping rule. The results of the dynamic simulation are analyzed, and the differences between the constraints and actual states of each node within the propagation range are modeled. Combined with the influence weight model of the mapping rules, the relevant mapping rules in the mapping strategy are adjusted in a targeted manner to generate a reconstruction mapping strategy that satisfies the constraints.

6. The method according to claim 5, characterized in that, From the root node of the conflict to the conflict node, a mapping operation dependency graph is constructed on the change path. The contribution of each mapping rule in the mapping operation dependency graph to the constraint conflict is analyzed, and an influence weight model of the mapping rules is established, including: A mapping operation dependency graph is constructed from the conflict root node to the conflict node, and the triggering conditions and execution effects of the mapping rule nodes are marked in the mapping operation dependency graph; The effect of each dependency edge in the mapping operation dependency graph on the constraint conflict propagation process is analyzed, and the contribution of the dependency edge is calculated based on the effect. A weight matrix reflecting the distribution of the contribution of the dependency edge is constructed. The influence of the mapping rule nodes in the mapping operation dependency graph is quantified according to the weight matrix, the degree of influence of each mapping rule node on constraint conflict is calculated, and the degree of influence is used as a weight factor to establish an influence weight model.

7. A system lifecycle management system based on MBSE, used to implement the method of any one of claims 1-6, characterized in that, include: The first unit is used to obtain the data objects to be synchronized, change event identifiers and business context information in the source system, perform semantic analysis on the data objects to be synchronized, extract the entity type, attribute features and inter-object dependencies of the data objects to be synchronized, and construct a semantic graph structure in combination with the business context information. The second unit is used to analyze the data models of the source system and the target system based on the semantic graph structure, learn the implicit association between the source system and the target system through semantic matching, and dynamically generate a mapping strategy that considers data integrity constraints based on the dependencies between the objects. The third unit is used to determine the execution order of synchronization operations according to the mapping strategy. When a dependency relationship is detected between objects, it organizes multiple related data objects into an atomic synchronization transaction and performs transactional data transmission to the target system according to the data flow path in the semantic graph structure. The fourth unit is used to construct a temporal tracing tree during the synchronization process, obtain the synchronization result from the target system, associate the synchronization result with the corresponding node of the temporal tracing tree and calculate the change propagation range, dynamically deduce the nodes within the change propagation range based on the business constraint rules in the semantic graph structure, and when a constraint conflict is detected, trace back to the root cause of the conflict along the change path of the temporal tracing tree, and adaptively reconstruct the mapping strategy based on the result of the dynamic deduction.

8. An electronic device, characterized in that, include: processor; Memory used to store processor-executable instructions; The processor is configured to invoke instructions stored in the memory to execute the method according to any one of claims 1 to 6.

9. A computer-readable storage medium having computer program instructions stored thereon, characterized in that, When the computer program instructions are executed by the processor, they implement the method described in any one of claims 1 to 6.

Images