Method for automatically checking consistency of soft materials based on mapping knowledge domain

Abstract

The invention discloses a knowledge graph-based software material consistency automatic checking method, which comprises the following steps of: collecting and processing a software declaration material to form a standardized original material set; forming an initial entity set and a candidate relation set based on the normalized original material set; constructing a heterogeneous knowledge graph based on the initial entity set and the candidate relationship set; executing cross-modal semantic anchoring on the heterogeneous knowledge graph to generate a semantic anchoring mapping table and an anchoring confidence value set; generating an enhanced constraint graph based on the semantic anchoring mapping table and the anchoring confidence value set; outputting a consistency detection result set and a minimum conflict subgraph set based on the heterogeneous knowledge graph and the enhanced constraint graph; and based on the consistency detection result set and the minimum conflict subgraph set, generating a difference check report and a repair suggestion set. According to the method, heterogeneous knowledge graph construction and semantic anchoring are adopted, and automatic consistency checking of the soft material is realized.

Description

Technical Field

[0001] This invention relates to the field of software copyright examination technology, and in particular to an automatic verification method for software copyright material consistency based on knowledge graphs. Background Technology

[0002] In the current software copyright application process, applicants are required to submit various materials, including source code files, functional design documents, interface specifications, user manuals, and structural drawings. To ensure a high pass rate, the functional descriptions, interface definitions, and data fields across these materials must be consistent. However, traditional verification methods primarily rely on manual comparison and rule-based scripts. Common practices include keyword searches and string matching between code and documentation, or using simple text difference detection tools to check modification records. These methods have limitations when handling multi-source heterogeneous data that combines structured and unstructured information, making it difficult to comprehensively identify semantic differences across files and modules.

[0003] In recent years, research has emerged applying knowledge graphs to software engineering, but most studies have focused on requirements analysis, defect prediction, or code recommendation. These studies typically establish entities and relationships only within a single data source, lacking cross-modal semantic anchoring mechanisms and failing to adequately record source evidence or manage version evolution with fine granularity. Existing knowledge graph consistency verification methods primarily rely on static schema verification, lacking dynamic tracking and incremental reasoning capabilities for different version evolution paths. Furthermore, they fail to deeply integrate graph rule reasoning with satisfiability testing, thus failing to establish an interpretable minimum conflict scope within complex software copyright materials.

[0004] Therefore, how to provide an automatic verification method for software copyright consistency based on knowledge graphs is a problem that urgently needs to be solved by those skilled in the art. Summary of the Invention

[0005] One objective of this invention is to propose an automatic consistency verification method for software copyrighted materials based on knowledge graphs. This invention utilizes knowledge graph construction, cross-modal semantic anchoring, graph rule reasoning, and satisfiability detection technologies to uniformly parse and model source code files, functional design documents, interface specifications, user manuals, and structural drawings. It constructs a heterogeneous knowledge graph comprising a schema layer, instance layer, evidence layer, and temporal layer, and on this basis, achieves consistency verification and difference localization for multi-source heterogeneous materials. This method can automatically identify semantic inconsistencies across files and versions, outputting a difference verification report and remediation suggestions including source evidence and evolution paths. It possesses advantages such as high verification efficiency, accurate semantic matching, traceable version differences, and interpretable results.

[0006] An automatic verification method for software copyright consistency based on knowledge graphs according to an embodiment of the present invention includes the following steps: Collect software copyright application materials and perform format standardization, paragraph annotation, redundancy removal and coding standardization to form a standardized set of original materials; Multimodal analysis is performed on the standardized original material set to form an initial entity set and a candidate relation set; Based on the initial entity set and the candidate relation set, a heterogeneous knowledge graph is constructed, which includes a pattern layer, an instance layer, an evidence layer and a temporal layer. Perform cross-modal semantic anchoring processing on heterogeneous knowledge graphs, generate semantic anchoring mapping tables, and assign anchoring confidence value sets; Based on the semantic anchoring mapping table and the anchoring confidence value set, combined with heterogeneous knowledge graphs, the consistency requirements of software copyright materials are transformed into formal rules and constraint graphs are generated. Based on heterogeneous knowledge graphs and enhanced constraint graphs, output a consistency detection result set and a set of minimum conflict subgraphs; Based on the consistency detection result set and the minimum conflict subgraph set, the corresponding material paragraph or code fragment is located, and a difference verification report and a set of remediation suggestions are generated.

[0007] Optionally, the process of collecting software copyright application materials and performing format standardization, paragraph annotation, redundancy removal, and coding standardization to form a standardized set of original materials specifically includes: Obtain the software copyright application materials to be verified, and divide the software copyright application materials into a set of source code files, a set of functional design documents, a set of interface specifications, a set of user manuals, and a set of structural drawings to form an initial set of materials; The initial set of materials is processed to unify the format, including unifying the character encoding format to UTF-8, the file type suffix, and the paragraph level tags, and generating a format-unified set. Paragraph annotation processing is performed on the uniformly formatted set, dividing each document into a set of paragraph units and assigning a unique identifier to each paragraph unit; Perform redundancy cleaning on the paragraph unit set, deleting duplicate paragraphs, blank paragraphs, and invalid characters to form a redundancy cleaned set; The redundant cleansing set is subjected to coding standardization processing, and the timestamp format, path representation and version number representation are unified. The processing result is defined as a standardized original material set.

