Intelligent change order tracking system based on semantic modeling

Abstract

The present application relates to the technical field of computer data processing and engineering information tracing, in particular to an engineering change intelligent tracing system based on semantic modeling. The system parses different versions of engineering requirements, design parameters, constraint conditions, interface definitions and verification records into semantic units, generates cross-version stable semantic anchor points; based on the semantic anchor points, a state layer and a causal layer are constructed, irrelevant modifications are isolated from the pre-change semantic snapshot, candidate upstream changes are played back in reverse according to the constraint propagation direction, a theoretical downstream difference set is formed, and the actual version difference set is matched in terms of object, change direction, constraint state and propagation order, causal edges are screened, and a change tracing chain is generated. The present application can maintain the identity continuity of objects during renaming, migration, splitting and merging, distinguish real change relationships from temporal co-occurrence relationships, and make the change source, propagation path, intermediate constraints and affected objects form a continuous and verifiable tracing result.

Description

Technical Field

[0001] This invention relates to the field of computer data processing and engineering information traceability technology, specifically to an intelligent traceability system for engineering changes based on semantic modeling. Background Technology

[0002] Engineering change tracking falls under the fields of engineering data management and computer data processing. Existing systems typically record the version status of engineering objects using documents, drawings, requirement items, configuration items, or data tables, and establish traceability relationships through version numbers, modification times, commit records, and reference links. The conventional approach is to save copies of the files before and after each change commit, or records of differences, and generate version comparison results using character additions / deletions, field changes, and object identifier changes, then connect the relevant records in chronological order. For structured data, the system usually identifies the same object based on object number, field name, and database primary key. For unstructured documents, it establishes version correspondences through paragraph position, keyword matching, text similarity, or reference tags. While such solutions can record when a file was modified and which fields changed, the establishment of traceability chains mainly relies on surface-level identifiers and temporal associations, making it difficult to reflect the actual transmission relationships between engineering objects formed by constraints, interface relationships, and technical dependencies.

[0003] Prior art close to this invention introduces semantic modeling or knowledge graphs, extracting requirement items, design parameters, interface definitions, configuration items, and verification records as nodes, and constructing a relational graph with references, inclusions, dependencies, constraints, or mappings. After the system detects a change in a node, it propagates downstream along pre-established relational edges to obtain a set of potentially affected objects. Some solutions also match objects in different versions based on semantic vector similarity, contextual similarity, or manually defined rules. Such techniques can express finer-grained relationships than simple file comparison, but their node identities are still easily affected by object renaming, paragraph migration, item splitting, item merging, and expression rewriting. Existing relational graphs also mostly use static binary connections, and candidate propagation paths are usually directly retained based on relational strength or preset rules, lacking consistency verification between the pre-change state, post-change state, and actual propagation results, thus making it impossible to confirm whether a certain relational edge corresponds to a real technical causal relationship.

[0004] Another type of existing technology employs change impact analysis, inferring the impact of upstream modifications on downstream objects based on version order, dependency direction, and rule base. Its conventional process involves extracting the differences between the current and previous versions, using the differing objects as change sources, searching for related objects along the dependency graph, and then generating an impact list based on propagation level, association weight, or manually defined scope. Some systems post-process the impact list by combining test results or verification records, while others observe whether multiple objects change together within a similar timeframe by replaying historical versions. These methods still primarily rely on temporal proximity, path reachability, or co-occurrence of results as the main criteria. When the same change cycle includes technical modifications, formatting adjustments, supplementary explanations, and batch version submissions, multiple objects without direct transmission relationships may form similar change trajectories. Due to the lack of a processing mechanism to apply a single candidate upstream change to the pre-change semantic state and compare it with the actual subsequent differences, existing methods struggle to exclude candidate paths that only have co-occurrence relationships.

[0005] When an engineering object undergoes renaming, migration, splitting, merging, or rewriting, and multiple parallel modifications occur within the same version cycle, how can we maintain the continuity of the semantic identity of the engineering object across versions and reproducibly verify whether candidate upstream changes actually cause downstream differences? How can we identify the true causal chain of changes from a large number of temporal co-occurrence relationships, reference relationships, and reachability relationships? Existing solutions rely on object number, text position, similarity, modification time, or static dependency edges to establish tracing relationships. This cannot stably correspond to the same engineering object after the surface form changes, nor can it prove the causal validity of candidate relationships through semantic snapshots before changes, application of candidate changes, constraint propagation, and comparison of actual differences. As a result, the generated tracing results may be mixed with unrelated modifications during the same period, or interrupted at the point of object identity change, making it impossible to form a continuous and verifiable logical chain between the change source, propagation path, intermediate constraints, and the final affected object. Summary of the Invention

[0006] The purpose of this invention is to provide an intelligent traceability system for engineering changes based on semantic modeling, which can solve the problems mentioned in the background art.

[0007] To achieve the above objectives, the technical solution adopted by the present invention is as follows:

[0008] The intelligent engineering change traceability system based on semantic modeling includes a semantic parsing and processing structure, a temporal relationship construction structure, a counterfactual playback structure, and a causal chain determination structure.

[0009] The semantic parsing processing structure parses engineering requirement items, design parameters, constraints, interface definitions, configuration items and verification records from different versions into semantic units containing object semantics, attribute semantics, constraint semantics, relational semantics and change intent, and generates cross-version stable semantic anchors.

[0010] The temporal relation construction structure establishes a state layer that records the evolution of semantic states and a causal layer that records candidate causal relations based on the stable semantic anchor points;

[0011] The counterfactual replay structure applies candidate upstream changes to the semantic snapshot before the change and forms a theoretical downstream difference set.

[0012] The causal chain determination structure filters causal edges based on the matching results between the theoretical downstream difference set and the actual subsequent version difference set, and generates an engineering change traceability chain consisting of change source, propagation path, intermediate constraints and affected objects.

[0013] Preferably, the semantic parsing processing structure forms a role semantic fingerprint according to the functional role, controlled attributes, constraint participation method and adjacency dependency relationship of the engineering object in the context, and excludes the object name, storage location and text expression from the main identifier field of the stable semantic anchor;

[0014] For candidate semantic units in previous and subsequent versions, an initial correspondence is first established based on functional roles and constraint participation methods. Then, the initial correspondence is corrected based on the consistency of the adjacency dependency relationship, and the corrected correspondence is written into the anchor inheritance record.

[0015] When a single semantic unit corresponds to multiple subsequent semantic units or multiple preceding semantic units correspond to a single subsequent semantic unit, the split mapping or merge mapping is stored in the anchor inheritance record respectively, and a source anchor, a target anchor, and a semantic contribution range are added to each mapping.

[0016] Preferably, the temporal relationship construction structure writes the existence state, attribute state, constraint state and association state of each stable semantic anchor point at each version time into the state layer, and generates candidate causal edges with consistent relationships of semantic dependency, constraint propagation direction, version order and change intention.

[0017] Each candidate causal edge includes a source anchor, a target anchor, a triggering constraint, an expected state transition, and a valid version range;

[0018] For downstream changes triggered by multiple upstream anchor points, multiple source anchor points and their joint triggering conditions are encapsulated into the same composite candidate edge. The participating anchor point set, joint constraint set, and state transition order corresponding to the composite candidate edge are stored in the causal layer. The joint triggering conditions participate in the causal edge screening in the form of an indivisible composite relationship.

[0019] Preferably, the counterfactual replay structure extracts a semantic snapshot of the upstream change corresponding to the candidate causal edge from the state layer before the upstream change occurs, isolates concurrent modifications unrelated to the candidate upstream change, applies the candidate upstream change to the semantic snapshot according to its change intention and constraint propagation direction, and performs state propagation along the constraint relationship associated with the candidate causal edge to form a theoretical downstream difference set containing the expected change object, expected attribute difference, expected constraint transformation and expected propagation order;

