A digital research and development demand automatic disassembly method based on knowledge reasoning

Abstract

The application discloses a kind of digital research and development needs automatic disassembly method based on knowledge reasoning, comprising the following steps: gathering multiple source needs unified de-duplication and build version baseline;From normalized demand to generate semantic graph, construct support atlas and constraint set, form resource image, historical measurement and template library;With improved GraphRAG model to search and subgraph aggregation, complete alignment reasoning and output fact set, conflict list and missing list;With improved Reflexion algorithm to generate hierarchical tasks, dependency and priority, and perform shadow scheduling and acyclic verification to obtain execution order table;Accordingly, generate design / interface / test / verification / acceptance artifacts and solve resources, milestones and critical path;Establish traceability link and early warning mechanism, re-arrange and resource reallocation when limit time is exceeded.The method shortens scheduling formation time, reduces rework and delay risk, improves artifact coverage, critical path controllability and delivery traceability.

Description

Technical Field

[0001] This invention relates to the field of intelligent software engineering and R&D management technology, and in particular to a method for automatically decomposing digital R&D requirements based on knowledge reasoning. Background Technology

[0002] With the increasing demand for digital R&D and lean delivery, requirements decomposition and plan generation technologies for software / smart hardware have gained attention. Existing methods largely rely on manual review, keyword retrieval, and static templates, or partially incorporate vector retrieval and summarization. However, they generally suffer from the following problems under multi-source input and cross-team collaboration:

[0003] The system suffers from several issues: a lack of unified standards and deduplication for multi-source requirements; incomplete version baselines and source indexes; difficulty in tracing historical changes; a lack of semantic graphs from standardized requirements to entity-relationship relationships, making alignment with enterprise rules and project configurations difficult and resulting in significant semantic drift; limited paragraph-level retrieval, lack of subgraph aggregation and constrained alignment reasoning between semantic graphs and supporting graphs, making it difficult to proactively expose conflicts and omissions; task generation relies on experience, lacking self-reflective iteration combining facts, conflicts, and omissions, resulting in insufficient granularity and interpretability; scheduling does not explicitly introduce constraint sets and resource profiles, lacks shadow scheduling and DAG verification, and postpones concurrency and time-limit risks; design / interface / testing / verification / acceptance artifacts are disconnected from tasks and dependencies, resulting in an incomplete coverage matrix; and a weak traceability link, making it impossible to implement early warnings and over-limit rescheduling based on critical paths and resource plans.

[0004] Therefore, how to provide a method for automatically breaking down digital R&D requirements based on knowledge reasoning 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 decomposition method for digital R&D requirements based on knowledge reasoning. This invention comprehensively employs technologies such as improved GraphRAG retrieval and subgraph aggregation, improved Reflexion iterative reasoning, constraint set verification, shadow scheduling, and acyclicity verification to achieve automatic alignment and decomposition of standardized requirements. Furthermore, it solves resource plans, milestone plans, and critical paths to establish a traceable execution chain. It has the advantages of accurate decomposition, strong consistency, feasible plans, closed-loop traceability, fast response to changes, and high overall delivery efficiency.

[0006] An automatic decomposition method for digital R&D requirements based on knowledge reasoning according to an embodiment of the present invention includes the following steps:

[0007] Construct a multi-source requirement list, unify the format and remove duplicates, establish a version baseline and source index, and generate standardized requirements;

[0008] A semantic graph is generated from standardized requirements, a supporting graph is built based on the semantic graph, enterprise rules and project configurations are gathered to form a constraint set, and a resource profile, historical metrics and task template library are constructed.

[0009] An improved GraphRAG model is used to perform retrieval and subgraph aggregation between semantic graph and support graph, and to complete aligned reasoning by combining constraint set, outputting fact set, conflict list and missing list;

[0010] An improved Reflexion algorithm is adopted to generate a hierarchical task set, dependency graph and priority list based on the fact set and with reference to the conflict list and missing list. Shadow scheduling and acyclicity verification are performed under the constraint set and resource profile to obtain the execution order table.

[0011] Based on the hierarchical task set, dependency graph, priority list and execution order table, design artifacts, interface artifacts, test artifacts, verification artifacts and acceptance artifacts are generated, and resource plans, milestone plans and critical paths are solved by combining historical metrics and constraint sets;

[0012] Establish a traceability link and bind the version baseline and source index. Track and warn based on resource plans and critical paths. Implement acceptance at the milestone plan stage. When limits are exceeded, implement rearrangement and resource reallocation based on dependency graphs and priority lists.

[0013] Optionally, the process of constructing a multi-source requirement list, unifying the format and deduplicating entries, establishing a version baseline and source index, and generating standardized requirements specifically includes:

[0014] Requirements from work orders, documents, prototypes, interface specifications, and meeting minutes are aggregated to form a multi-source requirement list;

[0015] Perform field mapping and format correction on the multi-source requirement list to obtain items that conform to a unified template;

[0016] For entries that conform to the unified template, perform deduplication processing, calculate content fingerprints and perform similarity comparison, merge entries that are determined to be duplicates, and obtain a deduplication list;

[0017] Generate a version baseline on the deduplication list, record the baseline number, generation time and reason for change, and obtain a baseline snapshot;

[0018] Record the source system, submitter, submission time, and original location for each item in the inventory, and create a source index;

[0019] After completing format standardization, deduplication, version baseline, and source indexing, a unique identifier is assigned to each entry, and the standardization requirements are output.

[0020] Optionally, the process of generating a semantic graph from standardized requirements, constructing a supporting graph based on the semantic graph, aggregating enterprise rules and project configurations to form a constraint set, and building a resource profile, historical metrics, and task template library specifically includes:

[0021] For the standardization requirements, word segmentation is completed based on dictionary matching and rule segmentation. Subject-verb-object and modification relationships are identified according to dependency relationship rules. Referential resolution is completed by combining the nearest antecedent principle. Entities, attributes and relationships are extracted to generate semantic graphs.