[0008] Optionally, the step of performing multimodal analysis on the normalized original material set to form an initial entity set and a candidate relation set specifically includes: The standardized raw material set is categorized by type and divided into source code file set, functional design document set, interface specification set, user manual set, and structural drawing set according to content attributes; Fine-grained syntactic structure extraction is performed on the collection of source code files. First, the lexical and syntactic structure of each source code file is parsed, and a complete abstract syntax tree is constructed to record package, class, method, variable and scope information in a hierarchical manner. Then, a call graph is generated based on the call relationship between methods to characterize the dependency between functions and modules. During the construction of the abstract syntax tree and call graph, signature recognition is performed on each method and interface, and interface features are extracted. The interface features include interface name, parameter type, return type, and access control attributes. Subsequently, based on the hierarchical structure of the abstract syntax tree, independent functional module units are identified, and the classes, methods, data fields, and interface call relationships contained in the module are completely mapped into the structured record; Based on this, a set of functional modules, a set of interface names, a set of data fields, and a set of call relationships are generated on the code side, and a unique identifier and associated index are established for each element in each set; The document semantic analysis process is performed on the functional design document set, interface specification set, and user manual set. First, the documents are segmented according to the title level and paragraph structure and a hierarchical index is established. Then, word segmentation, named entity recognition, and dependency parsing techniques are used to extract the functional modules, interface names, data fields, and hierarchical relationships in the documents. During this process, text fragments describing system constraints are identified and constrained to form constraint logic records. At the same time, relational information reflecting inter-module dependencies, data flow, and interface call order is extracted from the documents. Finally, based on the established paragraph index and semantic annotation results, a set of functional modules, a set of interface names, a set of data fields, a set of constraint logic, and a set of descriptive relationships are generated on the document side, and a unique identifier and associated index are established for each element in each set. The structural drawing set is processed for drawing structure recognition. First, each drawing file is converted into a parsable vector or graphic data format. The graphic symbols, connecting lines, text annotations and legends are parsed in layers and blocks. Based on the geometric position, connection relationship and annotation content, the key graphic elements representing system functional modules, interface ports and data channels are identified. Subsequently, the identified graphic elements and connections are classified and their relationships are modeled. The functional modules, interface names and data field information contained in the drawings are extracted, and the corresponding connection relationships are established to represent the topology and dependencies between modules. Finally, a set of functional modules, a set of interface names, a set of data fields, and a set of connection relationships are generated on the drawing side, and a unique identifier and index are established for each element in each set; The functional module set, interface name set, data field set, and constraint logic set generated from the code side, document side, and drawing side are integrated in a unified manner. Elements with the same semantics or the same name are deduplicated and merged. A global index is established according to four categories: functional module, interface name, data field, and constraint logic to form an initial entity set. At the same time, the call relationships, description relationships and connection relationships extracted from various sources are uniformly organized, the relationship types and directions are standardized, and a unified relationship index across sources is established to form a candidate relationship set.

[0009] Optionally, the construction of a heterogeneous knowledge graph based on the initial entity set and candidate relation set, wherein the heterogeneous knowledge graph includes a pattern layer, an instance layer, an evidence layer, and a temporal layer, specifically comprising: Based on the initial entity set and the candidate relation set, a heterogeneous knowledge graph is constructed, which includes a pattern layer, an instance layer, an evidence layer and a temporal layer. In the schema layer, the corresponding node types are defined for the functional module set, interface name set, data field set, and constraint logic set, and the corresponding relationship types are defined for the call relationship, description relationship, and connection relationship in the candidate relationship set. Based on this, a set of triplet relationships consisting of the starting node type, relationship type, and target node type is established according to the correspondence between each node type and the relationship type. In the instance layer, each entity in the initial entity set is mapped to an instance node, resulting in an instance node set. Each relationship in the candidate relationship set is mapped to a relationship edge between nodes, resulting in a relationship edge set. An instance layer graph is constructed based on the instance node set and the relationship edge set. In the evidence layer, a set of corresponding anchor point information is established for each node and each relation edge in the instance layer graph. For each anchor point, the original material source identifier, the precise location index in the material, and the content hash value are recorded, and the above information is associated with the corresponding node or relation edge. In the temporal layer, a version evolution label set is established for each node and each relation edge in the instance layer graph. Each label records the version number, the timestamp of version generation or modification, the operation type of the version and the associated change content. The label set is then bidirectionally associated with the corresponding node or relation edge.

[0010] Optionally, the step of performing cross-modal semantic anchoring processing on the heterogeneous knowledge graph, generating a semantic anchoring mapping table, and allocating a set of anchoring confidence values ​​specifically includes: Read heterogeneous knowledge graphs, which include a pattern layer, an instance layer, an evidence layer, and a temporal layer, providing node types and relation types, set of instance nodes and set of relation edges, set of anchor information, and set of version evolution tags, respectively, providing a complete graph structure and basic data for cross-modal semantic anchoring processing; In the instance node set, all nodes are grouped according to the source identifier and node pairs from different sources are filtered. Each pair of nodes that meets the source difference condition is combined into a candidate anchor pair, and the results are summarized to form a candidate anchor set. For each pair of instance nodes in the candidate anchor set, based on the node type and relationship type defined in the schema layer and the source identifier, location index and content hash value provided by the evidence layer, the node name, relationship schema and type consistency are compared item by item, and a rule matching score is generated in a comprehensive manner. For each pair of anchor nodes in the candidate anchor set, extract the contextual semantic information of each pair of anchor nodes in the instance layer graph, transform the paragraph text where the anchor node is located, the associated interface description and related descriptive relationships into a unified semantic vector representation, calculate and output the contextual similarity score of the anchor node pair. For each pair of anchor nodes in the candidate anchor set, first determine their respective neighborhood range in the instance layer graph, and extract the set of adjacent nodes directly connected to the anchor node and the set of multi-hop associations, the connection relationship type, the relationship direction and the topology depth. Then, the node attributes, relationship patterns, edge weights, and hierarchical positions of each neighborhood are encoded sequentially to form a comparable neighborhood structure feature description. Next, the two sets of neighborhood structural features are matched and the differences are measured item by item. The similarity in terms of node adjacency pattern, relation topology and multi-hop path consistency is comprehensively evaluated to obtain the structural similarity score of the anchor node pair. The structural similarity score is then stored and transmitted. The overall anchor confidence score is calculated by weighting the rule matching score, context similarity score, and structural similarity score. For each pair of anchor nodes in the candidate anchor set, read the comprehensive anchor confidence score calculated in the previous step and compare it with the preset threshold one by one. Determine the node pairs with a comprehensive anchor confidence score greater than or equal to the threshold as valid anchor pairs. All valid anchor pairs, along with their corresponding comprehensive anchor confidence scores, are stored in a semantic anchor mapping table, and a set of anchor confidence scores is generated simultaneously. The generated semantic anchoring mapping table and the corresponding set of anchoring confidence values ​​are output as the final anchoring result and stored in association with the heterogeneous knowledge graph.