[0020] The causal chain determination structure maps the theoretical downstream difference set to the actual subsequent version difference set item by item according to the object overlap, change direction, constraint state and propagation order, and retains only the candidate causal edges that have a common stable semantic anchor point and do not have opposite state transitions.

[0021] Preferably, the semantic parsing processing structure calculates the attribute inheritance fragment, constraint inheritance fragment, and relation inheritance fragment of each target anchor point in the split mapping, and registers the semantic fragments that are not inherited by any target anchor point as disappearing fragments;

[0022] Calculate the semantic preservation range of each source anchor in the target anchor for each source anchor in the merge mapping, and register the conflicting attributes or constraints between source anchors as merge conflict fragments;

[0023] The stable semantic anchor point consists of a constant core identifier and an evolvable branch identifier. The constant core identifier is associated with common engineering objects before splitting or merging. The evolvable branch identifier is associated with each inherited fragment, disappeared fragment, and merged conflict fragment, and records the branch generation, branch termination, and branch merging relationships in version order.

[0024] Preferably, the temporal relationship construction structure establishes a temporal consistency constraint set for the candidate causal edges in the causal layer. The temporal consistency constraint set at least stipulates that the source state change precedes the target state change, the triggering constraint remains valid during propagation, and there are no mutually exclusive states coexisting at the same stable semantic anchor point.

[0025] When the candidate causal edges form a closed loop, extract the effective version range, change intention direction and constraint state transition of each candidate causal edge within the closed loop, and delete the candidate causal edges that cannot satisfy the time-series consistency constraint set.

[0026] For composite closed loops that still satisfy temporal consistency, the causal layer is reconstructed according to the combination that can retain the most actual difference correspondences and contain the fewest candidate causal edges, and the excluded candidate causal edges are temporarily stored as temporal coexistence relations.

[0027] Preferably, the counterfactual replay structure establishes a local replay domain based on the stable semantic anchor points involved in the candidate upstream changes. The local replay domain includes associated anchor points that have a constraint transmission relationship with the stable semantic anchor points and are located within a set propagation level, and freezes the semantic state outside the local replay domain.

[0028] Within the local replay domain, candidate upstream changes are decomposed into at least one change operator among object addition / deletion, attribute replacement, constraint tightening, constraint relaxation, relationship migration, and change intent adjustment. These operators are applied one by one according to their order in the actual version, and the intermediate semantic state is saved after each change operator is applied.

[0029] The theoretical downstream difference set is generated by the final semantic state operator and each intermediate semantic state, and retains the first trigger anchor point and propagation constraints corresponding to each theoretical difference.

[0030] Preferably, the causal chain determination structure establishes an explanation set for multiple candidate causal edges corresponding to the same actual downstream difference, and each candidate causal edge in the explanation set carries a theoretical difference coverage term, a constraint state transition term, and a propagation order term;

[0031] First, remove redundant candidate causal edges whose theoretical difference coverage terms are completely contained by other candidate causal edges and do not add new constraint state transition terms. Then, select from the remaining candidate causal edges the combination that can cover all actual downstream differences, maintain consistent propagation order, and minimize the number of source anchors.

[0032] When multiple combinations have the same number of source anchors, a unique interpretation set is determined according to the continuity of the stable semantic anchors and the completeness of the constraint state transition, and the unique interpretation set is written into the engineering change traceability chain.

[0033] Preferably, the causal layer establishes a branch propagation record for stable semantic anchors with evolvable branch identifiers. The branch propagation record associates each candidate causal edge with a specific inherited fragment, a disappeared fragment, or a merged conflict fragment, and uses the constant core identifier as a cross-branch association index.

[0034] When split mapping occurs, candidate causal edges for branches are generated according to the actual constraint states carried by each inherited segment. The candidate causal edges of the source anchor point are only written to the target anchor point corresponding to the inherited constraint state.

[0035] When a merge mapping occurs, the candidate causal edges of the source anchor are merged under constraint compatibility, and the candidate causal edges containing mutually exclusive state transitions are written into the merge conflict record.

[0036] The merged conflict records are used for closed-loop determination of the temporal consistency constraint set and candidate causal edge exclusion.

[0037] Preferably, the counterfactual replay structure performs reverse reversal replay for each candidate causal edge in the unique explanation set, sequentially reversing the first triggering operator and restoring the local semantic state before reversal, and recording the actual downstream differences that no longer appear after reversal as the exclusive explanation item of the candidate causal edge;

[0038] Candidate causal edges generated by actual downstream differences that still occur after revocation are marked as shared explanatory terms.

[0039] Based on the triggering conditions of exclusive and shared explanatory terms, relevant candidate causal edges are merged into composite causal edges;

[0040] The causal chain determination structure only writes a single candidate causal edge with an exclusive explanatory term or a composite causal edge with a shared explanatory term and complete joint triggering conditions into the final engineering change tracing chain, and marks the remaining candidate causal edges as unverified associations.

[0041] Compared with the prior art, the beneficial effects of the present invention are as follows:

[0042] 1. By parsing engineering requirement items, design parameters, constraints, interface definitions, configuration items, and verification records from different versions into semantic units containing object semantics, attribute semantics, constraint semantics, relational semantics, and change intent, and generating stable semantic anchors based on functional roles, controlled attributes, constraint participation methods, and adjacency dependencies, cross-version identity correspondence can be maintained after object renaming, relocation, splitting, merging, or expression rewriting. The state layer records the existence state, attribute state, constraint state, and association state of each semantic anchor. The causal layer generates candidate causal edges based on semantic dependencies, constraint propagation direction, version order, and change intent. Candidate upstream changes are applied to the semantic snapshot before the change, isolating irrelevant modifications at the same time, and forming a theoretical downstream difference set along relevant constraint relationships. This set is then matched with the actual subsequent version difference set according to object overlap, change direction, constraint state, and propagation order. Candidate relationships that cannot reproduce actual differences can be excluded or converted into time co-occurrence relationships, thereby forming an engineering change causal chain continuously composed of change source, propagation path, intermediate constraints, and affected objects.

[0043] 2. Stable semantic anchors use constant core identifiers and evolvable branch identifiers to record splitting mappings, merging mappings, inherited fragments, disappearing fragments, and merging conflicting fragments. This ensures that causal relationships fall into specific semantic branches, preventing all target objects after splitting from indiscriminately inheriting the original propagation relationship. Temporal consistency constraints verify the sequential relationship between source and target states, the effective range of trigger constraints, and mutually exclusive states. They also reconstruct closed-loop candidate relationships, reducing cyclic relationships and paths that do not meet version order. Local replay domains freeze irrelevant semantic states, decomposing candidate changes into change operators such as object addition / deletion, attribute replacement, constraint adjustment, and relationship migration, while retaining intermediate semantic states and the first trigger operator. The interpretation set then removes redundant causal edges based on actual difference coverage, propagation order, and the number of source anchors. Reverse reversal replay distinguishes between exclusive and shared interpretation items, ensuring that single or compound causal edges in the final traceability chain correspond to clear semantic state transformation records. Attached Figure Description

[0044] Figure 1 This is a flowchart illustrating the overall processing flow of an intelligent engineering change traceability system based on semantic modeling.

[0045] Figure 2 A strength sequence diagram corresponding to cross-version anchor points;

[0046] Figure 3 Preserve the intensity sequence graph for candidate edges;

[0047] Figure 4 Flowchart for replaying counterfactual evidence of candidate causal relationships and determining the minimum set of explanations;

[0048] Figure 5 To replay the difference-matched intensity sequence map;

[0049] Figure 6 This is a check chart for closed-loop timing violations. Detailed Implementation