[0022] Based on the semantic graph and existing knowledge entries, the graph is matched and names are merged. Entity alignment and relationship merging are completed according to the judgment rules of type consistency and relationship compatibility to construct the support graph.

[0023] By aggregating enterprise rules and project configurations, type constraints, scope constraints, and timing constraints are transcribed into machine-readable entries, achieving unified standards and forming a constraint set.

[0024] Collect personnel skills, available time periods, and environmental capabilities; calculate available capacity based on qualification verification and time intervals; and generate resource profiles.

[0025] Statistical analysis of historical project records, calculation of project duration distribution, defect distribution, and complexity classification to form historical metrics;

[0026] Organize the parameter placeholders and trigger conditions for functional, interface, test, and verification tasks, establish a search index and keyword mapping, and generate a task template library.

[0027] Optionally, the improved GraphRAG model is used to perform retrieval and subgraph aggregation between the semantic graph and the support graph, and to complete aligned reasoning by combining the constraint set, outputting a fact set, a conflict list, and a missing list, specifically including:

[0028] An improved GraphRAG model is constructed, consisting of a retrieval and subgraph aggregation module, an alignment and constraint filtering module, a conflict minima and supplementation detection module, and a missing detection and result summarization module.

[0029] It receives semantic graph, support graph, constraint set, source index and version baseline as input, performs unified rules on field names and timestamps, converts inconsistent times and identifiers into a unified standard, and obtains a standardized input set.

[0030] The retrieval and subgraph aggregation module performs dual-channel retrieval based on a standardized input set: the semantic retrieval channel calculates semantic similarity scores, and the keyword retrieval channel calculates keyword hit accuracy scores. In the fusion stage, source credibility scores and time freshness scores are introduced as weighting factors. Candidate evidence sets are formed by filtering according to the weighted results and thresholds. The local neighborhood is expanded with the hit nodes of the candidate evidence set in the supporting graph as the center. Following the rules of type consistency and key adjacency preservation, redundant edges are pruned and non-key nodes are compressed. The candidate subgraph sets are aggregated by sorting according to relevance and timeliness.

[0031] The alignment and constraint filtering module performs name alignment and type verification on the requirement entity nodes in the semantic graph and the nodes in the candidate subgraph set. It calculates the alignment score based on the relation schema and adjacency consistency, removes entries with alignment scores below the threshold, and generates an alignment candidate set. Based on the type constraints, range constraints and temporal constraints in the constraint set, it first performs a preliminary quick judgment, then performs a formal satisfiability verification, removes unsatisfiable entries and records the conflict reason entries, forming the alignment set and conflict clue set.

[0032] When the formal satisfiability check fails, the minimum conflict set and supplementary check module extracts the minimum conflict set from the conflict clue set and sends the minimum conflict set back to the retrieval and subgraph aggregation module to trigger targeted supplementary check. The module supplements the basis and subgraph by expanding the keyword set, adjusting the time window and expanding the graph neighborhood radius, and reusing the alignment and constraint screening process until a corrected alignment set is obtained or a set number of rounds is reached.

[0033] The missing detection and result summary module performs integrity checks on the modified alignment set based on the list of required fields in the constraint set and marks uncovered items to form a missing list. The list of required fields refers to the list of fields that various requirements items specified by the constraint set must have. The modified alignment set is truncated according to the confidence threshold and deduplication and synonym merging are performed to form a fact set. The conflict cause items are grouped and archived to form a conflict list.

[0034] Optionally, the improved Reflexion algorithm is adopted, which generates a hierarchical task set, dependency graph, and priority list based on the fact set and with reference to the conflict list and missing list. Shadow scheduling and acyclicity verification are performed under the constraint set and resource profile to obtain the execution order table, specifically including:

[0035] Receive fact sets, conflict lists, missing data lists, constraint sets, and resource profiles;

[0036] Based on the functional items, interface items, quality attributes and time sequence descriptions in the fact set, element matching and granularity determination are performed according to the type constraints, scope constraints and time sequence constraints of the constraint set to generate a draft of the hierarchical task set. The required tasks and verification tasks are supplemented according to the missing list, and the source of the supplementation is marked as "missing list".

[0037] Based on the association relationships of the fact set and the order rules of the constraint set, the pre- and post-relationships, data dependencies and interface dependencies are derived. Duplicate relationships are merged and contradictory relationships are eliminated to obtain a draft dependency graph.

[0038] Shadow scheduling is performed under the constraints of resource profile and constraint set. Concurrency feasibility, time limit satisfaction and resource load are calculated. A dual threshold strategy is adopted. When the resource load exceeds the upper threshold, the relevant tasks are serialized or the concurrency is reduced. When the load is between the upper and lower thresholds, only local order fine-tuning is performed. Resource conflict flags and time limit default flags are output. Restricted tasks and restricted edges are written back to the dependency graph draft.

[0039] Perform loop detection on the dependency graph draft and extract the minimum set of feedback edges to form a loop list. Then, label the positions that are consistent with the conflict list.

[0040] The conflict list, missing list, resource conflict markers, time limit default markers, and loop list are compiled to generate a reflection prompt set. The reflection prompt set is a structured prompt to guide the addition, deletion, and modification operations. It includes conflicting tasks that need to be deleted, missing tasks that need to be added, minimum feedback edges that need to be trimmed, concurrent segments that need to be downgraded, and granular levels that need to be refined.

[0041] Based on the reflection prompts, the initial draft of the hierarchical task set and the draft dependency graph are revised, and deletions, additions, reconnections and granularity adjustments are performed. The task value, risk and blocking degree are calculated based on the constraint set, a priority list is generated, and an execution order table is generated based on the priority list and dependency graph. A threshold is set for the magnitude of the order change. If the threshold is exceeded, the part is rolled back, modified and recalculated.