[0011] Optionally, the step of transforming the consistency requirements of software copyright materials into formal rules and compiling a constraint graph based on a semantic anchoring mapping table and an anchoring confidence value set, combined with a heterogeneous knowledge graph, specifically includes: Read the semantic anchoring mapping table and anchoring confidence value set generated in the previous steps, and combine them with the pattern layer, instance layer, evidence layer and temporal layer in the heterogeneous knowledge graph. According to the different dimensions of software copyright material consistency requirements, classify and organize the functional modules, interface names, data fields and constraint logic, extract specific verification conditions item by item, standardize each verification condition into an independent consistency rule element, and summarize them one by one to form a consistency rule candidate set. Each rule extracted from the candidate set of consistency rules is processed according to the software copyright consistency verification requirements. It combines the node type and relation type of the schema layer, the set of instance nodes and relation edges of the instance layer, the matching node pairs in the semantic anchoring mapping table and the corresponding anchoring confidence. The functional modules, interface names, data fields and constraint logic involved in the rule are variableized. The value range, dependency and conflict conditions of the constraint variables are determined one by one. The rule content is compiled into logical constraint items according to the requirements of satisfiability detection to form a set of constraint expressions. The constraint expression set is relationally decomposed to identify all constraint variables and constraints involved. Each constraint variable or constraint condition is used to generate a corresponding constraint graph node, and the dependencies or conflicts in the constraint expressions are used to generate corresponding constraint graph edges. These are then combined to form a constraint graph node set and a constraint graph edge set, and an initial constraint graph is constructed accordingly. In the initial constraint graph, the corresponding anchored entity pair, comprehensive anchor confidence level, and source evidence index information are recorded for each constraint variable node, and associated with the anchor information in the evidence layer; Each constraint variable node is attached with a version evolution label from the temporal layer, recording the version number, the timestamp of version generation or modification, and the operation type, thus obtaining an enhanced constraint graph.

[0012] Optionally, the step of outputting a consistency detection result set and a minimum conflict subgraph set based on heterogeneous knowledge graphs and enhanced constraint graphs specifically includes: In the enhanced constraint graph and instance layer graph, the node type, relation type and triple relation set defined in the schema layer are used as inference rules. The real node set, edge set and neighborhood context provided by the instance layer graph are called. Each constraint variable node and its associated relation are matched and logically calculated one by one. The missing relations caused by the fusion of multi-source materials or incomplete description are automatically identified and new inference relation sets are generated. These relations are bound and updated with the actual nodes and edges in the instance layer. The inference relation set and the candidate relation set are merged to generate the complete relation set; In the enhanced constraint graph, satisfiability checks are performed on the set of constraint expressions generated in the previous steps one by one. The analysis is conducted to determine whether each constraint variable and dependency relationship simultaneously satisfies the logical conditions. All constraint combinations that are conflicting or cannot be satisfied simultaneously are identified. The set of minimum conflict subgraphs composed of relevant nodes and relation edges is extracted and output. For each constraint graph node in the enhanced constraint graph, the node pair and the comprehensive anchor confidence of the constraint graph node in the semantic anchoring mapping table are first obtained to measure the reliability of semantic matching. Then, the completed set of relations is retrieved, and the association between the constraint graph nodes and related constraint graph nodes in terms of relational integrity and constraint satisfaction is evaluated. Furthermore, by combining the version number, timestamp, and operation type of the constraint graph node in the version evolution label set, we can analyze its consistency performance across different version changes. Finally, the semantic confidence, relational integrity, and version consistency metrics are weighted and fused to obtain a node consistency score that comprehensively reflects the reliability of semantic matching, the completeness of structural relations, and the stability of version evolution. The consistency score results calculated from all constraint graph nodes in the enhanced constraint graph are summarized, and combined with the set of minimum conflict subgraphs, a comprehensive judgment is made on each constraint graph node and its associated relation edges to determine the specific nodes, relations and conflict ranges that violate the consistency rules, forming a complete consistency detection result set.

[0013] Optionally, the step of locating the corresponding material paragraph or code segment based on the consistency detection result set and the minimum conflict subgraph set, and generating a difference verification report and a set of remediation suggestions specifically includes: Based on the consistency detection result set and the minimum conflict subgraph set, combined with the evidence layer and temporal layer in the heterogeneous knowledge graph, the source identifier, material location index, content hash value, version number, generation or modification timestamp and operation type are extracted one by one for each constraint graph node and relationship that is judged to be inconsistent, forming a set of difference source information for the generation of difference reports and the generation of repair suggestions. Based on the consistency detection result set, the minimum conflict subgraph set, and the difference source information set, a mapping relationship is established between each inconsistency constraint graph node and its associated relation edge and the corresponding source identifier, material location index, content hash value, and version evolution information, and a difference location table is formed. Based on the discrepancy location table, the inconsistency constraint diagram nodes and relationships recorded therein are grouped and hierarchically organized according to node level, relationship level and version impact scope. For each group, a corresponding discrepancy verification item is generated, and the items are summarized to form a discrepancy verification report set. Based on the set of difference verification reports, and combined with the comprehensive anchor confidence in the semantic anchor mapping table, the completed set of relationships, and the set of version evolution tags, a comprehensive analysis is conducted on the functional modules, interface names, data fields, and constraint logic involved in each difference verification item. The main causes of the differences and their impact on semantics, structure, and version evolution are determined, and a corresponding set of repair suggestions is generated.

[0014] The beneficial effects of this invention are: This invention achieves unified modeling and global association of multi-source heterogeneous software copyrighted materials by constructing a heterogeneous knowledge graph comprising a mode layer, an instance layer, an evidence layer, and a temporal layer. Structurally, it breaks through the traditional consistency verification method that relies solely on a single data source. This graph framework can synchronously record the semantic type, instance relationship, source anchor point, and version evolution information of entities within the same system, providing a complete data foundation for subsequent cross-modal semantic anchoring, rule reasoning, and incremental updates. This allows the functional correspondence, interface relationship, and data flow between materials to be comprehensively presented in a structured and computable manner.

[0015] Building upon this foundation, the cross-modal semantic anchoring mechanism proposed in this invention calculates the comprehensive anchoring confidence by weighted fusion of rule matching, context similarity, and structural alignment results, and generates a semantic anchoring mapping table. This enables automated matching and disambiguation between source code, design documents, and structural drawings. By combining the formalization of consistency rules with the construction of enhanced constraint graphs, this method can automatically identify unsatisfiable constraint combinations and extract the minimum conflict subgraph during graph rule reasoning and satisfiability detection. Furthermore, it completes relation completion, logical conflict detection, and consistency scoring at the graph level, providing a reliable basis for identifying semantic differences and missing relations across files and versions.

[0016] This invention can automatically generate a set of verification conclusions containing discrepancy location information and remediation suggestions, achieving full automation from data collection, map construction, anchoring inference to discrepancy report output. Compared with existing technologies that rely on manual retrieval or simple script comparison, this method improves verification efficiency, consistency detection rate, version difference location accuracy, and result traceability, and provides systematic support for rapid modification, review feedback, and quality control of software copyright materials. Attached Figure Description