[0050] In one embodiment, please refer to Figure 1The intelligent engineering change traceability system based on semantic modeling includes a semantic parsing and processing structure, a temporal relationship construction structure, a counterfactual replay structure, and a causal chain determination structure. The semantic parsing and processing structure parses engineering requirement items, design parameters, constraints, interface definitions, configuration items, and verification records from different versions into semantic units containing object semantics, attribute semantics, constraint semantics, relational semantics, and change intent, and generates stable semantic anchors across versions. The temporal relationship construction structure establishes a state layer that records the evolution of semantic states and a causal layer that records candidate causal relationships based on the stable semantic anchors. The counterfactual replay structure applies candidate upstream changes to the semantic snapshot before the change and forms a theoretical downstream difference set. The causal chain determination structure filters causal edges based on the matching results between the theoretical downstream difference set and the actual subsequent version difference set, and generates an engineering change traceability chain consisting of change source, propagation path, intermediate constraints, and affected objects.

[0051] In this embodiment, the engineering data received by the system is organized by version. Each version includes at least a version identifier, a creation time, a source file identifier, and a set of object records. Engineering requirement items describe the functional or performance conditions to be met. Design parameters describe the value states of engineering objects. Constraints describe the allowed or prohibited relationships between objects. Interface definitions describe the input-output correspondence between objects. Configuration items describe the combination states adopted by the engineering scheme under a specific version. Verification records describe the verification conditions and verification conclusions of the corresponding semantic objects. The system does not use the entire text of a file as the smallest traceable object, but divides the content that can independently participate in constraint judgment and causal propagation into semantic units.

[0052] Specifically, the semantic parsing processing structure extracts the object subject, attribute name, attribute value, constraint expression, and association identifier from structured data according to field definitions and record primary keys. For unstructured engineering text, it segments it according to terminology boundaries, qualifiers, numerical expressions, referenced objects, and logical connections. It also splits the content of the same sentence that plays different technical roles into multiple semantic fragments. Then, based on the engineering terminology library and the current document context, the semantic fragments are mapped to object semantics, attribute semantics, constraint semantics, relational semantics, and change intent. The change intent is at least distinguished as addition, deletion, replacement, tightening, loosening, migration, splitting, merging, and expression rewriting. Semantic fragments whose specific intent cannot be determined are kept in a state of pending verification and do not directly enter the causal layer.

[0053] Semantic units are internally represented using quintuples. The object semantics in the quintuple are used to determine the category and functional role of the engineering object, the attribute semantics are used to store the attribute names and normalized values ​​of the attributes participating in version comparison, the constraint semantics are used to store the value range, dependency conditions, and conflict conditions, the relation semantics are used to store references, inclusions, input / output, or constraint propagation relationships with other objects, and the change intent is used to record the type of state change of the current version relative to the previous version. The system establishes a source index for each semantic unit. The source index is associated with at least the original version, the original file, the original location, and the term mapping rules used during parsing, so that each causal edge generated subsequently can be traced back to the corresponding original engineering data.

[0054] To avoid identity disruption caused by changes in object names, the semantic parsing processing structure extracts functional roles, controlled attribute sets, constraint participation sets, and adjacency dependency sets from semantic units, and performs standardized encoding on each component. Functional roles are encoded using the input, output, constraint source, constraint target, or verification object of the engineering object in the current technical relationship. Controlled attribute sets are encoded using a combination of attribute names and dimension categories. Constraint participation sets are encoded using constraint types and the position of the object in the constraint. Adjacency dependency sets are encoded using the functional roles and relation types of adjacent semantic units. Names, paragraph positions, and file paths are only used as auxiliary verification information and not as core components of stable semantic anchors.

[0055] The candidate correspondence degree of stable semantic anchors is calculated according to the following formula: ;

[0056] in, This represents the anchor point correspondence between the i-th semantic unit in the previous version and the j-th semantic unit in the subsequent version. Indicates the consistency of functional roles. Indicates the degree of overlap of controlled attributes. Indicates the degree of consensus among participants. Indicates the consistency of adjacency dependency. Indicates the degree of semantic conflict between mutually exclusive elements. , , , and They are respectively represented as , , , and The corresponding non-negative weights sum to 1, for example, taking , , , , When the corresponding value reflects that although the names and positions of two semantic units change, their roles, constraints, and adjacency relationships remain continuous. Furthermore, if the controlled attribute direction is opposite, the corresponding value will decrease and enter the manual rule review queue.

[0057] Please refer to Figure 2 , Figure 2 The horizontal axis represents the sampling sequence number of the cross-version anchor point inheritance record, ranging from 1 to 252. The vertical axis represents the normalized calculated value of the corresponding anchor point strength, ranging from approximately 0.6093 to 0.7783. The black solid line dots represent the calculation results of each anchor point inheritance record. The long dashed line represents the first threshold of 0.62, and the dotted line represents the second threshold of 0.78.

[0058] from Figure 2 As can be seen, the anchor point strength is generally concentrated around 0.6919, with only two samples falling below the first threshold. This indicates that most cross-version semantic units maintain continuity in functional roles, controlled attributes, constraint participation methods, and adjacency dependencies. The peak samples mainly appear in sample 210 (0.7783), sample 4 (0.7752), and sample 105 (0.7733), and the corresponding semantic units show strong consistency in role fingerprints and adjacency dependencies.

[0059] The local downward movement in the curve indicates that there may be rewritten object representations, adjusted constraint directions, or enhanced mutual exclusion semantic conflicts within this version of the window, but these are few in number and do not form a persistent identity break. Figure 2 To support the effectiveness of the stable semantic anchor algorithm, the system does not directly determine the same object based on name, paragraph position or file path, but generates cross-version identity correspondence results by comprehensively considering role, attribute, constraint, adjacency and conflict evidence.

[0060] In a preferred embodiment, anchor point correspondence does not use a single pairwise matching result. Instead, a candidate correspondence matrix is ​​first established based on functional roles and constraint participation relationships. Then, the candidate correspondence matrix is ​​iteratively corrected using adjacency dependencies. During each round of correction, the anchor point relationships established around the candidate semantic unit are read. If adjacent objects maintain the same dependency direction in previous and subsequent versions, the adjacency consistency of the corresponding item is increased. If all adjacent objects change and there is no common constraint source, the adjacency consistency of the corresponding item is decreased. The iteration terminates when the correspondence relationship no longer changes after two consecutive rounds, thereby forming cross-version stable semantic anchor points and corresponding anchor point inheritance records.

[0061] When a preceding semantic unit corresponds to multiple subsequent semantic units, the semantic parsing processing structure registers the correspondence as a split mapping and calculates the inherited attribute range, constraint range, and relation range of each subsequent semantic unit. When multiple preceding semantic units correspond to one subsequent semantic unit, the correspondence is registered as a merge mapping, and the semantic retention range of each source semantic unit in the target semantic unit is recorded. Neither split mapping nor merge mapping changes the core identity of the common engineering object. Instead, the allocation result of semantic content is saved through branch identifiers. Content that is not inherited is registered as a disappeared fragment, and content that conflicts between sources is registered as a merged conflict fragment.

[0062] The temporal relationship construction structure establishes a state layer based on stable semantic anchors as indexes. Each record in the state layer includes at least the version time, existence state, attribute state, constraint state, association state, and source index. The existence state distinguishes between existence, deletion, pending recovery, and branch termination. The attribute state stores the normalized attribute values ​​of the current version. The constraint state stores the constraints that are satisfied, not satisfied, invalid, or pending verification under the current version. The association state stores the relationship type and direction between the current anchor and other anchors. The state layer does not cover the historical records, but connects the states of the same anchor at different version times in chronological order, so that any state can locate its predecessor and successor states.

[0063] The causal layer is built on top of the state layer. The temporal relation construction structure extracts the anchor points that have changed from the state layer and generates candidate causal edges based on the consistency of semantic dependency direction, constraint propagation direction, version order, and change intention. Each candidate causal edge includes a source anchor point, a target anchor point, a triggering constraint, an expected state transition, and a valid version range. The source anchor point represents the upstream object that may cause the change, the target anchor point represents the downstream object that may be affected, the triggering constraint represents the condition that must be met for the propagation to be valid, the expected state transition represents the type of change that should occur when the candidate propagation is valid, and the valid version range is used to restrict the candidate edge to participate in reasoning only within the version range where the corresponding constraint actually exists.