[0042] Set a convergence threshold group, including acyclicity requirement, resource load not exceeding limit, time limit satisfaction, constraint satisfaction, and clearing the missing list. When any one of them is not met, the results of this round of checks are transformed into a new set of reflection prompts and iterated. When all thresholds are met, output a hierarchical task set, dependency graph, priority list, and execution order table.

[0043] Optionally, the step of generating design artifacts, interface artifacts, test artifacts, verification artifacts, and acceptance artifacts based on the hierarchical task set, dependency graph, priority list, and execution order table, and solving for resource plans, milestone plans, and critical paths by combining historical metrics and constraint sets, specifically includes:

[0044] Based on the hierarchical task set, dependency graph, priority list and execution order table, the inputs, outputs and completion criteria are extracted item by item to generate design artifacts, interface artifacts, test artifacts, verification artifacts and acceptance artifacts;

[0045] Calculate the production relationship along the dependency graph, fill the fields and timing requirements of the interface artifact with the upstream output through field mapping and type verification, determine the order of calls and timeout thresholds according to the execution order table, generate test artifacts and acceptance artifacts for each output in order of priority from high to low according to the priority list, construct a coverage matrix, which is a coverage relationship table from output to artifact entries, and fill in the uncovered units according to the essential item rules of the constraint set.

[0046] By combining historical metrics to estimate the duration of tasks in quantiles, the start and end times and available resources are allocated to tasks according to the time limits and capacity boundaries given by the constraint set. The concurrent load is calculated as the sum of resource usage in the same time period. When the limit is exceeded, a heuristic adjustment is adopted by extending the earliest available time window and exchanging local sequences to obtain the resource plan.

[0047] Under the constraints of resource planning and dependency graphs, the earliest start time is calculated by advancing layer by layer, and the latest start time is calculated by advancing layer by layer to obtain the total float. The task chain with zero total float is determined as the critical path. The delivery node on the critical path and the pass node in the acceptance workpiece are used as anchor points. The milestone plan is generated by node selection and date backward.

[0048] Optionally, the establishment of a traceability link and binding of version baseline and source index, tracking and early warning based on resource plan and critical path, acceptance during milestone plan implementation phases, and reordering and resource reallocation based on dependency graph and priority list when limits are exceeded, specifically includes:

[0049] Based on the version baseline and source index, a traceability link is established, and standardized requirements, hierarchical task sets, dependency graphs, priority lists, execution order tables and various artifacts are associated one by one according to task identifiers to form a queryable mapping.

[0050] Based on the resource plan and critical path, progress tracking is performed, the plan completion rate and critical path time difference are calculated, deviation warnings are generated, and the milestone plan is used as the basis for phase acceptance. The pass records of the accepted workpieces are checked and the release is determined.

[0051] When overdue, overloaded, or blocked events occur, the dependency graph and priority list are read, and changes are triggered and rearranged according to priority and order. The execution order table and resource plan are updated using local order adjustment and resource reallocation strategies, and the reasons for the changes and the scope of impact are recorded.

[0052] The beneficial effects of this invention are:

[0053] This invention uses semantic graphs and supporting graphs to structurally represent requirements. It introduces an improved GraphRAG to achieve version-aware retrieval and subgraph aggregation, and uses constraint sets for pre-screening and satisfiability verification, significantly reducing mismatches and invalid verifications. Combined with an improved Reflexion, it iteratively absorbs fact sets, conflict lists, and missing lists to form hierarchical task sets, dependency graphs, and priority lists. Under the constraints of resource profiles and constraint sets, it completes shadow scheduling and acyclic verification, generating an executable execution order table. Subsequently, based on the above results, it automatically generates design artifacts, interface artifacts, test artifacts, verification artifacts, and acceptance artifacts. It combines historical metrics to solve resource plans, milestone plans, and critical paths, and finally establishes a full-link traceability and early warning mechanism based on version baselines and source indexes. Compared with existing methods that rely on manual disassembly and decentralized verification, this invention achieves automatic alignment of disassembly results with enterprise rules, timely detection and closed-loop repair of conflicting and missing items, more complete task and workpiece coverage, scheduling that better meets resource and time constraints, early warning of critical path deviations, and rapid local rescheduling of changes. Overall, it results in improved disassembly accuracy, enhanced consistency, improved planning feasibility, shorter delivery cycle, and reduced rework rate. Attached Figure Description

[0054] 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:

[0055] Figure 1 This is a flowchart of a method for automatically decomposing digital R&D requirements based on knowledge reasoning, as proposed in this invention.

[0056] Figure 2 This is a schematic diagram of the improved GraphRAG model in the knowledge-based reasoning-based automatic decomposition method for digital R&D requirements proposed in this invention.

[0057] Figure 3 This is a schematic diagram of the improved Reflexion algorithm in the knowledge-based reasoning-based automatic decomposition method for digital R&D requirements proposed in this invention. Detailed Implementation

[0058] 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.

[0059] refer to Figure 1-3 A method for automatically breaking down digital R&D requirements based on knowledge reasoning includes the following steps:

[0060] Construct a multi-source requirement list, unify the format and remove duplicates, establish a version baseline and source index, and generate standardized requirements;

[0061] A semantic graph is generated from standardized requirements, a supporting graph is built based on the semantic graph, enterprise rules and project configurations are gathered to form a constraint set, and a resource profile, historical metrics and task template library are constructed.

[0062] An improved GraphRAG model is used to perform retrieval and subgraph aggregation between semantic graph and support graph, and to complete aligned reasoning by combining constraint set, outputting fact set, conflict list and missing list;

[0063] An improved Reflexion algorithm is adopted to generate a hierarchical task set, dependency graph and priority list based on the fact set and with reference to the conflict list and missing list. Shadow scheduling and acyclicity verification are performed under the constraint set and resource profile to obtain the execution order table.