[0017] The accompanying drawings are provided to further illustrate the invention and form part of the specification. They are used in conjunction with embodiments of the invention to explain the invention and do not constitute a limitation thereof. In the drawings:

[0018] Figure 1 This is a flowchart of an automatic verification method for software copyright consistency based on knowledge graphs proposed in this invention; Figure 2This is a schematic diagram of the heterogeneous knowledge graph structure in the automatic verification method for software copyright consistency based on knowledge graph proposed in this invention; Figure 3 This is a schematic diagram of the cross-modal semantic anchoring and confidence calculation process in the automatic verification method for software copyright consistency based on knowledge graph proposed in this invention. Detailed Implementation

[0019] The present invention will now be described in further detail with reference to the accompanying drawings. These drawings are simplified schematic diagrams, illustrating only the basic structure of the invention, and therefore only show the components relevant to the invention.

[0020] refer to Figure 1-3 An automatic verification method for software copyright consistency based on knowledge graphs includes the following steps: Collect software copyright application materials and perform format standardization, paragraph annotation, redundancy removal and coding standardization to form a standardized set of original materials; Multimodal analysis is performed on the standardized original material set to form an initial entity set and a candidate relation set; Based on the initial entity set and the candidate relation set, a heterogeneous knowledge graph is constructed, which includes a pattern layer, an instance layer, an evidence layer and a temporal layer. Perform cross-modal semantic anchoring processing on heterogeneous knowledge graphs, generate semantic anchoring mapping tables, and assign anchoring confidence value sets; Based on the semantic anchoring mapping table and the anchoring confidence value set, combined with heterogeneous knowledge graphs, the consistency requirements of software copyright materials are transformed into formal rules and constraint graphs are generated. Based on heterogeneous knowledge graphs and enhanced constraint graphs, output a consistency detection result set and a set of minimum conflict subgraphs; Based on the consistency detection result set and the minimum conflict subgraph set, the corresponding material paragraph or code fragment is located, and a difference verification report and a set of remediation suggestions are generated.

[0021] In this embodiment, the process of collecting software copyright application materials and performing format standardization, paragraph annotation, redundancy removal, and code standardization to form a standardized original material set specifically includes: Obtain the software copyright application materials to be verified, and divide the software copyright application materials into a set of source code files, a set of functional design documents, a set of interface specifications, a set of user manuals, and a set of structural drawings to form an initial set of materials for subsequent format unification, paragraph annotation, redundancy removal, and code standardization processing. The initial set of materials is processed to unify the format, including unifying the character encoding format to UTF-8, the file type suffix, and the paragraph level tags, and generating a format-unified set. Paragraph annotation processing is performed on the uniformly formatted set, dividing each document into a set of paragraph units and assigning a unique identifier to each paragraph unit; Perform redundancy cleaning on the paragraph unit set, deleting duplicate paragraphs, blank paragraphs, and invalid characters to form a redundancy cleaned set; The redundant cleansing set is subjected to coding standardization processing, and the timestamp format, path representation and version number representation are unified. The processing result is defined as a standardized original material set.

[0022] In this embodiment, the step of performing multimodal analysis on the standardized original material set to form an initial entity set and a candidate relation set specifically includes: The standardized raw material set is categorized by type and divided into source code file set, functional design document set, interface specification set, user manual set, and structural drawing set according to content attributes; Fine-grained syntactic structure extraction is performed on the collection of source code files. First, the lexical and syntactic structure of each source code file is parsed, and a complete abstract syntax tree is constructed to record package, class, method, variable and scope information in a hierarchical manner. Then, a call graph is generated based on the call relationship between methods to characterize the dependency between functions and modules. During the construction of the abstract syntax tree and call graph, signature recognition is performed on each method and interface, and interface features are extracted. The interface features include interface name, parameter type, return type, and access control attributes. Subsequently, based on the hierarchical structure of the abstract syntax tree, independent functional module units are identified, and the classes, methods, data fields, and interface call relationships contained in the module are completely mapped into the structured record; Based on this, a set of functional modules, a set of interface names, a set of data fields, and a set of call relationships are generated on the code side. A unique identifier and associated index are established for each element in each set to ensure accurate referencing and tracking in the subsequent knowledge graph construction and cross-modal semantic anchoring process. The document semantic analysis process is performed on the functional design document set, interface specification set, and user manual set. First, the documents are segmented according to the title level and paragraph structure and a hierarchical index is established. Then, word segmentation, named entity recognition, and dependency parsing techniques are used to extract the functional modules, interface names, data fields and their hierarchical relationships in the documents. During this process, text fragments describing system constraints are identified and constrained to form constraint logic records. At the same time, relational information reflecting inter-module dependencies, data flow, and interface call order is extracted from the documents. Finally, based on the established paragraph index and semantic annotation results, a set of functional modules, interface names, data fields, constraint logic, and descriptive relationships are generated on the document side. A unique identifier and associated index are established for each element in each set to ensure accurate referencing and tracing in the subsequent knowledge graph construction and cross-modal semantic anchoring process. The structural drawing set is processed for drawing structure recognition. First, each drawing file is converted into a parsable vector or graphic data format. The graphic symbols, connecting lines, text annotations and legends are parsed in layers and blocks. Based on the geometric position, connection relationship and annotation content, the key graphic elements representing system functional modules, interface ports and data channels are identified. Subsequently, the identified graphic elements and connections are classified and their relationships are modeled. The functional modules, interface names and data field information contained in the drawings are extracted, and the corresponding connection relationships are established to represent the topology and dependencies between modules. Finally, a set of functional modules, interface names, data fields, and connection relationships are generated on the drawing side. A unique identifier and index are established for each element in each set to ensure that the knowledge graph can be accurately associated and invoked in subsequent knowledge graph construction and cross-modal semantic anchoring. The functional module set, interface name set, data field set, and constraint logic set generated from the code side, document side, and drawing side are integrated in a unified manner. Elements with the same semantics or the same name are deduplicated and merged. A global index is established according to four categories: functional module, interface name, data field, and constraint logic, forming an initial entity set covering all sources. Meanwhile, the call relationships, description relationships, and connection relationships extracted from various sources are uniformly organized, the relationship types and directions are standardized, and a unified relationship index across sources is established to form a set of candidate relationships that can be directly used for knowledge graph construction, so as to ensure that the structured information between different materials can remain consistent and traceable in subsequent graph construction.