[0064] For situations where multiple upstream anchors jointly trigger a downstream change, the temporal relation construction structure encapsulates multiple source anchors and their joint triggering conditions into composite candidate edges. The composite candidate edges store the set of participating anchors, the set of joint constraints, and the order of state transitions. The set of joint constraints uses a conjunction relation to express indivisible common conditions. When any necessary participating anchor does not undergo the specified change or any joint constraint is not satisfied, the composite candidate edge does not enter counterfactual replay, thus avoiding the propagation of errors after decomposing the multi-source changes that must work together into several independent edges.

[0065] The initial retention value of candidate causal edges is calculated according to the following formula: ;

[0066] in, This represents the candidate edge retention value from source anchor point u to target anchor point v. Indicates the consistency of semantic dependency direction. Indicates the degree of constraint satisfaction. Indicates the consistency of version order. This indicates the degree of consistency between the intended change and the expected state transition. Indicates the degree of conflict in the prohibited state. , , , and They are respectively represented as , , , and The corresponding non-negative coefficients, for example, when the upstream parameters tighten first and the downstream interface subsequently narrows its compatibility range, and the triggering constraint continues to exist within the effective version range, the first 4 terms take values ​​close to 1. If the target anchor point has been deleted at the same time, the state conflict degree is prohibited to take 1 and the corresponding candidate edge is excluded.

[0067] Please refer to Figure 3 , Figure 3 The horizontal axis represents the sampling sequence number of the candidate causal edge, ranging from 1 to 30. The vertical axis represents the normalized calculated value of the candidate edge retention strength, ranging from approximately 0.5745 to 0.7919. The black solid line dots represent the retention values ​​of each candidate edge. The long dashed line represents the first threshold of 0.58, and the dotted line represents the second threshold of 0.72.

[0068] from Figure 3 As can be seen, the average retention strength of candidate edges is approximately 0.6641, with 5 candidate edges reaching or exceeding the second threshold and 3 candidate edges falling below the first threshold. High-value candidate edges mainly include edge 11 (0.7919), edge 21 (0.7646), and edge 22 (0.7436), indicating that these propagation relations are significant in terms of semantic dependency direction, trigger constraint satisfaction, version order, and change intent. Figure 1 There is sufficient evidence regarding its sexual efficacy.

[0069] Low-value candidate edges usually correspond to situations where trigger constraints are insufficient, prohibited state conflicts are high, or the target anchor point state does not meet the propagation conditions. These should be subject to review or bypass relationship judgment. Figure 3 It directly corresponds to the candidate causal edge generation process and can be used to explain how the system retains highly reliable propagation paths in the causal layer and excludes weak candidate paths formed only by temporal proximity or reference relationships.

[0070] Please refer to Figure 4The counterfactual replay structure extracts a semantic snapshot from the state layer before the upstream change occurs for each candidate causal edge. The semantic snapshot includes the source anchor, the target anchor, the intermediate anchors involved in the triggering constraints, and the attribute state, constraint state, and association state of each anchor before the change. The extraction is consistent with the version time and does not write the newly added relationship after the change into the snapshot before the change. If the candidate edge corresponds to a composite candidate edge, the semantic snapshot also includes the state of all necessary participating anchors under the common baseline version to prevent the splicing of states at different version times to form non-existent replay conditions.

[0071] In this embodiment, modifications unrelated to upstream changes within the same version cycle are isolated. The isolation is based on whether there are triggering constraints, semantic dependencies, or common stable semantic anchors between the modified object and the candidate source anchor. Modifications lacking the above relationships are not written into the replay input. Modifications with indirect relationships but beyond the current candidate propagation path remain frozen. Format changes, annotation additions, and rewriting of expressions that do not change the semantics of the object are recorded as surface changes and not as state propagation input. Thus, the theoretical downstream differences are only caused by the current upstream changes and their associated constraints.

[0072] The counterfactual replay structure transforms candidate upstream changes into executable semantic change operators. Semantic change operators include at least object addition, object deletion, attribute replacement, constraint tightening, constraint relaxation, relation migration, semantic splitting, and semantic merging. Each change operator contains applicable premises, input state, output state, and affected relations. During execution, the input state is first verified to be consistent with the semantic snapshot. Then, the source anchor state is modified and propagated along the triggering constraints of the candidate causal edges. During the propagation process, each state transition is written to the intermediate replay record. The intermediate replay record saves the triggering operator, input anchor, output anchor, propagation constraints, and the state before and after the transition.

[0073] The theoretical downstream difference set is obtained by comparing the semantic state after replay with the semantic snapshot before replay. The difference items include at least the expected change object, expected attribute difference, expected constraint transformation and expected propagation order. The expected change object is represented by a stable semantic anchor point, the expected attribute difference is represented by the change of normalized attribute value, the expected constraint transformation is represented by the transformation between satisfying state, conflicting state, invalid state or unverified state, and the expected propagation order is represented by the generation order of the intermediate replay records. When the same target anchor point is reached by multiple paths, all paths are retained and the first triggering operator of each path is recorded.

[0074] The actual set of differences in subsequent versions is obtained by comparing the state records between the baseline version and the target version in the state layer. When comparing, stable semantic anchors are used instead of object names or file locations. For split mappings, the inherited fragments of each branch anchor are compared separately. For merge mappings, the semantic ranges of each source in the target anchor are compared. Expression rewriting that has been registered as a surface change does not generate engineering state differences. Records where the attribute value changes in unit or format but the normalized value remains unchanged are considered to have no substantial difference. The actual difference items and theoretical difference items are stored using the same data structure.

[0075] The degree of matching between theoretical and actual differences is calculated using the following formula: ;

[0076] in, This represents the matching value between the theoretical difference term p and the actual difference term q. Indicates the degree of overlap of stable semantic anchors. Indicates the consistency of the direction of attribute changes. Indicates the consistency of constraint state transitions. Indicates the consistency of the propagation order. , , and They are respectively represented as , , and The corresponding non-negative weights sum to 1. For example, if theoretical and actual differences point to the same anchor point, attributes change from allowed to restricted states, and constraints change from satisfied to pending verification in the same order, then each item takes a value of 1. If the objects are the same but the constraint transformation directions are opposite, then... And this will prevent the corresponding candidate edge from passing the matching check.

[0077] Please refer to Figure 5 , Figure 5 The horizontal axis represents the matching record number between the theoretical downstream difference and the actual subsequent version difference, ranging from 1 to 18. The vertical axis represents the difference matching strength, with a value ranging from approximately 0.6383 to 0.8551. The height of the bar represents the overall consistency of each matching item in terms of anchor point coincidence, attribute change direction, constraint state transition, and propagation order.

[0078] from Figure 5 As can be seen, all matching records are above the first threshold of 0.6, with four reaching or exceeding the second threshold of 0.76. The highest matching record is match number 13 at 0.8551, match number 1 at 0.8165, and match number 14 at 0.8102. This indicates that there is good continuity in object identity and consistency in state transitions between the theoretical differences generated by the replay structure and the actual version differences.

[0079] The causal chain determination structure matches the theoretical difference set with the actual difference set item by item according to the stable semantic anchor point, change direction, constraint state and propagation order. Only when the main state transition in the theoretical difference can be found in the actual difference and there is no opposite state transition on the same anchor point, will the candidate causal edge enter the set to be confirmed. Candidate edges that do not appear in the actual version of the theoretical difference are marked as not propagated. The part of the actual difference that cannot be explained by the current candidate edge is retained as unexplained difference. Unexplained difference continues to participate in the replay of other candidate edges or composite candidate edges without being directly attributed.