[0064] Based on the hierarchical task set, dependency graph, priority list and execution order table, design artifacts, interface artifacts, test artifacts, verification artifacts and acceptance artifacts are generated, and resource plans, milestone plans and critical paths are solved by combining historical metrics and constraint sets;

[0065] Establish a traceability link and bind the version baseline and source index. Track and warn based on resource plans and critical paths. Implement acceptance at the milestone plan stage. When limits are exceeded, implement rearrangement and resource reallocation based on dependency graphs and priority lists.

[0066] In this embodiment, the steps of constructing a multi-source requirement list, unifying the format and deduplicating, establishing a version baseline and source index, and generating standardized requirements specifically include:

[0067] Requirements from work orders, documents, prototypes, interface specifications, and meeting minutes are aggregated to form a multi-source requirement list;

[0068] Field mapping and format correction are performed on the multi-source demand list to obtain items that conform to a unified template, which is a predefined set of fields;

[0069] For entries that conform to a unified template, deduplication is performed, content fingerprints are calculated and similarity comparisons are made, and entries that are determined to be duplicates are merged to obtain a deduplication list. The content fingerprint is a fixed-length summary generated based on the text and structure, which is used for duplicate determination.

[0070] Generate a version baseline on the deduplication list, record the baseline number, generation time and reason for change, and obtain a baseline snapshot;

[0071] Record the source system, submitter, submission time, and original location for each item in the inventory, and create a source index;

[0072] After completing format unification, deduplication, version baseline, and source index, a unique identifier is assigned to each entry, and the normalization requirements are output. The normalization requirements are a set of entries that meet the unified template and are bound to the version baseline and source index.

[0073] This implementation method achieves traceable, auditable, and unambiguous input of requirements by constructing a multi-source requirement list, unifying the template, deduplicating, and establishing version baselines and source indexes, which significantly reduces the cost of subsequent retrieval and comparison.

[0074] In this embodiment, the process of generating a semantic graph from standardized requirements, constructing a supporting graph based on the semantic graph, aggregating enterprise rules and project configurations to form a constraint set, and building a resource profile, historical metrics, and task template library specifically includes:

[0075] The standardized requirements are segmented into words based on dictionary matching and rule segmentation. Subject-verb-object and modification relationships are identified according to dependency relationship rules. Referential resolution is completed by combining the nearest antecedent principle. Entities, attributes and relationships are extracted to generate a semantic graph. The semantic graph is a structured representation with requirement entities as nodes and semantic relationships as edges.

[0076] Based on the semantic graph and existing knowledge entries, the graph is matched and the names are merged. Entity alignment and relationship merging are completed according to the judgment rules of type consistency and relationship compatibility. A support graph is constructed. The support graph is a domain knowledge subgraph generated around the scope of this processing and contains nodes and edges related to the requirements.

[0077] By aggregating enterprise rules and project configurations, type constraints, scope constraints, and timing constraints are transcribed into machine-readable entries to achieve unified standards and form a constraint set. This constraint set is used for subsequent consistency checks and satisfiability judgments, and provides boundary conditions for task generation and scheduling.

[0078] Collect personnel skills, available time periods, and environmental capabilities; calculate available capacity based on qualification verification and time intervals; and generate a resource profile, which is a structured description of execution capabilities and availability.

[0079] Statistical analysis of historical project records is performed to calculate the distribution of project duration, defects, and complexity levels, forming historical metrics. These historical metrics provide baseline data for scale estimation and risk assessment, and are used for project solution and priority correction.

[0080] Organize the parameter placeholders and trigger conditions for functional, interface, test, and verification tasks, establish a retrieval index and keyword mapping, and generate a task template library, which is a set of reusable template entries.

[0081] This implementation method generates semantic graphs and supporting graphs, itemized constraint sets, and forms resource profiles, historical metrics, and task template libraries to establish a structured knowledge base, reduce noise and caliber differences, and improve downstream usability.

[0082] In this embodiment, the improved GraphRAG model is used to perform retrieval and subgraph aggregation between the semantic graph and the support graph, and to complete aligned reasoning by combining the constraint set, outputting a fact set, a conflict list, and a missing list, specifically including:

[0083] An improved GraphRAG model is constructed, consisting of a retrieval and subgraph aggregation module, an alignment and constraint filtering module, a conflict minima and supplementation detection module, and a missing detection and result summarization module.

[0084] It receives semantic graph, support graph, constraint set, source index and version baseline as input, performs unified rules on field names and timestamps, converts inconsistent times and identifiers into a unified standard, and obtains a standardized input set.

[0085] The retrieval and subgraph aggregation module performs dual-channel retrieval based on a standardized input set: the semantic retrieval channel calculates semantic similarity scores, and the keyword retrieval channel calculates keyword hit accuracy scores. In the fusion stage, source credibility scores and time freshness scores are introduced as weighting factors. Candidate evidence sets are formed by filtering according to the weighted results and thresholds. The local neighborhood is expanded with the hit nodes of the candidate evidence set in the supporting graph as the center. Following the rules of type consistency and key adjacency preservation, redundant edges are pruned and non-key nodes are compressed. The candidate subgraph sets are aggregated by sorting according to relevance and timeliness.

[0086] The alignment and constraint filtering module performs name alignment and type verification on the demand entity nodes in the semantic graph and the nodes in the candidate subgraph set. The candidate subgraph set is an ordered set of several subgraphs obtained by aggregation based on retrieval hits and rules in the support graph. The alignment score is calculated based on the relation pattern and adjacency consistency. Entries with alignment scores below the threshold are eliminated to generate an alignment candidate set. Based on the type constraints, range constraints and temporal constraints in the constraint set, a preliminary quick judgment is first performed, followed by a formal satisfiability verification. Unsatisfiable entries are eliminated and conflict reason entries are recorded to form an alignment set and a conflict clue set.