[0023] In this embodiment, the construction of a heterogeneous knowledge graph based on the initial entity set and the candidate relation set, wherein the heterogeneous knowledge graph includes a pattern layer, an instance layer, an evidence layer, and a temporal layer, specifically includes: Based on the initial entity set and the candidate relation set, a heterogeneous knowledge graph is constructed, which includes a pattern layer, an instance layer, an evidence layer and a temporal layer. Among them, the schema layer is used to define entity types and relation types, the instance layer is used to carry specific structured entities and semantic relations, the evidence layer is used to record the source and location anchors of each entity and relation in the original material, and the temporal layer is used to describe version information and evolution path, thus forming a basic framework of heterogeneous knowledge graph with complete semantics and hierarchical structure. In the schema layer, corresponding node types are defined for the functional module set, interface name set, data field set, and constraint logic set, respectively. Corresponding relation types are defined for the call relation, description relation, and connection relation in the candidate relation set. Based on this, according to the correspondence between each node type and relation type, a set of triplet relations consisting of the starting node type, relation type, and target node type is established to form the semantic structure framework of the schema layer. In the instance layer, each entity in the initial entity set is mapped to an instance node, resulting in an instance node set. Each relationship in the candidate relationship set is mapped to a relationship edge between nodes, resulting in a relationship edge set. An instance layer graph is constructed based on the instance node set and the relationship edge set to fully represent various entities and their relationships in actual materials. In the evidence layer, a set of corresponding anchor point information is established for each node and each relation edge in the instance layer graph. For each anchor point, the original material source identifier, the precise location index in the material, and the content hash value are recorded. The above information is associated with the corresponding node or relation edge to provide verifiable source evidence and location basis in the subsequent consistency verification and result traceability process. In the temporal layer, a version evolution label set is established for each node and each relation edge in the instance layer graph. Each label records the version number, the timestamp of version generation or modification, the operation type of the version, and the associated changes. The label set is bidirectionally associated with the corresponding node or relation edge to comprehensively represent the evolutionary state of each entity and relation in different versions, including additions, modifications, and deletions. This provides a complete time series basis and a precise evolution path description for subsequent consistent inference, version difference detection, and incremental updates.

[0024] In this embodiment, the step of performing cross-modal semantic anchoring processing on the heterogeneous knowledge graph, generating a semantic anchoring mapping table, and allocating a set of anchoring confidence values ​​specifically includes: Read heterogeneous knowledge graphs, which include a pattern layer, an instance layer, an evidence layer, and a temporal layer, providing node types and relation types, set of instance nodes and set of relation edges, set of anchor information, and set of version evolution tags, respectively, providing a complete graph structure and basic data for cross-modal semantic anchoring processing; In the instance node set, all nodes are grouped according to the source identifier and node pairs from different sources are filtered. Each pair of nodes that meets the source difference condition is combined into a candidate anchor pair, and the candidate anchor set is summarized to be used in subsequent steps to perform rule matching, context similarity calculation and structural alignment calculation on each candidate anchor pair in sequence. For each pair of instance nodes in the candidate anchoring set, based on the node type and relation type defined in the pattern layer and the source identifier, location index and content hash value provided in the evidence layer, the node name, relation pattern and type consistency are compared item by item, and a rule matching score is generated. The rule matching score is recorded and transmitted as the basic input for subsequent context similarity calculation, structure alignment calculation and comprehensive anchoring confidence calculation. For each pair of anchor nodes in the candidate anchor set, extract the contextual semantic information of each pair of anchor nodes in the instance layer graph, transform the paragraph text where the anchor node is located, the associated interface description and related descriptive relationships into a unified semantic vector representation, calculate and output the contextual similarity score of the anchor node pair, and store the contextual similarity score for subsequent comprehensive anchor confidence calculation. For each pair of anchor nodes in the candidate anchor set, first determine their respective neighborhood range in the instance layer graph, and extract the set of adjacent nodes directly connected to the anchor node and the set of multi-hop associations, the connection relationship type, the relationship direction and the topology depth. Then, the node attributes, relationship patterns, edge weights, and hierarchical positions of each neighborhood are encoded sequentially to form a comparable neighborhood structure feature description. Next, the two sets of neighborhood structural features are matched and the differences are measured item by item. The similarity in terms of node adjacency pattern, relation topology and multi-hop path consistency is comprehensively evaluated to obtain the structural similarity score of the anchor node pair. The structural similarity score is stored and transmitted for subsequent comprehensive anchor confidence calculation. The overall anchor confidence score is calculated by weighting the rule matching score, context similarity score, and structural similarity score. ; in, , For anchoring node pairs, To comprehensively anchor the confidence level, Weight the score for matching the rules. Score for rule matching. As the weight for context similarity score, Context similarity score, As the weight for structural similarity scores, Score the structural similarity. For each pair of anchor nodes in the candidate anchor set, read the comprehensive anchor confidence score calculated in the previous step and compare it with the preset threshold one by one. Determine the node pairs with a comprehensive anchor confidence score greater than or equal to the threshold as valid anchor pairs. All valid anchor pairs, along with their corresponding comprehensive anchor confidence scores, are stored in a semantic anchor mapping table. Simultaneously, a set of anchor confidence scores is generated to provide filtered matching relationships and quantitative confidence data to the subsequent consistency verification rule compilation and constraint graph generation steps, thereby achieving complete recording and transmission of cross-modal semantic anchoring results. The generated semantic anchoring mapping table and the corresponding set of anchoring confidence values ​​are output as the final anchoring result and stored in association with the heterogeneous knowledge graph so that they can be directly called in the subsequent consistency verification rule compilation, constraint graph generation and inference calculation process, so as to realize the complete inheritance and unified management of cross-modal semantic anchoring information.