[0080] For multiple candidate causal edges in the set to be confirmed, the causal chain determination structure establishes an interpretation set. Each candidate causal edge carries a theoretical difference coverage item, a constraint state transition item, and a propagation order item. If the coverage item of a candidate edge is completely contained by another candidate edge without adding new constraint state transitions, the former is registered as a redundant candidate edge. The remaining candidate edges are combined according to the conditions of covering all actual downstream differences, maintaining consistent propagation order, and reducing the number of source anchor points. In the combination result, each candidate edge still retains the source index and intermediate playback record corresponding to the original engineering data.

[0081] The unique set of explanations is determined by the following formula: ;

[0082] Where G represents the set of candidate edges to be confirmed. This represents the selected set of interpretations. This represents the actual number of differences not covered by set E. This indicates the number of source anchors in the set. Indicates the number of anchor point identity interruptions. The number of constraint state transition gaps is represented by a, b, c, and d, which are positive coefficients corresponding to the number of actual differences, the number of source anchors, the number of anchor identity interruptions, and the number of constraint state transition gaps, respectively, with a being greater than the other coefficients. For example, when two candidate combinations cover all actual differences, the number of uncovered differences is 0. The system selects the combination with fewer source anchors and no anchor identity interruptions. If the number of source anchors is the same, the combination with fewer constraint state transition gaps is selected.

[0083] The causal chain structure is determined by generating an engineering change traceability chain based on a unique set of explanations. The traceability chain uses the confirmed source anchor point as the change source, forms the propagation path with candidate causal edges and intermediate replay records, forms intermediate constraints with the trigger constraints corresponding to each state transition, and forms the affected object with the target anchor point matched by the actual difference. Each node in the chain is associated with the version time and source index, and each edge is associated with the change operator, trigger constraint, and matching record. Temporal co-occurrence relationships, auxiliary reference relationships, and unverified associations are retained in the bypass records of the causal layer but do not enter the final traceability chain.

[0084] In one embodiment, the semantic parsing processing structure forms a role semantic fingerprint based on the functional role, controlled attributes, constraint participation method, and adjacency dependency relationship of the engineering object in the context. The object name, storage location, and text expression are excluded from the main identifier field of the stable semantic anchor. For candidate semantic units in previous and subsequent versions, an initial correspondence is first established based on the functional role and constraint participation method. Then, the initial correspondence is corrected based on the consistency of the adjacency dependency relationship. The corrected correspondence is written into the anchor inheritance record. When a single semantic unit corresponds to multiple subsequent semantic units or multiple preceding semantic units correspond to a single subsequent semantic unit, the split mapping or merge mapping is saved in the anchor inheritance record respectively, and a source anchor, a target anchor, and a semantic contribution range are added to each mapping.

[0085] Specifically, the semantic fingerprint of a role is stored using a combination of fixed-length fields and variable-length sets. The fixed-length fields record the object category, functional role, and constraint position, while the variable-length sets record the controlled attributes, adjacent object roles, and relationship types. When establishing the initial correspondence, candidates with mutually exclusive object categories or opposite constraint positions are first filtered out. Then, objects with the same functional role and overlapping constraint sets are selected from the remaining candidates. During adjacency correction, the confirmed adjacent anchor point correspondence is read and the candidate is updated. If a candidate has a continuous relationship with multiple target objects, it enters the splitting determination. If multiple source objects point to the same target object and their semantic content is complementary, it enters the merging determination.

[0086] In a preferred embodiment, the semantic parsing processing structure calculates the attribute inheritance fragments, constraint inheritance fragments, and relation inheritance fragments of each target anchor point in the split mapping, and registers semantic fragments not inherited by any target anchor point as disappearing fragments. For each source anchor point in the merge mapping, it calculates the semantic retention range of each source anchor point in the target anchor point, and registers the conflicting attributes or constraints between source anchor points as merge conflict fragments. The stable semantic anchor point consists of a constant core identifier and an evolvable branch identifier. The constant core identifier is associated with the common engineering object before splitting or merging, and the evolvable branch identifier is associated with each inherited fragment, disappearing fragment, and merge conflict fragment, respectively. The branch generation, branch termination, and branch merging relationships are recorded according to the version order.

[0087] Attribute inheritance fragments are determined by the intersection of attribute name, dimension category, and value semantics. Constraint inheritance fragments are determined by the intersection of constraint type, constraint location, and participating objects. Relationship inheritance fragments are determined by the intersection of relation type, direction, and adjacency role. A semantic fragment that does not appear in any target branch and does not have an equivalent expression is registered as a disappeared fragment. Source semantic fragments that point to the same attribute in the merge target but have mutually exclusive value directions, or that give allow and prohibit states for the same constraint respectively, are registered as merge conflict fragments. Merge conflict fragments are not directly written into the determined state of the target anchor point, but are retained as unresolved branches for subsequent time-series verification and counterfactual replay.

[0088] In one embodiment, the temporal relationship construction structure writes the existence state, attribute state, constraint state, and association state of each stable semantic anchor point at each version time into the state layer, and generates candidate causal edges based on the consistent relationship of semantic dependency, constraint propagation direction, version order, and change intention. Each candidate causal edge includes a source anchor point, a target anchor point, a triggering constraint, an expected state transition, and a valid version range. For downstream changes triggered by multiple upstream anchor points, multiple source anchor points and their joint triggering conditions are encapsulated into the same composite candidate edge, and the participating anchor point set, joint constraint set, and state transition order corresponding to the composite candidate edge are stored in the causal layer. The joint triggering condition participates in the causal edge screening in the form of an indivisible composite relationship.

[0089] Preferably, the state layer uses an append-only state record to store version evolution. When any version is written, the existing state record is not modified. When candidate causal edges are generated, the change type of the source anchor and the target anchor in adjacent versions is read, and the triggering constraint is checked to see if it is in a usable state within the valid version range. If the triggering constraint has expired before propagation, the corresponding candidate edge will not enter the causal layer. The joint constraint set of composite candidate edges uses a participation condition bitmap to record each necessary condition. The expected state transition is generated only when all necessary condition bits are satisfied. If any necessary condition is missing in the middle, this propagation is recorded as an incomplete joint trigger.

[0090] In a preferred embodiment, the temporal relation construction structure establishes a temporal consistency constraint set for candidate causal edges in the causal layer. The temporal consistency constraint set at least requires that the source state change precedes the target state change, the triggering constraint remains valid during propagation, and there are no mutually exclusive states coexisting at the same stable semantic anchor point. When candidate causal edges form a closed loop, the effective version range, change intention direction, and constraint state transition of each candidate causal edge in the closed loop are extracted, and candidate causal edges that cannot satisfy the temporal consistency constraint set are deleted. For composite closed loops that still satisfy temporal consistency, the causal layer is reconstructed according to the combination that can retain the most actual difference correspondences and contains the fewest candidate causal edges, and the excluded candidate causal edges are transferred to temporal co-occurrence relations.

[0091] The time violation of the candidate edge set is calculated using the following formula: ;

[0092] Where C represents the set of candidate edges in the same closed loop. This indicates whether candidate edge e contains a violation flag indicating that the source state is not earlier than the target state. This indicates whether there is a violation flag indicating that the triggering constraint has failed during propagation. The flags indicate whether a mutually exclusive state exists at the target anchor point. The three flags can only be 0 or 1. For example, in a closed loop, if the source state of an edge is later than the target state, the triggering constraint remains valid, and the target anchor point does not have a mutually exclusive state, the corresponding three flags are 1, 0, and 0. The system prioritizes deleting the path containing this edge and with the least actual difference coverage. Then the closed loop is reconstructed according to the actual difference coverage and the number of candidate edges.

[0093] Please refer to Figure 6 , Figure 6 The horizontal axis represents the inspection sequence number of the closed-loop candidate edge set, ranging from 1 to 10, and the vertical axis represents the number of temporal consistency violation markers, ranging from 1 to 3. The height of the bar is obtained by adding three types of markers: source state not earlier than target state, failure during trigger constraint propagation, and coexistence of mutually exclusive target anchor states.