[0087] When the formal satisfiability check fails, the minimum conflict set and supplementary check module extracts the minimum conflict set from the conflict clue set and sends the minimum conflict set back to the retrieval and subgraph aggregation module to trigger targeted supplementary check. By expanding the keyword set, adjusting the time window and expanding the graph neighborhood radius, the module supplements the basis and subgraph, and reuses the alignment and constraint screening process until a corrected alignment set is obtained or a set number of rounds are reached. The minimum conflict set is the set of the fewest constraint entries that cause unsatisfiability under the current alignment, and the corrected alignment set is the set of alignment results updated after targeted supplementary check.

[0088] The missing detection and result summary module performs integrity checks on the modified alignment set based on the list of required fields in the constraint set and marks uncovered items to form a missing list. The list of required fields refers to the list of fields that various requirements items specified by the constraint set must have. The modified alignment set is truncated according to the confidence threshold and deduplication and synonym merging are performed to form a fact set. The conflict cause items are grouped and archived to form a conflict list.

[0089] This implementation improves the accuracy and completeness of the fact set and reduces invalid checks and mismatch rates by using version-aware retrieval, structure-preserving subgraph aggregation, constraint pre-screening, and minimum conflict set supplementation checks in the improved GraphRAG model.

[0090] In this embodiment, the improved Reflexion algorithm is used to generate a hierarchical task set, dependency graph, and priority list based on the fact set and referring to the conflict list and missing list. Shadow scheduling and acyclicity verification are performed under the constraint set and resource profile to obtain the execution order table, specifically including:

[0091] Receive fact sets, conflict lists, missing data lists, constraint sets, and resource profiles;

[0092] Based on the functional items, interface items, quality attributes and time sequence descriptions in the fact set, element matching and granularity determination are performed according to the type constraints, scope constraints and time sequence constraints of the constraint set to generate a draft of the hierarchical task set. The required tasks and verification tasks are supplemented according to the missing list, and the source of the supplementation is marked as "missing list".

[0093] Based on the association relationships of the fact set and the order rules of the constraint set, the pre- and post-relationships, data dependencies and interface dependencies are derived. Duplicate relationships are merged and contradictory relationships are eliminated to obtain a draft dependency graph.

[0094] Shadow scheduling is performed under the constraints of resource profile and constraint set. Concurrency feasibility, time limit satisfaction and resource load are calculated. A dual threshold strategy is adopted. When the resource load exceeds the upper threshold, the relevant tasks are serialized or the concurrency is reduced. When the load is between the upper and lower thresholds, only local order fine-tuning is performed. Resource conflict flags and time limit default flags are output. Restricted tasks and restricted edges are written back to the dependency graph draft.

[0095] Perform loop detection on the dependency graph draft and extract the minimum set of feedback edges to form a loop list. Then, label the positions that are consistent with the conflict list.

[0096] The conflict list, missing list, resource conflict markers, time limit default markers, and loop list are compiled to generate a reflection prompt set. The reflection prompt set is a structured prompt to guide the addition, deletion, and modification operations. It includes conflicting tasks that need to be deleted, missing tasks that need to be added, minimum feedback edges that need to be trimmed, concurrent segments that need to be downgraded, and granular levels that need to be refined.

[0097] Based on the reflection prompts, the initial draft of the hierarchical task set and the draft dependency graph are revised, and deletions, additions, reconnections and granularity adjustments are performed. The task value, risk and blocking degree are calculated based on the constraint set, a priority list is generated, and an execution order table is generated based on the priority list and dependency graph. A threshold is set for the magnitude of the order change. If the threshold is exceeded, the part is rolled back, modified and recalculated.

[0098] Set a convergence threshold group, including acyclicity requirement, resource load not exceeding limit, time limit satisfaction, constraint satisfaction, and clearing the missing list. When any one of them is not met, the results of this round of checks are transformed into a new set of reflection prompts and iterated. When all thresholds are met, output a hierarchical task set, dependency graph, priority list, and execution order table.

[0099] This implementation uses the improved Reflexion algorithm's reflection-revision loop closure, dual-threshold concurrency control, and minimum feedback edge pruning to quickly generate an acyclic and resource-feasible execution order list, reducing the number of reorderings and shortening the convergence time.

[0100] In this embodiment, the step of generating design artifacts, interface artifacts, test artifacts, verification artifacts, and acceptance artifacts based on the hierarchical task set, dependency graph, priority list, and execution order table, and solving for resource plans, milestone plans, and critical paths by combining historical metrics and constraint sets, specifically includes:

[0101] Based on the hierarchical task set, dependency graph, priority list, and execution order table, the inputs, outputs, and completion criteria are extracted item by item to generate design artifacts, interface artifacts, test artifacts, verification artifacts, and acceptance artifacts. The design artifact is a set of items containing scheme descriptions, structural descriptions, and constraint descriptions. The interface artifact is a set of items containing names, directions, fields, verification, and timing requirements. The test artifact is a set of items containing prerequisites, steps, expectations, and data. The verification artifact and the acceptance artifact are sets of items containing indicators and thresholds, respectively, and are bound to task identifiers one by one.

[0102] The production relationship is calculated along the dependency graph. The upstream output is then mapped and type-validated to fill the fields and timing requirements of the interface artifact. The upstream output refers to the layered task set located in the dependency relationship. Figure 1 The task at the starting point of each dependent edge records data items, artifact references, and completion status items in the output field. The order of calls and timeout thresholds are determined according to the execution order table. Test artifacts and acceptance artifacts are generated for each output in descending order of priority. A coverage matrix is ​​constructed, which is a table of coverage relationships from output to artifact entries. Uncovered units are filled in according to the essential item rules of the constraint set.

[0103] By combining historical metrics to estimate the duration of tasks in quantiles, the start and end times and available resources are allocated to tasks according to the time limits and capacity boundaries given by the constraint set. The concurrent load is calculated as the sum of resource usage in the same time period. When the limit is exceeded, a heuristic adjustment is adopted by extending the earliest available time window and exchanging local sequences to obtain the resource plan.