[0025] In this embodiment, the step of transforming the consistency requirements of software copyright materials into formal rules and compiling a constraint graph based on a semantic anchoring mapping table and an anchoring confidence value set, combined with a heterogeneous knowledge graph, specifically includes: The semantic anchoring mapping table and anchoring confidence value set generated in the previous steps are read, and combined with the pattern layer, instance layer, evidence layer and temporal layer in the heterogeneous knowledge graph, the functional modules, interface names, data fields and constraint logic are classified and organized according to different dimensions of software copyright material consistency requirements. Specific verification conditions are extracted item by item. The specific verification conditions include interface declaration and implementation consistency, data field value consistency, call relationship closure, and permission and constraint matching. Each verification condition is standardized into an independent consistency rule element, and they are summarized to form a consistency rule candidate set, which is used as input for subsequent rule formalization and constraint graph generation. Each rule extracted from the consistency rule candidate set is processed according to the software copyright consistency verification requirements. It combines the node type and relation type of the schema layer, the set of instance nodes and relation edges of the instance layer, the matching node pairs in the semantic anchoring mapping table and the corresponding anchoring confidence. The functional modules, interface names, data fields and constraint logic involved in the rule are variableized. The value range, dependency relationship and conflict condition of the constraint variable are determined one by one. According to the requirements of satisfiability detection, the rule content is compiled into logical constraint items, forming a set of constraint expressions composed of constraint variables, constraint relationships and constraint conditions. This set of constraint expressions is used to provide complete and directly callable formal input for the subsequent construction of constraint graph. The constraint expression set is relationally decomposed to identify all constraint variables and constraints involved. Each constraint variable or constraint condition is used to generate a corresponding constraint graph node, and the dependencies or conflicts in the constraint expressions are used to generate corresponding constraint graph edges. These are then combined to form a constraint graph node set and a constraint graph edge set. Based on this, an initial constraint graph is constructed to fully represent the associations, dependencies, and conflicts between consistency rules and to serve as the input for subsequent calculations. In the initial constraint diagram, the corresponding anchored entity pair, comprehensive anchoring confidence level, and source evidence index information are recorded for each constraint variable node, and associated with the anchor point information in the evidence layer to ensure the traceability relationship between the constraint conditions and the original materials. Each constraint variable node is attached with a version evolution label from the temporal layer, which records the version number, the timestamp of version generation or modification, and the operation type. This label describes the addition, modification, or deletion status of the constraint variable under different versions and supports subsequent version difference detection and incremental updates, resulting in an enhanced constraint graph.

[0026] In this embodiment, the step of outputting a consistency detection result set and a minimum conflict subgraph set based on heterogeneous knowledge graphs and enhanced constraint graphs specifically includes: In the enhanced constraint graph and instance layer graph, the node types, relation types and triple relation sets defined in the schema layer are used as inference rules. The real node set, edge set and neighborhood context provided by the instance layer graph are called. Each constraint variable node and its associated relation are matched and logically calculated one by one. The missing relations caused by the fusion of multi-source materials or incomplete description are automatically identified and new inference relation sets are generated. These relations are bound and updated with the actual nodes and edges in the instance layer. This provides complete relation inputs that have been extended by rule reasoning and can be directly implemented for subsequent semantic relation completion, satisfiability detection and consistency scoring calculation. The inference relation set and the candidate relation set are merged to generate the complete relation set; In the enhanced constraint graph, satisfiability checks are performed on the set of constraint expressions generated in the previous steps one by one. The analysis is conducted to determine whether each constraint variable and dependency relationship simultaneously satisfies the logical conditions. All constraint combinations that are conflicting or cannot be satisfied simultaneously are identified. The set of minimum conflict subgraphs composed of relevant nodes and relation edges is extracted and output to clearly indicate the specific scope of the violation of consistency rules and to provide basic data for the generation of subsequent consistency scores and verification reports. For each constraint graph node in the enhanced constraint graph, the node pair and the comprehensive anchor confidence of the constraint graph node in the semantic anchoring mapping table are first obtained to measure the reliability of semantic matching. Then, the completed set of relations is retrieved, and the association between the constraint graph nodes and related constraint graph nodes in terms of relational integrity and constraint satisfaction is evaluated. Furthermore, by combining the version number, timestamp, and operation type of the constraint graph node in the version evolution label set, we can analyze its consistency performance across different version changes. Finally, the semantic confidence, relational integrity index and version consistency index are weighted and fused to obtain a node consistency score that comprehensively reflects the reliability of semantic matching, the completeness of structural relations and the stability of version evolution. The node consistency score is used as the quantitative basis for generating the consistency detection result set in the future. The consistency score results calculated from all constraint graph nodes in the enhanced constraint graph are summarized, and combined with the set of minimum conflict subgraphs, a comprehensive judgment is made on each constraint graph node and its associated relation edges to determine the specific nodes, relations and conflict ranges that violate the consistency rules, forming a complete consistency detection result set.

[0027] In this embodiment, the step of locating the corresponding material paragraph or code segment based on the consistency detection result set and the minimum conflict subgraph set, and generating a difference verification report and a set of remediation suggestions specifically includes: Based on the consistency detection result set and the minimum conflict subgraph set, combined with the evidence layer and temporal layer in the heterogeneous knowledge graph, the source identifier, material location index, content hash value, version number, generation or modification timestamp and operation type are extracted one by one for each constraint graph node and relationship that is judged to be inconsistent, forming a set of difference source information for the generation of difference reports and the generation of repair suggestions. Based on the consistency detection result set, the minimum conflict subgraph set, and the difference source information set, each inconsistency constraint graph node and its associated relationship edge are mapped one by one with the corresponding source identifier, material location index, content hash value, and version evolution information. This is organized into a difference location table, which is used to accurately describe the specific location, source evidence, and version evolution path of each inconsistency node or relationship in the original material, providing a complete data foundation for the subsequent generation of difference verification reports. Based on the difference location table, the nodes and relationships of the inconsistency constraint diagram recorded therein are grouped and classified according to node level, relationship level and version impact scope. For each group, a corresponding difference verification item is generated, and the difference verification report is compiled item by item to form a set of difference verification reports. This is used to comprehensively present the differences in semantics, structure and version evolution of the software copyright materials, and to provide detailed basis for the subsequent generation of remediation suggestions. Based on the set of difference verification reports, and combined with the comprehensive anchor confidence in the semantic anchor mapping table, the completed set of relationships, and the set of version evolution tags, a comprehensive analysis is conducted on the functional modules, interface names, data fields, and constraint logic involved in each difference verification item. The main causes of the differences and their impact on semantics, structure, and version evolution are determined, and a corresponding set of repair suggestions is generated to provide precise repair solutions for subsequent material modifications, interface renaming, supplementary explanations, or version rollback operations.

[0028] Example 1: To verify the feasibility of this invention in practice, it was applied to a software copyright application project undertaken by a software company. The company was required to submit 300,000 lines of source code, 42 functional design documents, 25 interface specifications, 15 user manuals, and 20 system architecture drawings. Due to the long development cycle and multiple iterations, the numerous versions of materials, frequent updates, and diverse sources made it difficult to guarantee consistency between the descriptions in the documents using traditional manual verification and script comparison methods. Previously, the company used conventional text retrieval and simple script matching, with each round of verification taking an average of 36 hours. Furthermore, subsequent review stages still revealed interface description conflicts and inconsistent version data, requiring an average of three to four rounds of correction each time, significantly increasing the development and review cycle and costs.