[0094] from Figure 6 As can be seen, all current loop closure check records have at least one violation flag, with 7 loops reaching or exceeding the second threshold of 2. The higher values ​​mainly include loop 2 (3), loop 6 (3), and loop 7 (3). This indicates that these loop closure candidate paths have timing or state compatibility issues that require priority handling and cannot be directly retained as the final causal chain.

[0095] Low-value bars indicate that only local conditions are not met in the closed loop, while high-value bars indicate that multiple types of violations exist in the same closed loop. The system should prioritize deleting paths that contain violation edges and have relatively little actual difference coverage, and save the excluded relations as time co-occurrence relations.

[0096] In a preferred embodiment, for a composite closed loop that still satisfies temporal consistency, the system enumerates simple paths that can connect the change source and the actual affected object, calculates the actual difference items covered by each path and the number of candidate edges it contains, first retains the paths that are fully covered by actual differences, and then deletes duplicate edges that can be replaced by other paths. If multiple paths simultaneously meet the conditions, the path with continuous constraint state transitions and stable semantic anchors that have not experienced identity interruptions is retained. The deleted edges, along with the original version time, reference relationships, and co-occurrence records, are transferred to the temporal co-occurrence relationship table so that they can re-enter the candidate set when new evidence appears in subsequent versions.

[0097] In one embodiment, the counterfactual replay structure extracts a semantic snapshot of the upstream change corresponding to the candidate causal edge from the state layer before the upstream change occurs, isolates concurrent modifications unrelated to the candidate upstream change, applies the candidate upstream change to the semantic snapshot according to its change intention and constraint propagation direction, and performs state propagation along the constraint relationship associated with the candidate causal edge to form a theoretical downstream difference set containing the expected change object, expected attribute difference, expected constraint transformation, and expected propagation order. The causal chain determination structure matches the theoretical downstream difference set with the actual subsequent version difference set item by item according to object overlap, change direction, constraint state, and propagation order, and retains only candidate causal edges that have a common stable semantic anchor point and no opposite state transformation.

[0098] Specifically, semantic snapshots are generated using a version freeze method. The freeze range is determined by the candidate source anchor, the target anchor, and intermediate anchors on the propagation path. Each state record in the snapshot carries the original version time. During playback, it is prohibited to read attributes or relationships that appear in subsequent versions. The isolation of concurrent modifications is achieved by comparing the trigger constraints of its source anchor with those of the current candidate edge. When a concurrent modification is not a participant in the trigger constraint and does not change the state of the intermediate anchor in the path, it remains frozen. When a concurrent modification changes the intermediate constraint but occurs later than the target difference, it is not used as input for this propagation but is treated as a subsequent independent candidate change.

[0099] In a preferred embodiment, the counterfactual replay structure establishes a local replay domain based on the stable semantic anchors involved in the candidate upstream changes. The local replay domain includes associated anchors that have a constraint propagation relationship with the stable semantic anchors and are located within a set propagation level. The semantic state outside the local replay domain is frozen. Within the local replay domain, the candidate upstream changes are decomposed into at least one change operator among object addition / deletion, attribute replacement, constraint tightening, constraint relaxation, relationship migration, and change intention adjustment. The operators are applied one by one according to the order of the actual version. After each change operator is applied, the intermediate semantic state is saved. The theoretical downstream difference set is generated by the final semantic state and each intermediate semantic state, and the first triggering operator and propagation constraint corresponding to each theoretical difference are retained.

[0100] The local replay domain is obtained by traversing the restricted graph from the source anchor point along the direction of the triggering constraint. The traversal only expands adjacent anchor points where the constraint is in the valid version range and the relationship direction allows propagation. Expansion stops when a prohibited state, invalid constraint, or confirmed irrelevant branch is encountered. The propagation level does not use fixed hardware parameters, but is based on the shortest constraint chain in the actual candidate path that can reach the target anchor point, and allows the inclusion of necessary intermediate anchor points. The state outside the domain is retained in read-only mode, and no change operator may modify the anchor points outside the domain. This ensures that the replay results of different candidate upstream changes have comparable input boundaries.

[0101] The execution of change operators adopts two phases: prerequisite verification and state submission. Prerequisite verification reads the input state, trigger constraints, and target relationship required by the operator. If any condition is not met, the state is not submitted and a failure record is generated. State submission modifies the local replay domain according to the order of operators in the actual version. For object splitting and merging operators, the constant core identifier and the evolvable branch identifier are updated simultaneously. For constraint tightening and loosening operators, the set of allowed states of the participating objects is updated. For relation migration operators, the original relation termination time is retained and the new relation start time is established. After each submission, the unoverwriteable intermediate semantic state is saved.

[0102] In one embodiment, the causal chain determination structure establishes an explanation set for multiple candidate causal edges corresponding to the same actual downstream difference. Each candidate causal edge in the explanation set carries a theoretical difference coverage term, a constraint state transition term, and a propagation order term. First, redundant candidate causal edges whose theoretical difference coverage term is completely contained by other candidate causal edges and have not added new constraint state transition terms are eliminated. Then, from the remaining candidate causal edges, the combination that can cover all actual downstream differences, maintains the consistency of propagation order, and has the fewest source anchor points is selected. When multiple combinations have the same number of source anchor points, a unique explanation set is determined according to the continuity of stable semantic anchor points and the completeness of constraint state transitions, and the unique explanation set is written into the engineering change traceability chain.

[0103] When constructing the explanation set, a coverage matrix is ​​formed with actual difference items as rows and candidate causal edges as columns. The matrix elements record whether the candidate edge can generate the corresponding actual difference through replay and whether it has the same constraint transformation. If all coverage items in a column are covered by another column and there is no independent constraint transformation record, the former column is deleted. The remaining column combination must cover all attributable differences and keep the state transition order of each path consistent with the actual version. Actual differences that cannot be covered are not forcibly merged into the current explanation set, but are retained as unexplained and wait for other candidate sources to participate in the replay.

[0104] In one embodiment, the causal layer establishes a branch propagation record for stable semantic anchors with evolvable branch identifiers. The branch propagation record associates each candidate causal edge with a specific inherited segment, disappearing segment, or merged conflict segment, and uses a constant core identifier as a cross-branch association index. When a split mapping occurs, candidate causal edges are generated according to the actual constraint states carried by each inherited segment. The candidate causal edges of the source anchor are only written to the target anchor corresponding to the inherited constraint state. When a merge mapping occurs, the candidate causal edges of the source anchor are merged for constraint compatibility, and the candidate causal edges containing mutually exclusive state transitions are written to the merge conflict record. The merge conflict record participates in the closed-loop determination of the temporal consistency constraint set and the exclusion of candidate causal edges.

[0105] Specifically, each target branch in the split mapping inherits only the candidate edges corresponding to its attribute fragment, constraint fragment, and relation fragment. Target branches that do not inherit a certain constraint fragment do not establish a propagation relationship triggered by that constraint. Historical candidate edges corresponding to disappearing fragments retain the termination version time but do not point to subsequent branches. Source candidate edges in the merge mapping are recombined according to the semantic range retained in the target anchor. Candidate edges with consistent constraint directions and compatible state transitions are merged into a single composite record. Candidate edges with opposite constraint directions or mutually exclusive output states enter the merge conflict record and stop entering the counterfactual propagation of the current version.

[0106] In one embodiment, the counterfactual replay structure performs reverse reversal replay for each candidate causal edge in the unique explanatory set, sequentially reversing the first triggering operator and restoring the local semantic state before reversal. It records the actual downstream differences that no longer occur after reversal as the exclusive explanatory terms of the candidate causal edge. For actual downstream differences that are still generated by other candidate causal edges after reversal, they are recorded as shared explanatory terms. Based on the joint triggering conditions corresponding to the shared explanatory terms, the relevant candidate causal edges are merged into composite causal edges. The causal chain determination structure only writes the single candidate causal edge with an exclusive explanatory term or the composite causal edge with a shared explanatory term and complete joint triggering conditions into the final engineering change traceability chain, and marks the remaining candidate causal edges as unverified associations.