[0104] Under the constraints of resource planning and dependency graphs, the earliest start time is calculated by advancing layer by layer, and the latest start time is calculated by advancing layer by layer to obtain the total float. The task chain with zero total float is determined as the critical path. The delivery node on the critical path and the pass node in the acceptance workpiece are used as anchor points. The milestone plan is generated by node selection and date backward.

[0105] This implementation automatically generates five types of artifacts based on a hierarchical task set, dependency graph, priority list, and execution order table. It also combines historical metrics and constraint sets to solve resource plans, milestones, and critical paths, ensuring that the system is testable, executable, and measurable.

[0106] In this embodiment, the establishment of a traceability link and binding of version baseline and source index, tracking and early warning based on resource plan and critical path, acceptance during milestone plan implementation phases, and reordering and resource reallocation based on dependency graph and priority list when limits are exceeded, specifically include:

[0107] Based on the version baseline and source index, a traceability link is established, and standardized requirements, hierarchical task sets, dependency graphs, priority lists, execution order tables and various artifacts are associated one by one according to task identifiers to form a queryable mapping.

[0108] Based on the resource plan and critical path, progress tracking is performed, the plan completion rate and critical path time difference are calculated, deviation warnings are generated, and the milestone plan is used as the basis for phase acceptance. The pass records of the accepted workpieces are checked and the release is determined.

[0109] When overdue, overloaded, or blocked events occur, the dependency graph and priority list are read, and changes are triggered and rearranged according to priority and order. The execution order table and resource plan are updated using local order adjustment and resource reallocation strategies, and the reasons for the changes and the scope of impact are recorded.

[0110] This implementation establishes a traceability link based on the version baseline and source index, and performs progress monitoring and deviation warning according to the resource plan and critical path. When a limit is exceeded, it performs a local reordering based on the dependency graph and priority list, thereby improving the change response speed.

[0111] Example 1:

[0112] To verify the feasibility of this invention in practice, it was applied to a "Vehicle Domain Controller OTA Platform Upgrade" project of a new energy vehicle company. The project requirements covered market changes, regulatory compliance, quality defects, and maintenance work orders, spanning four domains: cloud scheduling, vehicle gateway, mobile app, and offline maintenance.

[0113] First, multi-source entries from work orders, documents, interface specifications, and meeting minutes are mapped to fields, formatted, and deduplicated using content fingerprints to establish version baselines and source indexes, resulting in traceable standardized requirements. These standardized requirements are then extracted into entities, attributes, and relationships to generate a project semantic graph. This graph is then merged and aligned with the supporting graph constructed from enterprise-level rules and project configurations, resulting in machine-readable type, scope, and temporal constraints. In parallel, team skills, available time periods, and experimental environment capabilities are collected to create resource profiles. Historical project duration distribution and defect rates are statistically analyzed to form historical metrics. Functional, interface, test, and verification templates are compiled and added to the task template library. Using this as input, an improved GraphRAG model performs dual-channel retrieval and subgraph aggregation on the semantic graph and supporting graph. Source credibility and time freshness weights are introduced to complete aligned reasoning, producing a fact set, conflict list, and missing item list. An improved Reflexion algorithm generates hierarchical tasks, dependencies, and priorities on the fact set. Combined with constraints and resource profiles, shadow scheduling and acyclicity checks are performed, outputting an executable sequence list. The system automatically instantiates design, interface, test, verification, and acceptance artifacts based on a sequence list, and solves resource plans, milestones, and critical paths using historical metrics and constraint sets. It binds end-to-end objects with version baselines and source indexes to establish a traceability and early warning mechanism. When limits are exceeded, the system rearranges and reallocates resources according to dependencies and priorities.

[0114] To quantify the effect, the most recent release cycle before application was selected as the baseline and compared with the first five-week cycle after the implementation of this invention.

[0115] Table 1. Comparison of key process indicators before and after implementation of this invention.

[0116]

[0117] Analysis of the data in Table 1 shows that the increase in the number of deduplication and merging entries indicates that multi-source entries were effectively resolved before entering the review process, directly reducing redundant communication costs. The increase in the number of conflict identifications and the significant decrease in the spillover ratio indicate that the alignment inference of the improved GraphRAG model exposed contradictions early on and resolved them through supplementary checks, reducing rework during the development phase. The average number of missing fields per requirement decreased from 1.7 to 0.6, corresponding to the increase in the fact set confidence P50 from 0.72 to 0.86, indicating that the required field constraints and evidence paths made the elements more complete. Shadow scheduling reduced the total project duration from 62 days to 55 days, while reducing peak resource usage from 123% to a near-full but executable 104%, demonstrating the effectiveness of the dual-threshold strategy in limiting concurrency and fine-tuning delay order. Cycle-free verification significantly reduced the number of loops, stabilizing the topology and avoiding later "rework". The coverage matrix coverage increased to 91%, leading to a first-pass yield rate of 82% from 64%, demonstrating that the coordinated generation of design / interface / test / verification / acceptance artifacts enhanced the traceable mapping from requirements to use cases. The milestone on-time rate jumped to 88%, reflecting the value of the critical path solving and early warning rescheduling mechanisms in terms of pace control.

[0118] As can be seen from this embodiment, the present invention, through a closed-loop path of "normalization—semantic graph—graph alignment—self-reflective generation—shadow scheduling—workpiece and plan linkage—traceability and early warning," enables conflicts and omissions to be discovered and corrected in the early stages; allows tasks and dependencies to be generated in the context of constraints and resources and ensured to be feasible through DAG verification; allows workpieces and coverage matrices to move design and testing forward; and allows critical paths and resource plans to drive the pace and quickly reschedule when limits are exceeded. Compared to the baseline cycle, the project improves simultaneously in core indicators such as duration, first-time pass rate, and on-time rate, while keeping peak resources within a controllable range, demonstrating the feasibility and significant beneficial effects of the present invention in complex cross-domain projects.