[0029] In this scenario, the invention first automatically collects source code, functional design documents, interface specifications, user manuals, and structural drawings. After standardizing file formats, paragraph annotations, redundancy removal, and coding, a standardized raw material set is generated. The system performs multimodal parsing on this material set, extracting functional modules, interface names, data fields, call relationships, and constraint logic to form an initial entity set and a candidate relationship set. Subsequently, a heterogeneous knowledge graph containing a schema layer, instance layer, evidence layer, and temporal layer is constructed. The graph not only records the types and semantics of entities and relationships but also binds the source anchor point and version evolution label of each node and relationship, achieving cross-modal semantic anchoring and disambiguation. Based on rule matching, contextual semantics, and graph structure alignment, the system generates a semantic anchoring mapping table and an anchoring confidence set. Then, the consistency rules are transformed into formal constraints and an enhanced constraint graph is constructed. Through graph rule reasoning, semantic relationship completion, satisfiability detection, and consistency scoring, the system automatically identifies the least conflicting subgraph and outputs the consistency detection result. Finally, the system automatically generates a discrepancy verification report and remediation suggestions, including the location of the files involved, the associated versions, and the suggested modification schemes, which can be directly revised by the R&D personnel.

[0030] Test results show that the application of this invention in the company's real-world project improved the efficiency and accuracy of consistency checks. The system processed over 500,000 text segments, more than 9,000 interface definitions, and 24,000 call relationships, automatically identifying 365 cross-file semantic inconsistencies and 110 version evolution conflicts. Compared to traditional manual checks, the total processing time was reduced to less than four hours, the average accuracy rate reached 98.6%, the version difference location accuracy reached 99.1%, the number of subsequent corrections was reduced to less than one, and the first-time pass rate of materials increased to over 96%. These data fully verify the efficiency and reliability of this invention in the automatic consistency check of multi-source, heterogeneous, and version-complex software copyright materials, providing strong technical support for the rapid filing of large-scale software intellectual property rights.

[0031] Table 1. Implementation Results Data of Automatic Verification of Software Copyright Conformity

[0032] As can be seen from Table 1 above, this invention has achieved improvements in key performance indicators of automatic verification of software copyright consistency compared to traditional manual verification methods. Firstly, in terms of cross-document semantic inconsistency identification, this invention identified 365 semantic inconsistencies in a real project containing 300,000 lines of source code, 42 functional design documents, 25 interface specifications, 15 user manuals, and 20 system architecture drawings, achieving an average identification rate of 98.6%, which is 38.6 percentage points higher than the approximately 60% identification rate of traditional manual verification. This indicates that the heterogeneous knowledge graph constructed through the schema layer, instance layer, evidence layer, and temporal layer, along with the cross-modal semantic anchoring and rule-based reasoning mechanism, can more comprehensively capture and analyze cross-document semantic conflicts.

[0033] Secondly, in terms of version evolution conflict identification, this invention can accurately identify 110 instances of version differences and evolution issues involving code and documents, achieving an identification rate of 99.1%, which is 44.1 percentage points higher than the approximately 55% identification rate of traditional methods. By introducing a temporal layer of version number, timestamp, and operation type into the knowledge graph and combining it with an enhanced constraint graph, dynamic tracking of the version evolution process and automatic extraction of the minimum conflict subgraph are achieved, providing effective support for multi-version, multi-stage material verification.

[0034] Finally, this invention also demonstrates significant advantages in processing efficiency and subsequent revision costs. The complete verification process takes an average of only 4 hours, which is about 32 hours shorter than the traditional manual processing time of 36 hours, resulting in an overall efficiency improvement of more than 8 times. The number of subsequent corrections has been reduced from the traditional average of 3 to 4 times to less than 1 time, and the first-time pass rate has increased from about 70% to over 96%, significantly reducing the workload of repeated modifications and submissions. Therefore, this invention achieves significant optimizations in semantic matching accuracy, version difference location, verification speed, and result traceability, providing efficient and reliable technical support for software copyright applications and effectively reducing the time and labor costs for enterprises in the consistency verification of multi-source heterogeneous materials.

[0035] The above description is only a preferred embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any equivalent substitutions or modifications made by those skilled in the art within the scope of the technology disclosed in the present invention, based on the technical solution and inventive concept of the present invention, should be covered within the scope of protection of the present invention.

Claims

1. A method for automatic verification of software copyright consistency based on knowledge graphs, characterized in that, Includes the following steps: Collect software copyright application materials and perform format standardization, paragraph annotation, redundancy removal and coding standardization to form a standardized set of original materials; Multimodal analysis is performed on the standardized original material set to form an initial entity set and a candidate relation set; Based on the initial entity set and the candidate relation set, a heterogeneous knowledge graph is constructed, which includes a pattern layer, an instance layer, an evidence layer and a temporal layer. Perform cross-modal semantic anchoring processing on heterogeneous knowledge graphs, generate semantic anchoring mapping tables, and assign anchoring confidence value sets; Based on the semantic anchoring mapping table and the anchoring confidence value set, combined with the heterogeneous knowledge graph, the consistency requirements of software copyright materials are transformed into formal rules and an enhanced constraint graph is generated. Based on heterogeneous knowledge graphs and enhanced constraint graphs, output a consistency detection result set and a set of minimum conflict subgraphs; Based on the consistency detection result set and the minimum conflict subgraph set, the corresponding material paragraph or code fragment is located, and a difference verification report and a set of remediation suggestions are generated.

2. The method for automatic verification of software copyright consistency based on knowledge graphs according to claim 1, characterized in that, The standardized raw material set includes a set of source code files, a set of functional design documents, a set of interface specifications, a set of user manuals, and a set of structural drawings that have undergone standardized formatting, paragraph annotation, redundancy removal, and coding standardization.