[0107] Reverse reversal replay is executed in the reverse order of intermediate replay records. When reversing attribute replacement, the attribute state before replacement is restored. When reversing constraint tightening or relaxation, the original allowed state set is restored. When reversing relation migration, the new relation is terminated and the original relation is restored. When reversing splitting or merging, the semantic boundary before reversal is restored based on the constant core identifier and the evolvable branch identifier. After each reversal, the constraint propagation in the local replay domain is re-executed and a reversal difference set is generated. The original state layer is not modified during the reversal process. Only temporary replay records bound to the current candidate edge are generated.

[0108] The withdrawal contribution of a candidate edge is determined by the following formula: ;

[0109] in, This represents the number of exclusive interpretations for a candidate causal edge e. This represents the set of difference items that uniquely matches the actual difference when the set is fully replayed. This represents the set of matching differences that can still be generated by the remaining candidate edges after the first triggering operator of candidate edge e is removed. The set difference operation represents the difference between the matching edges generated by the remaining candidate edges. Removal still exists in The difference terms in the equation, for example, if a complete replay matches 4 actual differences, and after removing a candidate edge, only 2 differences remain, it can still be generated. These two differences are registered as exclusive explanatory terms, if However, the relevant differences only occur when both edges coexist. In this case, the corresponding differences are registered as shared explanatory terms and the joint triggering conditions are verified.

[0110] The joint triggering conditions of shared explanatory terms are verified according to the set of participating anchor points and the set of joint constraints stored in the composite candidate edges. The system performs replay of the missing participating anchor point. If the missing of any necessary participating anchor point fails to generate a shared explanatory term, and the presence of all participating anchor points can generate the corresponding difference, the relevant candidate edges are merged into a composite causal edge. If the missing of some participating anchor points can still generate all shared differences, the candidate edges that do not constitute necessary conditions are deleted. If the shared differences cannot be stably reproduced under any combination, the relevant candidate edges are marked as unverified associations and their replay records are retained.

[0111] In one application implementation, a constraint entry in the engineering requirements version undergoes an expression rewrite and simultaneously changes the range of controlled parameters. The interface definition in the design document undergoes a compatibility range adjustment in a later version. The corresponding verification item in the verification record changes from a passed state to a pending verification state. The semantic parsing processing structure registers the expression rewrite as a surface change and the parameter range change as a constraint tightening operator. It generates stable semantic anchors through functional roles, controlled attributes, and adjacency dependencies. The temporal relationship construction structure establishes candidate causal edges from the constraint entry to the interface definition and from the interface definition to the verification record. The counterfactual replay structure applies the constraint tightening operator separately in the semantic snapshot before the change and generates the theoretical difference between the interface compatibility range reduction and the verification state transition.

[0112] In the above application implementation, if the interface definition in the actual subsequent version has a common stable semantic anchor point with the theoretical difference, the direction of attribute change is the allowable range reduction, and the constraint state transition in the verification record is consistent with the theoretical propagation order, then the corresponding candidate edge enters the interpretation set. If the same version cycle also includes interface description text adjustment and irrelevant configuration item sorting, the above content is frozen because it does not participate in triggering constraints and is not written into the current theoretical difference set. If another requirement item may also cause the same interface change, then candidate replay and reverse undo replay are executed respectively, and a single causal edge or a compound causal edge is determined based on the exclusive interpretation item or the shared interpretation item.

[0113] In another implementation, an original configuration item is split into a basic configuration branch and an extended configuration branch in a subsequent version. The basic configuration branch inherits the original interface constraints, while the extended configuration branch only inherits additional attributes. The semantic parsing processing structure establishes a common constant core identifier and different evolvable branch identifiers for the two branches, and records the constraint inheritance fragments and attribute inheritance fragments respectively. The causal layer only writes the candidate causal edges corresponding to the original interface constraints into the basic configuration branch, and does not copy the candidate edges to the extended configuration branch. The counterfactual replay structure limits the local replay domain and verifies the actual affected objects by using branch propagation records.

[0114] In the above application implementation, if a subsequent version merges the two configuration branches again, the system calculates the semantic retention range of each source branch in the target configuration item. When the interface constraint direction is consistent, the corresponding candidate edges are merged. When attribute values ​​are mutually exclusive, a merge conflict fragment is generated and kept in a pending resolution state. The temporal consistency constraint set checks whether the conflict fragment causes the coexistence of mutually exclusive states of the same anchor point. Candidate edges that violate the rules are not included in the current tracing chain. After the conflict is eliminated in a subsequent version, a new state record is generated to generate candidate relationships. This avoids the causal propagation path being incorrectly cut off or expanded due to changes in object name or file location during the splitting and merging process.

[0115] The final engineering change traceability chain saved by the system consists of stable semantic anchor point identifiers, version time, change operators, trigger constraints, intermediate state records, theoretical difference matching records, actual difference source indexes, and edge verification status. When querying a change source, the propagation path is read along the confirmed causal edge. When querying an affected object, the source path is read in reverse along the causal edge. Temporal co-occurrence relationships and unverified associations are stored using different status identifiers. When new actual differences or constraint records appear in subsequent versions, the corresponding semantic snapshots and replay records can be called back for verification without changing the already saved original version status.

Claims

1. An intelligent traceability system for engineering changes based on semantic modeling, characterized in that, This includes semantic parsing processing structure, temporal relation construction structure, counterfactual replay structure, and causal chain determination structure; The semantic parsing processing structure parses engineering requirement items, design parameters, constraints, interface definitions, configuration items and verification records from different versions into semantic units containing object semantics, attribute semantics, constraint semantics, relational semantics and change intent, and generates cross-version stable semantic anchors. The semantic unit is expressed internally using a quintuple. The object semantics in the quintuple are used to determine the category and functional role of the engineering object, the attribute semantics are used to store the attribute name and normalized value of the version comparison, the constraint semantics are used to store the value range, dependency conditions and conflict conditions, the relation semantics are used to store the reference, containment, input-output or constraint propagation relationship with other objects, and the change intent is used to record the state change type of the current version relative to the previous version. Instead of using a single pairwise matching result, the anchor point correspondence first establishes a candidate correspondence matrix based on functional roles and constraint participation relationships. Then, iteratively corrects the candidate correspondence matrix using adjacency dependency relationships. During each round of correction, the anchor point relationships established around the candidate semantic unit are read. If adjacent objects maintain the same dependency direction in previous and subsequent versions, the adjacency consistency of the corresponding item is increased. If all adjacent objects change and there is no common constraint source, the adjacency consistency of the corresponding item is decreased. The iteration terminates when the correspondence relationship no longer changes after two consecutive rounds. This forms a cross-version stable semantic anchor point and its corresponding anchor point inheritance record. The temporal relation construction structure establishes a state layer that records the evolution of semantic states and a causal layer that records candidate causal relations based on the stable semantic anchor points; The temporal relationship construction structure establishes the state layer using stable semantic anchors as indexes. Each record in the state layer includes at least the version time, existence state, attribute state, constraint state, association state, and source index. The existence state is distinguished as existing, deleted, pending recovery, and branch termination. The attribute state stores the normalized attribute values ​​of the current version. The constraint state stores the constraints that are satisfied, not satisfied, invalid, or pending verification under the current version. The association state stores the relationship type and direction between the current anchor point and other anchor points. The state layer does not cover the historical records, but connects the states of the same anchor point at different versions in chronological order, so that any state can locate its predecessor and successor states. The causal layer is built on the state layer. The temporal relationship construction structure extracts the anchor points that have changed from the state layer and generates candidate causal edges based on the consistency of semantic dependency direction, constraint propagation direction, version order, and change intention. Each candidate causal edge includes a source anchor point, a target anchor point, a triggering constraint, an expected state transition, and a valid version interval. The source anchor point represents the upstream object that caused the change, the target anchor point represents the downstream object that was affected, the triggering constraint represents the condition that must be met for the propagation to be successful, and the expected state transition represents the type of change that should occur when the candidate propagation is successful. The counterfactual replay structure applies candidate upstream changes to the semantic snapshot before the change and forms a theoretical downstream difference set. The causal chain determination structure filters causal edges based on the matching results between the theoretical downstream difference set and the actual subsequent version difference set, and generates an engineering change traceability chain consisting of change source, propagation path, intermediate constraints and affected objects.