[0119] 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 automatically decomposing digital R&D requirements based on knowledge reasoning, characterized in that, Includes the following steps: Construct a multi-source requirement list, unify the format and remove duplicates, establish a version baseline and source index, and generate standardized requirements; A semantic graph is generated from standardized requirements, a supporting graph is built based on the semantic graph, enterprise rules and project configurations are gathered to form a constraint set, and a resource profile, historical metrics and task template library are constructed. An improved GraphRAG model is used to perform retrieval and subgraph aggregation between semantic graph and support graph, and to complete aligned reasoning by combining constraint set, outputting fact set, conflict list and missing list; An improved Reflexion algorithm is adopted to generate a hierarchical task set, dependency graph and priority list based on the fact set and with reference to the conflict list and missing list. Shadow scheduling and acyclicity verification are performed under the constraint set and resource profile to obtain the execution order table. Based on the hierarchical task set, dependency graph, priority list and execution order table, design artifacts, interface artifacts, test artifacts, verification artifacts and acceptance artifacts are generated, and resource plans, milestone plans and critical paths are solved by combining historical metrics and constraint sets; Establish a traceability link and bind the version baseline and source index. Track and warn based on resource plans and critical paths. Implement acceptance at the milestone plan stage. When limits are exceeded, implement rearrangement and resource reallocation based on dependency graphs and priority lists.

2. The method for automatically decomposing digital R&D requirements based on knowledge reasoning according to claim 1, characterized in that, The process of constructing a multi-source requirement list, standardizing the format and removing duplicates, establishing a version baseline and source index, and generating standardized requirements specifically includes: Requirements from work orders, documents, prototypes, interface specifications, and meeting minutes are aggregated to form a multi-source requirement list; Perform field mapping and format correction on the multi-source requirement list to obtain items that conform to a unified template; For entries that conform to the unified template, perform deduplication processing, calculate content fingerprints and perform similarity comparison, merge entries that are determined to be duplicates, and obtain a deduplication list; Generate a version baseline on the deduplication list, record the baseline number, generation time and reason for change, and obtain a baseline snapshot; Record the source system, submitter, submission time, and original location for each item in the inventory, and create a source index; After completing format standardization, deduplication, version baseline, and source indexing, a unique identifier is assigned to each entry, and the standardization requirements are output.

3. The method for automatically decomposing digital R&D requirements based on knowledge reasoning according to claim 1, characterized in that, The process involves generating a semantic graph from standardized requirements, constructing a supporting graph based on the semantic graph, aggregating enterprise rules and project configurations to form a constraint set, and building resource profiles, historical metrics, and a task template library. Specifically, this includes: For the standardization requirements, word segmentation is completed based on dictionary matching and rule segmentation. Subject-verb-object and modification relationships are identified according to dependency relationship rules. Referential resolution is completed by combining the nearest antecedent principle. Entities, attributes and relationships are extracted to generate semantic graphs. Based on the semantic graph and existing knowledge entries, the graph is matched and names are merged. Entity alignment and relationship merging are completed according to the judgment rules of type consistency and relationship compatibility to construct the support graph. By aggregating enterprise rules and project configurations, type constraints, scope constraints, and timing constraints are transcribed into machine-readable entries, achieving unified standards and forming a constraint set. Collect personnel skills, available time periods, and environmental capabilities; calculate available capacity based on qualification verification and time intervals; and generate resource profiles. Statistical analysis of historical project records, calculation of project duration distribution, defect distribution, and complexity classification to form historical metrics; Organize the parameter placeholders and trigger conditions for functional, interface, test, and verification tasks, establish a search index and keyword mapping, and generate a task template library.

4. The method for automatically decomposing digital R&D requirements based on knowledge reasoning according to claim 1, characterized in that, The improved GraphRAG model is used to perform retrieval and subgraph aggregation between the semantic graph and the support graph, and to complete aligned reasoning by combining the constraint set, outputting a fact set, a conflict list, and a missing list, specifically including: An improved GraphRAG model is constructed, consisting of a retrieval and subgraph aggregation module, an alignment and constraint filtering module, a conflict minima and supplementation detection module, and a missing detection and result summarization module. It receives semantic graph, support graph, constraint set, source index and version baseline as input, performs unified rules on field names and timestamps, converts inconsistent times and identifiers into a unified standard, and obtains a standardized input set. The retrieval and subgraph aggregation module performs dual-channel retrieval based on a standardized input set: the semantic retrieval channel calculates semantic similarity scores, and the keyword retrieval channel calculates keyword hit accuracy scores. In the fusion stage, source credibility scores and time freshness scores are introduced as weighting factors. Candidate evidence sets are formed by filtering according to the weighted results and thresholds. The local neighborhood is expanded with the hit nodes of the candidate evidence set in the supporting graph as the center. Following the rules of type consistency and key adjacency preservation, redundant edges are pruned and non-key nodes are compressed. The candidate subgraph sets are aggregated by sorting according to relevance and timeliness. The alignment and constraint filtering module performs name alignment and type verification on the requirement entity nodes in the semantic graph and the nodes in the candidate subgraph set. It calculates the alignment score based on the relation schema and adjacency consistency, removes entries with alignment scores below the threshold, and generates an alignment candidate set. Based on the type constraints, range constraints and temporal constraints in the constraint set, it first performs a preliminary quick judgment, then performs a formal satisfiability verification, removes unsatisfiable entries and records the conflict reason entries, forming the alignment set and conflict clue set. When the formal satisfiability check fails, the minimum conflict set and supplementary check module extracts the minimum conflict set from the conflict clue set and sends the minimum conflict set back to the retrieval and subgraph aggregation module to trigger targeted supplementary check. The module supplements the basis and subgraph by expanding the keyword set, adjusting the time window and expanding the graph neighborhood radius, and reusing the alignment and constraint screening process until a corrected alignment set is obtained or a set number of rounds is reached. The missing detection and result summary module performs integrity checks on the modified alignment set based on the list of required fields in the constraint set and marks uncovered items to form a missing list. The list of required fields refers to the list of fields that various requirements items specified by the constraint set must have. The modified alignment set is truncated according to the confidence threshold and deduplication and synonym merging are performed to form a fact set. The conflict cause items are grouped and archived to form a conflict list.