3. The method for automatic verification of software copyright consistency based on knowledge graphs according to claim 1, characterized in that, The process of performing multimodal analysis on the standardized original material set to form an initial entity set and a candidate relation set specifically includes: The standardized raw material set is categorized by type and divided into source code file set, functional design document set, interface specification set, user manual set, and structural drawing set according to content attributes; Extract the syntax structure from the source code file set, construct an abstract syntax tree and call graph, extract interface signatures, and generate a set of functional modules, interface names, data fields, and call relationships on the code side; Perform semantic analysis on the functional design document set, interface specification set, and user manual set to obtain a semantic unit set and a terminology set, and generate a document-side functional module set, interface name set, data field set, constraint logic set, and descriptive relationship set; Perform drawing structure recognition on the set of structural drawings to obtain a set of graphic elements and a set of connection relationships, and generate a set of functional modules, a set of interface names and a set of data fields on the drawing side based on the graphic element annotations; The initial entity set is obtained by combining similar elements from the code side, document side, and drawing side, and the candidate relationship set is obtained by combining relational elements.

4. The method for automatic verification of software copyright consistency based on knowledge graphs according to claim 1, characterized in that, The construction of a heterogeneous knowledge graph based on an initial entity set and a candidate relation set, specifically including a schema layer, an instance layer, an evidence layer, and a temporal layer, comprises: Based on the initial entity set and the candidate relation set, a heterogeneous knowledge graph is constructed, which includes a pattern layer, an instance layer, an evidence layer and a temporal layer. In the schema layer, the corresponding node types are defined for the functional module set, interface name set, data field set, and constraint logic set, and the corresponding relationship types are defined for the call relationship, description relationship, and connection relationship in the candidate relationship set, and a triplet relationship set composed of the starting node type, relationship type, and target node type is established. In the instance layer, each entity in the initial entity set is mapped to an instance node, resulting in an instance node set. Each relationship in the candidate relationship set is mapped to a relationship edge between nodes, resulting in a relationship edge set. An instance layer graph is constructed based on the instance node set and the relationship edge set. In the evidence layer, a set of corresponding anchor point information is established for each node and each relation edge in the instance layer graph; In the temporal layer, a set of version evolution labels is created for each node and each relation edge in the instance layer graph.

5. The method for automatic verification of software copyright consistency based on knowledge graphs according to claim 1, characterized in that, The specific steps of performing cross-modal semantic anchoring processing on heterogeneous knowledge graphs, generating a semantic anchoring mapping table, and assigning a set of anchoring confidence values ​​include: Read heterogeneous knowledge graphs, which include a pattern layer, an instance layer, an evidence layer, and a temporal layer, providing node types and relation types, a set of instance nodes and a set of relation edges, a set of anchor information, and a set of version evolution tags, respectively. In the instance node set, all nodes are grouped according to the source identifier and node pairs from different sources are filtered. Each pair of nodes that meets the source difference condition is combined into a candidate anchor pair to form a candidate anchor set. For each pair of instance nodes in the candidate anchor set, a rule matching score is generated based on the node type and relation type defined in the schema layer and the evidence layer. For each pair of instance nodes in the candidate anchor set, extract the corresponding contextual semantic information in the instance layer graph and calculate the contextual similarity score; For each pair of instance nodes in the candidate anchoring set, perform structural alignment calculation on the instance layer graph, extract the neighborhood subgraph, and generate a structural similarity score; The overall anchor confidence score is calculated by weighting the rule matching score, context similarity score, and structural similarity score. The overall anchor confidence level is compared with the preset threshold one by one, and the node pairs with an overall anchor confidence level greater than or equal to the threshold are determined as valid anchor pairs; All valid anchor pairs, along with their corresponding comprehensive anchor confidence scores, are stored in a semantic anchor mapping table, and a set of anchor confidence scores is generated simultaneously.

6. The method for automatic verification of software copyright consistency based on knowledge graphs according to claim 1, characterized in that, The process of transforming software copyright material consistency requirements into formal rules and generating enhanced constraint graphs based on semantic anchoring mapping tables and anchoring confidence value sets, combined with heterogeneous knowledge graphs, specifically includes: Based on the semantic anchoring mapping table and the anchoring confidence value set, and combined with the pattern layer, instance layer, evidence layer and temporal layer in the heterogeneous knowledge graph, a candidate set of consistency rules is constructed. Each rule extracted from the candidate set of consistency rules is used to form a set of constraint expressions according to the consistency verification requirements of software copyright materials; The constraint expression set is relationally decomposed to generate a constraint graph node set and a constraint graph edge set, and an initial constraint graph is constructed. In the initial constraint graph, the corresponding anchored entity pair, the overall anchor confidence level, and the source evidence index are recorded for each constraint variable node; By combining the set of version evolution labels in the temporal layer, a version evolution attribute is added to each constraint variable node of the initial constraint graph to obtain an enhanced constraint graph.

7. The method for automatic verification of software copyright consistency based on knowledge graphs according to claim 1, characterized in that, The specific output of the consistency detection result set and the minimum conflict subgraph set based on heterogeneous knowledge graphs and enhanced constraint graphs includes: Graph rule reasoning is performed on the enhanced constraint graph and instance layer graph, and missing relation edges are derived based on the pattern layer triple set to generate a set of reasoning relations; The inference relation set and the candidate relation set are merged to generate the complete relation set; Perform satisfiability checks on the enhanced constraint graph structure, perform logical solutions on the set of constraint expressions, and output the set of minimum conflicting subgraphs; For each constraint graph node in the enhanced constraint graph, the consistency score of the constraint graph node is calculated by combining the node pair corresponding to the constraint graph node in the semantic anchoring mapping table and the comprehensive anchoring confidence, and a set of consistency score results is obtained. Based on the consistency score result set and the minimum conflict subgraph set, a comprehensive judgment is made on each constraint graph node and its associated relation edges to form a complete consistency detection result set.

8. The method for automatic verification of software copyright consistency based on knowledge graphs according to claim 1, characterized in that, The process of locating the corresponding material paragraph or code fragment based on the consistency detection result set and the minimum conflict subgraph set, and generating a difference verification report and a set of remediation suggestions specifically includes: Based on the consistency detection result set and the minimum conflict subgraph set, combined with the heterogeneous knowledge graph, the anchor point information set of each inconsistent constraint graph node and the set of associated relationships, as well as the version evolution tag set, are extracted to form the difference source information set. Based on the consistency detection result set, the minimum conflict subgraph set, and the difference source information set, a mapping is established between the anchor point information set and the version evolution tag set to generate a difference location table; Based on the discrepancy location table, inconsistent constraint diagram nodes and relationships are grouped and classified according to node level, relationship level, and version impact scope to form a set of discrepancy verification reports; Based on the set of difference verification reports, the comprehensive anchor confidence in the semantic anchor mapping table, the completed set of relationships, and the version evolution tags, a set of repair suggestions is generated.

Images