2. The intelligent traceability system for engineering changes based on semantic modeling according to claim 1, characterized in that, The semantic parsing processing structure forms a role semantic fingerprint based on the functional role, controlled attributes, constraint participation method, and adjacency dependency relationship of the engineering object in the context, and excludes the object name, storage location, and text expression from the main identifier field of the stable semantic anchor. For candidate semantic units in previous and subsequent versions, an initial correspondence is first established based on functional roles and constraint participation methods. Then, the initial correspondence is corrected based on the consistency of the adjacency dependency relationship, and the corrected correspondence is written into the anchor inheritance record. When a single semantic unit corresponds to multiple subsequent semantic units or multiple preceding semantic units correspond to a single subsequent semantic unit, the anchor inheritance record stores the split mapping or merge mapping respectively, and adds a source anchor, a target anchor, and a semantic contribution range to each mapping.

3. The intelligent engineering change traceability system based on semantic modeling according to claim 1, characterized in that, The temporal relationship construction structure writes the existence state, attribute state, constraint state and association state of each stable semantic anchor point at each version time into the state layer, and generates candidate causal edges with consistent relationships of semantic dependency, constraint propagation direction, version order and change intention. Each candidate causal edge includes a source anchor, a target anchor, a triggering constraint, an expected state transition, and a valid version range; the valid version range is used to restrict the candidate edge to participate in reasoning only within the version range where the corresponding constraint actually exists; For downstream changes triggered by multiple upstream anchor points, multiple source anchor points and their joint triggering conditions are encapsulated into the same composite candidate edge. The participating anchor point set, joint constraint set and state transition order corresponding to the composite candidate edge are stored in the causal layer. The joint triggering conditions participate in the causal edge screening in the form of an indivisible composite relationship.

4. The intelligent traceability system for engineering changes based on semantic modeling according to claim 1, characterized in that, The counterfactual replay structure extracts a semantic snapshot of the upstream change corresponding to the candidate causal edge from the state layer before the upstream change occurs, isolates concurrent modifications unrelated to the candidate upstream change, applies the candidate upstream change to the semantic snapshot according to its change intention and constraint propagation direction, and performs state propagation along the constraint relationship associated with the candidate causal edge to form a theoretical downstream difference set containing the expected change object, expected attribute difference, expected constraint transformation and expected propagation order. The causal chain determination structure maps the theoretical downstream difference set to the actual subsequent version difference set item by item according to the object overlap, change direction, constraint state and propagation order, and retains only the candidate causal edges that have a common stable semantic anchor point and do not have opposite state transitions.

5. The intelligent traceability system for engineering changes based on semantic modeling according to claim 2, characterized in that, The semantic parsing processing structure calculates the attribute inheritance fragment, constraint inheritance fragment, and relation inheritance fragment of each target anchor in the split mapping, and registers the semantic fragments that are not inherited by any target anchor as disappearing fragments. Calculate the semantic preservation range of each source anchor in the target anchor for each source anchor in the merge mapping, and register the conflicting attributes or constraints between source anchors as merge conflict fragments; The stable semantic anchor consists of a constant core identifier and an evolvable branch identifier. The constant core identifier is associated with common engineering objects before splitting or merging. The evolvable branch identifier is associated with each inherited fragment, disappeared fragment, and merged conflict fragment, and records the branch generation, branch termination, and branch merging relationships in version order.

6. The intelligent traceability system for engineering changes based on semantic modeling according to claim 3, characterized in that, The temporal relation construction structure establishes a temporal consistency constraint set for candidate causal edges in the causal layer. The temporal consistency constraint set at least requires that the source state change precedes the target state change, the triggering constraint remains valid during propagation, and there are no mutually exclusive states coexisting at the same stable semantic anchor point. When the candidate causal edges form a closed loop, extract the effective version range, change intention direction and constraint state transition of each candidate causal edge within the closed loop, and delete the candidate causal edges that cannot satisfy the time-series consistency constraint set. For composite closed loops that still satisfy temporal consistency, the causal layer is reconstructed according to the combination that can retain the most actual difference correspondences and contain the fewest candidate causal edges, and the excluded candidate causal edges are temporarily stored as temporal coexistence relations.

7. The intelligent engineering change traceability system based on semantic modeling according to claim 1, characterized in that, The counterfactual replay structure establishes a local replay domain based on the stable semantic anchor points involved in the candidate upstream changes. The local replay domain includes associated anchor points that have a constraint transmission relationship with the stable semantic anchor points and are located within a set propagation level, and freezes the semantic state outside the local replay domain. Within the local replay domain, candidate upstream changes are decomposed into at least one change operator among object addition / deletion, attribute replacement, constraint tightening, constraint relaxation, relationship migration, and change intent adjustment. The operators are applied one by one according to their order in the actual version, and the intermediate semantic state is saved after each change operator is applied. The theoretical downstream difference set is generated by the final semantic state operator and each intermediate semantic state, and retains the first trigger anchor point and propagation constraints corresponding to each theoretical difference.

8. The intelligent traceability system for engineering changes based on semantic modeling according to claim 4, characterized in that, The causal chain determination structure establishes an explanation set for multiple candidate causal edges corresponding to the same actual downstream difference. Each candidate causal edge in the explanation set carries a theoretical difference coverage term, a constraint state transition term, and a propagation order term. First, remove redundant candidate causal edges whose theoretical difference coverage terms are completely contained by other candidate causal edges and do not add new constraint state transition terms. Then, select from the remaining candidate causal edges the combination that can cover all actual downstream differences, maintain consistent propagation order, and minimize the number of source anchors. When multiple combinations have the same number of source anchors, a unique interpretation set is determined according to the continuity of the stable semantic anchors and the completeness of the constraint state transition, and the unique interpretation set is written into the engineering change traceability chain.

9. The intelligent traceability system for engineering changes based on semantic modeling according to claim 5, characterized in that, The causal layer establishes branch propagation records for stable semantic anchors with evolvable branch identifiers. The branch propagation records associate each candidate causal edge with a specific inherited fragment, a disappeared fragment, or a merged conflict fragment, and use the constant core identifier as a cross-branch association index. When split mapping occurs, candidate causal edges for branches are generated according to the actual constraint states carried by each inherited segment. The candidate causal edges of the source anchor point are only written to the target anchor point corresponding to the inherited constraint state. When a merge mapping occurs, the candidate causal edges of the source anchor are merged under constraint compatibility, and the candidate causal edges containing mutually exclusive state transitions are written into the merge conflict record. The merged conflict records are used for closed-loop determination of the temporal consistency constraint set and candidate causal edge exclusion.

10. The intelligent traceability system for engineering changes based on semantic modeling according to claim 8, characterized in that, The counterfactual replay structure performs reverse reversal replay for each candidate causal edge in the unique explanation set, sequentially reversing the first triggering operator and restoring the local semantic state before reversal, and recording the actual downstream differences that no longer appear after reversal as the exclusive explanation item of the candidate causal edge. Candidate causal edges generated by actual downstream differences that still occur after revocation are marked as shared explanatory terms. Based on the triggering conditions of exclusive and shared explanatory terms, relevant candidate causal edges are merged into composite causal edges; The causal chain determination structure only writes a single candidate causal edge with an exclusive explanatory term or a composite causal edge with a shared explanatory term and complete joint triggering conditions into the final engineering change tracing chain, and marks the remaining candidate causal edges as unverified associations.

Images