5. The method for automatically decomposing digital R&D requirements based on knowledge reasoning according to claim 1, characterized in that, The improved Reflexion algorithm is employed, which generates a hierarchical task set, dependency graph, and priority list based on a fact set and referencing conflict and missing lists. Shadow scheduling and acyclicity checks are performed under constraint sets and resource profiles to obtain an execution order table, specifically including: Receive fact sets, conflict lists, missing data lists, constraint sets, and resource profiles; Based on the functional items, interface items, quality attributes and time sequence descriptions in the fact set, element matching and granularity determination are performed according to the type constraints, scope constraints and time sequence constraints of the constraint set to generate a draft of the hierarchical task set. The required tasks and verification tasks are supplemented according to the missing list, and the source of the supplementation is marked as "missing list". Based on the association relationships of the fact set and the order rules of the constraint set, the pre- and post-relationships, data dependencies and interface dependencies are derived. Duplicate relationships are merged and contradictory relationships are eliminated to obtain a draft dependency graph. Shadow scheduling is performed under the constraints of resource profile and constraint set. Concurrency feasibility, time limit satisfaction and resource load are calculated. A dual threshold strategy is adopted. When the resource load exceeds the upper threshold, the relevant tasks are serialized or the concurrency is reduced. When the load is between the upper and lower thresholds, only local order fine-tuning is performed. Resource conflict flags and time limit default flags are output. Restricted tasks and restricted edges are written back to the dependency graph draft. Perform loop detection on the dependency graph draft and extract the minimum set of feedback edges to form a loop list. Then, label the positions that are consistent with the conflict list. The conflict list, missing list, resource conflict markers, time limit default markers, and loop list are compiled to generate a reflection prompt set. The reflection prompt set is a structured prompt to guide the addition, deletion, and modification operations. It includes conflicting tasks that need to be deleted, missing tasks that need to be added, minimum feedback edges that need to be trimmed, concurrent segments that need to be downgraded, and granular levels that need to be refined. Based on the reflection prompts, the initial draft of the hierarchical task set and the draft dependency graph are revised, and deletions, additions, reconnections and granularity adjustments are performed. The task value, risk and blocking degree are calculated based on the constraint set, a priority list is generated, and an execution order table is generated based on the priority list and dependency graph. A threshold is set for the magnitude of the order change. If the threshold is exceeded, the part is rolled back, modified and recalculated. Set a convergence threshold group, including acyclicity requirement, resource load not exceeding limit, time limit satisfaction, constraint satisfaction, and clearing the missing list. When any one of them is not met, the results of this round of checks are transformed into a new set of reflection prompts and iterated. When all thresholds are met, output a hierarchical task set, dependency graph, priority list, and execution order table.

6. The method for automatically decomposing digital R&D requirements based on knowledge reasoning according to claim 1, characterized in that, Based on the hierarchical task set, dependency graph, priority list, and execution order table, design artifacts, interface artifacts, test artifacts, verification artifacts, and acceptance artifacts are generated. Resource plans, milestone plans, and critical paths are then solved using historical metrics and constraint sets. Specifically, this includes: Based on the hierarchical task set, dependency graph, priority list and execution order table, the inputs, outputs and completion criteria are extracted item by item to generate design artifacts, interface artifacts, test artifacts, verification artifacts and acceptance artifacts; Calculate the production relationship along the dependency graph, fill the fields and timing requirements of the interface artifact with the upstream output through field mapping and type verification, determine the order of calls and timeout thresholds according to the execution order table, generate test artifacts and acceptance artifacts for each output in order of priority from high to low according to the priority list, construct a coverage matrix, which is a coverage relationship table from output to artifact entries, and fill in the uncovered units according to the essential item rules of the constraint set. By combining historical metrics to estimate the duration of tasks in quantiles, the start and end times and available resources are allocated to tasks according to the time limits and capacity boundaries given by the constraint set. The concurrent load is calculated as the sum of resource usage in the same time period. When the limit is exceeded, a heuristic adjustment is adopted by extending the earliest available time window and exchanging local sequences to obtain the resource plan. Under the constraints of resource planning and dependency graphs, the earliest start time is calculated by advancing layer by layer, and the latest start time is calculated by advancing layer by layer to obtain the total float. The task chain with zero total float is determined as the critical path. The delivery node on the critical path and the pass node in the acceptance workpiece are used as anchor points. The milestone plan is generated by node selection and date backward.

7. The method for automatically decomposing digital R&D requirements based on knowledge reasoning according to claim 1, characterized in that, The process involves establishing a traceability link and binding version baselines and source indexes, tracking and issuing early warnings based on resource plans and critical paths, implementing acceptance tests at milestone stages, and, when limits are exceeded, reordering and resource reallocation based on dependency graphs and priority lists. Specifically, this includes: Based on the version baseline and source index, a traceability link is established, and standardized requirements, hierarchical task sets, dependency graphs, priority lists, execution order tables and various artifacts are associated one by one according to task identifiers to form a queryable mapping. Based on the resource plan and critical path, progress tracking is performed, the plan completion rate and critical path time difference are calculated, deviation warnings are generated, and the milestone plan is used as the basis for phase acceptance. The pass records of the accepted workpieces are checked and the release is determined. When overdue, overloaded, or blocked events occur, the dependency graph and priority list are read, and changes are triggered and rearranged according to priority and order. The execution order table and resource plan are updated using local order adjustment and resource reallocation strategies, and the reasons for the changes and the scope of impact are recorded.

Images