Intelligent data processing method for collection files based on artificial intelligence

Abstract

The invention belongs to the technical field of intelligent document processing, and discloses an intelligent data processing method for collected files based on artificial intelligence, which comprises the following steps: acquiring a multi-source multi-version file to carry out layout rectification and OCR (Optical Character Recognition) to obtain a page fragment object set; using a controlled decoding language model to extract clause records according to preset Schema to form a clause record set; performing cross-version alignment on homonymous or synonymous terms, and constructing a time sequence knowledge graph; compiling the cross-document consistency rule into an executable rule set which can be evaluated on the time sequence knowledge graph by adopting an executable collection constraint language; evaluating the scope of action of each rule to generate conflict candidates; and calculating a minimum hit set to obtain a minimum conflict interpretation set, positioning a root cause term instance, and generating a minimum repair suggestion according to a normalization result of the operator and the node violating the rule. According to the method, the unification of clauses and calibers and the automatic judgment of the latest effective state, the accurate positioning of conflicts and the minimum cost repair are realized.

Description

Technical Field

[0001] This invention belongs to the field of intelligent document processing technology, and in particular, it is an intelligent data processing method for procurement documents based on artificial intelligence. Background Technology

[0002] In business scenarios such as bidding or procurement projects, a massive amount of heterogeneous data is generated, including bidding announcements, bidding documents, procurement requirements, clarification documents, Q&A documents, addenda, correction notices, tender documents and attachments, bid evaluation reports, notices of award, contract texts and contract amendment documents, and acceptance reports. These documents come from diverse sources and are frequently updated. The current industry practice is to obtain text information through layout correction and optical character recognition (OCR) technology, then extract elements using keyword retrieval, regular expression templates, dictionary matching, or simple classifiers, supplemented by manual proofreading, deduplication, and similarity comparison to complete archiving. Cross-document consistency usually relies on item-by-item checking of tables and lists, conflict location depends on experience in searching for prompts such as "correction" and "supplement," and the units, currencies, and dates of clauses are mostly manually converted and recorded. The final results are presented as static reports or explanatory documents, lacking a structured expression with a time-series dimension and reusable constraint expression methods.

[0003] The shortcomings of existing technologies are mainly reflected in the following aspects: it is difficult to perform cross-version alignment of multi-source and multi-version files and reliably determine the "latest valid" status; cross-document consistency is mostly checked manually after the fact, and there is a lack of rule expressions that can be evaluated in the time dimension; the unit, currency and date information in the document clauses are prone to implicit inconsistencies; when information conflicts occur across documents, existing technologies can only present the conflict phenomenon, but cannot trace the root cause of the conflict or provide an executable repair path. At the same time, the evidence points to different page numbers and page coordinates of multi-source and multi-version files, lacking a unified evidence pointer and chain association, making it difficult to locate the source fragment in a timely manner during audit backtracking. Summary of the Invention

[0004] In view of the aforementioned existing problems, the present invention is proposed.

[0005] Therefore, this invention provides an intelligent data processing method for procurement documents based on artificial intelligence to solve the problems in the prior art where it is difficult to align multiple versions of procurement documents across versions and determine the latest valid status, and the inability to automatically calculate cross-document consistency in a unified manner and time sequence dimension.

[0006] To solve the above-mentioned technical problems, the present invention provides the following technical solution:

[0007] This invention provides an intelligent data processing method for procurement documents based on artificial intelligence, comprising the following steps: S1. Obtain multi-source, multi-version files pointing to the same procurement project, perform layout correction and OCR on the multi-source, multi-version files to obtain a set of page fragment objects, and establish a version sequence; S2. Based on the set of page fragment objects, extract the clause records according to the preset schema using a language model with controlled decoding to form a set of clause records; S3. Based on the set of clause records and version sequence, cross-version alignment is performed on clauses with the same name or synonyms to construct a temporal knowledge graph; S4. Use an executable procurement constraint language to compile cross-document consistency rules into an executable rule set that can be evaluated on a temporal knowledge graph; S5. Based on the executable rule set, evaluate the scope of each rule on the time-series knowledge graph and generate conflict candidates. After aggregation, obtain the conflict candidate set. S6. Based on the conflict candidate set, calculate the minimum hit set that restores all conflict candidates to the required state, obtain the minimum conflict explanation set and locate the root cause clause instance, and generate the minimum repair suggestion based on the normalization result of the operator and node of the violated rule. S7. Based on the root cause clause examples and minimum repair recommendations, output an auditable verification result report.

[0008] Furthermore, in S1, the multi-source, multi-version documents include tender notices, tender documents or procurement requirements, clarification documents or Q&A documents and addenda, correction notices, tender documents and tender document attachments, bid evaluation reports, notices of award, contract texts and contract amendment documents, acceptance reports, prequalification documents, bid opening records, technical specifications, and drawings and price lists.

[0009] Furthermore, layout correction and OCR are performed on the multi-source, multi-version files to obtain a set of page fragment objects, and a version sequence is established, including: Perform layout correction on multi-source, multi-version files to generate a geometrically normalized page image while retaining file identifiers and version timestamps; Perform OCR on the geometrically normalized page image to obtain recognition results containing text content and page coordinates, and form page fragment candidates; Construct a collection of page fragment objects based on page fragment candidates, file identifiers, version timestamps, page numbers, and page layout coordinates; A version sequence is established for multi-source, multi-version files based on version timestamps, and the overwrite relationship is recorded.

[0010] Furthermore, S2 specifically refers to: Content segmentation is performed based on a collection of page fragment objects to obtain a collection of text segments that are consistent with the mapping of preset schema fields. Based on a preset schema, a language model prompt for controlled decoding is constructed, and the output fields and output format are limited. The set of text segments and the prompt are combined to form a controlled decoding input. The term record is generated by the controlled decoding language model based on the controlled decoding input, and an evidence pointer to a set of page fragment objects is attached. The terms and conditions records are normalized based on the unit, currency, and date information and then aggregated to form a set of terms and conditions records.

[0011] Furthermore, S3 specifically refers to: Cross-version alignment of clauses with the same name or synonyms is determined based on the set of clause records and the version sequence. Generate a clause instance node for each version based on cross-version alignment; Label the clause instance nodes with overlay edges, revision edges, reference edges, and repeal edges according to the version sequence; Generate covering chains and referencing chains along the covering edges and referencing edges in the order of version sequence, and select the latest valid node set for each clause identifier by combining the markings of the revision edges and repeal edges, and the clause instances that are later in the version sequence and have not been revised or repealed. The clause instance nodes, covering edges, revision edges, referencing edges, repeal edges, covering chains, referencing chains, and the latest valid node set are merged to form a temporal knowledge graph.

[0012] Furthermore, S4 specifically refers to: Using a controlled decoding language model, cross-document consistency rule sources are parsed according to the syntax of an executable procurement constraint language, and a set of rule candidates is generated. By aligning the fields and unifying the terminology of the rule candidate set, the clause record set, and the latest valid node set in the temporal knowledge graph, cross-document consistency rules are formed. In the temporal knowledge graph, determine the scope of each cross-document consistency rule and point it to the latest set of valid nodes; Within the scope, read the normalized results from the set of terms records corresponding to the node, configure the tolerance strategies for units, currencies, and dates, and complete the compilation to obtain an executable rule set.

[0013] Furthermore, the executable rule set includes the MUST_EQUAL operator, IN operator, RANGE operator, MUTEX operator, IMPLIES operator, and EXCEPT_IF operator.

[0014] Furthermore, S5 specifically refers to: Based on the executable rule set, the scope of each rule in the time-series knowledge graph is selected, and each rule is evaluated to obtain the consistency state of each rule. Based on the rules that the consistency state is not satisfied, conflict candidates are generated; All conflict candidates are aggregated to obtain the conflict candidate set.

[0015] Furthermore, S6 specifically refers to: Establish the correspondence between conflict and clause instance nodes based on the conflict candidate set, and calculate the minimum hit set that restores all conflict candidates to the desired state. Determine the minimum conflict interpretation set based on the minimum hit set and locate root cause clause instances on the temporal knowledge graph; Based on the normalized results of the operators and clause instance nodes of the violated rules, a minimum repair suggestion is generated.

[0016] Furthermore, S7 specifically refers to: Based on the root cause clause examples and minimum repair recommendations, evidence pointers are gathered from the set of page fragment objects and an evidence chain is assembled. Generate auditable verification results reports based on the chain of evidence and minimum repair recommendations.

[0017] The beneficial effects of this invention are as follows: The method of this invention compiles cross-document consistency rules into an executable rule set that can be evaluated on a temporal knowledge graph by using an executable procurement constraint language, thereby achieving precise evaluation of the rules in the latest set of valid nodes, which is used to automatically determine consistency and exceptions; by calculating the minimum hit set based on the conflict candidate set, obtaining the minimum conflict explanation set and locating the root cause clause instance, the method generates a minimum repair suggestion to guide value alignment and consistency, and finally resolves conflicts with minimal changes and outputs traceable verification results. Attached Figure Description

[0018] To more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings used in the following description of the embodiments will be briefly introduced. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0019] Figure 1 This is a flowchart of an AI-based intelligent data processing method for procurement documents. Figure 2 Flowchart for layout correction and OCR processing of page fragment object collections and version sequences; Figure 3 A flowchart for controlled decoding and extracting terms records; Figure 4 A flowchart for constructing a time-series knowledge graph. Detailed Implementation

[0020] To make the above-mentioned objects, features and advantages of the present invention more apparent and understandable, the specific embodiments of the present invention will be described in detail below with reference to the accompanying drawings.

[0021] Many specific details are set forth in the following description in order to provide a full understanding of the invention. However, the invention may also be practiced in other ways different from those described herein, and those skilled in the art can make similar extensions without departing from the spirit of the invention. Therefore, the invention is not limited to the specific embodiments disclosed below.

[0022] Secondly, the term "one embodiment" or "embodiment" as used herein refers to a specific feature, structure, or characteristic that may be included in at least one implementation of the present invention. The phrase "in one embodiment" appearing in different places in this specification does not necessarily refer to the same embodiment, nor is it a single or selective embodiment that is mutually exclusive with other embodiments.

[0023] Reference Figures 1-4 This is one embodiment of the present invention, which provides an intelligent data processing method for procurement documents based on artificial intelligence, including the following steps:

[0024] S1. Obtain multi-source, multi-version files pointing to the same procurement project, perform layout correction and OCR on the multi-source, multi-version files to obtain a set of page fragment objects, and establish a version sequence.

[0025] S1.1. Extract bidding announcements from the specified bidding announcement directory and extract the project name, bidding number, purchaser name, administrative division code, and announcement date to generate a master anchor document. Using the project name, bidding number, purchaser name, administrative division code, and announcement date of the master anchor document as search criteria, batch extract all bidding-related documents adjacent to the time window from the government procurement and public resource transaction public page, email inbox archives, and internal shared directories, and record the source paths. Calculate the content fingerprint and layout fingerprint of the batch extracted documents to remove duplicate documents and retain the source path, extraction time, and summary text of each document to form a candidate document set. Extract the project name, bidding number, purchaser name, administrative division code, and document date from each candidate document set and perform homonymy normalization to form aligned field pairs with the corresponding fields of the master anchor document.

[0026] S1.2 Calculate the overall ranking based on the candidate file set and the main anchor document. Select the optimal time-series chain with the minimum path cost by using the cumulative overall ranking and the cumulative date distance ratio as the cost. Sort the files in ascending order by date to generate a multi-source, multi-version file list pointing to the same procurement project.

[0027] Furthermore, the project names in the candidate file set and the main anchor document are cleaned (parentheses and extra spaces are removed), and the number of Levenshtein edit distance steps between the two strings is calculated (replacement, insertion, and deletion are allowed, and the minimum number of steps is counted). The larger of the two string lengths is used as the standardization base, and the number of edit distance steps is divided by the base to obtain a ratio. The ratio minus one is taken as the project name similarity. The purchaser name similarity is calculated using the same method. After removing punctuation and whitespace from the strings, an equality comparison is performed to calculate the consistency of the tender numbers; identical numbers are recorded as 1, and different numbers as 0. The administrative division codes in the candidate document set and the main anchor document are mapped to equal-length bit strings, and then compared bit by bit to obtain the difference ratio, which is then converted into a similarity score. The closer the similarity score is to the maximum value, the closer the similarity, thus obtaining the administrative division similarity. Fixed-length overlapping substring sets are generated for the denoised text of the main anchor document and the denoised text of the candidate documents. The intersection-union ratio (IUU) of the two sets is calculated to obtain the full-text content overlap; the closer the overlap score is to the maximum value, the closer the content. The candidate document dates and the main anchor document announcement dates are converted to days on the same time scale, and the difference between the two is calculated. The difference is then standardized according to a fixed time scale to obtain the date distance ratio; the smaller the date distance ratio, the closer the times. Candidate documents are ranked across six indicators and summarized into a comprehensive ranking. A higher comprehensive ranking indicates that the document is closer to the main anchor document. If rankings are tied, the order of priority is: higher authority of the source path, inclusion of coverage keywords, and earlier capture time. A directed acyclic relationship is established for candidate documents from earliest to latest file date. Starting from the main anchor document, date-increasing paths are enumerated, and the path cost is calculated for each path. The path cost is composed of the cumulative comprehensive ranking of files within the path and the cumulative date distance between adjacent files. Adjacent files are required to have a non-zero overlap of full text content; if this condition is not met, the next best adjacent file is selected. The path with the lowest path cost among all feasible paths is selected as the optimal time-series chain. When optimal time-series chains are tied, paths containing documents with higher authority of the source path are given priority, followed by paths containing more concentrated coverage keywords. If they are still tied, paths with later endpoint dates are selected. The files in the optimal time-series chain are output in ascending order of file date as a multi-source, multi-version file list pointing to the same procurement project.

[0028] S1.3. Correct the layout of multi-source and multi-version files to form a geometrically normalized page image; Specifically, the file identifier and version timestamp of the page image to be processed in the multi-source, multi-version files are read and temporarily stored as metadata; after converting the page image to a grayscale image, denoising and contrast-limited histogram equalization are performed, and a binary image is obtained through adaptive threshold segmentation; edge detection is performed on the binary image, and small breaks are closed and thinned to obtain a set of edges with good continuity; probabilistic Hough line detection is performed on the edge set, and short lines and repeated collinear lines are filtered out, and adjacent lines with similar angles are merged to obtain a set of lines representing the page boundary; multiple sets of corner points are generated by pairwise intersection of the line set, and candidate quadrilaterals are screened out according to the area and aspect ratio of the closed polygons enclosed by the corner points. The quadrilateral with the largest coverage of the text area is selected first and its four vertex coordinates are recorded. If no valid quadrilateral is detected, the process returns to the external contour of the connected component to extract the largest rectangle as the alternative boundary; A one-to-one correspondence is established between the boundary vertices and the four corners of the target rectangle. Homography is estimated and perspective correction is performed on the page image to align the page boundaries into right-angled rectangles. At the same time, excess black borders are cropped while maintaining the aspect ratio. The main direction of the text lines is calculated on the perspective-corrected image. The peak direction can be found by the projection histograms of the horizontal and vertical directions, or the text line direction angle can be located by the frequency domain energy peak. After obtaining the residual rotation angle, the page image is rotated to make the text lines tend to be horizontal. The rotated image undergoes size and resolution unification processing, including scaling the image to a uniform target size, resolution, margins, and content centering. A second cropping of the black borders is then performed to eliminate blank areas caused by rotation, resulting in a unified image. Geometric quality checks are then performed on the unified image, including checks for right angles, page boundary closure, and text line directionality. If any of these checks fails to meet the preset passing criteria, the process reverts to the quadrilateral candidate generation step. Candidates are then selected in descending order of area (and further broken by descending order of perimeter), and the next quadrilateral candidate in the sorted list is chosen. Perspective and rotation corrections are then re-executed until the page passes or is determined to have a full-page rectangle as its boundary for correction. The file identifier and version timestamp are written into the metadata fields of the accompanying record and the image header. At the same time, the parameter summary and quality verification result summary of this perspective correction and rotation correction are recorded to generate a geometrically normalized page image.

[0029] S1.4 Perform OCR on the geometrically normalized page image to obtain the recognition results containing text content and page coordinates and form page fragment candidates; The geometrically normalized page image is subjected to grayscale conversion, denoising, contrast enhancement, and adaptive binarization to obtain a binary image suitable for text region detection. Extreme value stable region detection is then performed on the binary image to generate a set of connected text candidate regions, and the bounding boundary of each candidate region is extracted. Overlapping and nearest-neighbor merging are performed on connected text candidate regions. The principal orientation angle of each candidate region is estimated based on the direction of its long side, and noise regions with extremely small or elongated surfaces are filtered out. Candidate regions are density-clustered according to the criteria of similar principal orientation angles and vertical proximity to obtain a set of text lines. A minimum bounding quadrilateral is fitted to each text line as its boundary. Vertical projection is calculated within each text line, and adjacent projection valleys are used as segmentation points to obtain word sub-blocks. Recognition fragment images are then cropped in the geometrically normalized page image coordinate system. These recognition fragment images are fed into an OCR (Optical Character Recognition) engine, which uses connection-time classification decoding to output character sequences, character-by-character confidence sequences, and character-by-character boundary coordinates. The character-by-character boundary coordinates are mapped back to the page coordinate system of the geometrically normalized page image. Adjacent characters within the same text line are concatenated into line-level text in the order of reading, generating initial fragment entries containing line-level text and page coordinates. For each initial fragment entry, multiple indicators such as directional consistency, recognition confidence aggregation, geometric compactness, language readability, and stroke stability are calculated, and each indicator is judged with fixed passing conditions. Initial fragment entries that meet all passing conditions enter the subsequent merging process, while initial fragment entries that do not meet the passing conditions are directly eliminated. The initial fragment entries are sorted according to the page reading order. Adjacent initial fragment entries with small spacing within the same text line are merged to generate page fragment candidates containing text content, page coordinates, and confidence scores. The page fragment candidates are then supplemented with file identifiers, version timestamps, and page numbers.

[0030] S1.5. Based on page fragment candidates, file identifiers, version timestamps, page numbers, and page layout coordinates, construct a set of page fragment objects; Page fragment candidates, along with their corresponding file identifiers, version timestamps, and page numbers, are grouped by page number and processed within the same page. Within the same page, page fragment candidates are standardized in character encoding, line breaks, and whitespace formatting, and their page coordinates are unified to the geometrically normalized coordinate system of the page image. A grid index is created within the same page based on the coordinates of the top-left corner, establishing a list of adjacent candidate pairs to provide a retrieval entry point for subsequent merging and deduplication. Adjacent candidate pairs are subjected to text deduplication; when the text content is completely identical and the page coordinates highly overlap, only the candidate with the newer source time is retained, forming a deduplicated candidate set. The candidate set after deduplication is sorted according to the reading order based on the criteria of consistent text direction and proximity to the baseline, resulting in an inline sequence. Within the inline sequence, inline segments are merged based on adjacent spacing and alignment to generate line-level segments. After merging, the outer boundaries of the text content and page coordinates are updated. Line-level segments are then merged into paragraphs based on the line spacing, starting position alignment, and indentation of adjacent lines, generating paragraph-level segments. After merging, the outer boundaries of the paragraphs are updated. Identify the row and column alignment relationships within a table area, merge row-level segments with aligned boundaries and continuous content within the same row or column to generate table cell-level segments, and record the row and column positioning information of the cells after merging; Write a file identifier, version timestamp, and page number for each page fragment object, and also write the fragment text, the outer boundary of the page coordinates, the reading order of the text within the page, and the merging source record; Perform consistency checks on page fragment objects, including whether the page coordinates fall within the page range, whether the outer boundary is closed, whether the text is empty, and whether the merging source is traceable. Objects that fail the checks are removed or rolled back to the previous merging stage for regeneration. The page fragment objects that pass the consistency check are sorted by page number and reading order to form a list of page fragment objects for this page. The list of page fragment objects for all pages is then summarized to generate a set of page fragment objects.

[0031] S1.6. Establish a version sequence for multi-source, multi-version files based on version timestamps and record the overwrite relationship; The version timestamps are parsed to a unified time scale and common format differences or missing fields are corrected. Files that cannot be parsed are marked as pending review and temporarily placed at the end of the sequence. The initial time series is formed by sorting the version timestamps from earliest to latest. When multiple files appear at the same time point, they are scattered according to the fixed authoritative order of the source path. The file category is determined based on a fixed set of keywords in the first line of the title, the source column, and the first paragraph of the body. Other determination clues are recorded in the object for later use. The files are traversed one by one in the time series, and the normalized fields of project name, tender number, purchaser name, administrative division code and document date are extracted. First, a reference index is established with the earlier files. Priority is given to connecting objects with the same tender number and high similarity of project name. Next, objects with high similarity of project name and high similarity of purchaser name are connected. If none of these conditions are met, only time adjacency is established. The text is scanned to identify coverage prompts, and the coverage type and covered objects are determined by combining the document category and citation index: corrections and modifications are identified as change coverage, supplements are identified as supplementary coverage, repeals are identified as invalid coverage, replacements are identified as replacement coverage, and continued validity is identified as continuation coverage; when the covered object can be located at the clause number or paragraph title, the coverage scope is recorded as clause level, and when it cannot be located, the coverage scope is recorded as full text level, and the page number and position of the sentence containing the coverage prompt are extracted as the evidence extraction position; For each file, a version node is created and the file identifier, version timestamp, source path, file category, and the count of incoming and outgoing edges of the overwrite relationship are written. The version nodes are concatenated into a version sequence in chronological order and the predecessor and successor identifiers are recorded in the node. Perform consistency checks on the version sequence. When an overlay loop is found, retain the earlier starting point and remove the later back pointer. When multiple overlay conflicts of the same type are found, retain the source path with higher authority and record the conflict summary. When a deprecated overlay is found to continue, the invalid overlay shall be used and subsequent continuations shall be removed. Output the version sequence and overlay relationship record sorted by time, and retain the file identifier and version timestamp in each version node.

[0032] S2. Based on the set of page fragment objects, extract the clause records according to the preset schema using the language model of controlled decoding to form a set of clause records.

[0033] S2.1. Segment the content based on the set of page fragment objects to obtain a set of text segments that are consistent with the preset schema field mapping; Specifically, text normalization is performed on the collection of page fragment objects. The normalization includes unifying character encoding, unifying full-width and half-width characters, unifying punctuation, merging redundant whitespace, and unifying line break expressions. Generate a field anchor terminology from a preset schema. The field anchor terminology includes the preset schema field names and enumerable aliases, common title formats and colon-based formats, and generates a deterministic matching order and priority for each terminology entry. Perform field anchor matching one by one in the collection of page fragment objects. When a match is found, record the anchor position, the page fragment object identifier occupied by the anchor, and the anchor level type. The level type is determined based on three conditions: whether it is an independent row, whether it contains a colon, and whether it is a table column header. Starting from the anchor point, scan the set of page fragment objects from front to back. Stop when a new anchor point of the same type as the current level is encountered or when the end of the page is encountered. Concatenate the continuous page fragment objects between the starting point and the stopping position into candidate segment text in reading order, and generate a sequence of evidence coordinates for the candidate segments. For page fragment objects belonging to the table area, column header recognition is first performed. The column header recognition is based on the correspondence between the phrases in the first row or the prominently bolded row of the table and the field anchor word list. After the column header is mapped to the field in the preset schema, the text of the cells in the same column is merged by row to generate candidate segment text, and the row and column positioning and evidence coordinate sequence of the candidate segment are recorded. Boundary clipping is performed on the candidate segment text. The clipping rules are to remove repeated anchor phrases at the start and end positions, unify inline connectors and meaningless delimiters, and retain structural markers within the segment (such as clause numbers and subheadings). After clipping, a draft mapping of segment text and corresponding fields is obtained. When multiple candidate segment texts appear in the same field, conflict resolution is performed in the following deterministic order: select the candidate segment text containing overriding prompts such as "correct to", "modify to", or "this is the standard"; if no overriding prompts are found, select the candidate segment text closest to the field anchor; if there are still ties, select the one located on the later page or in the later reading order. Each final determined segment of text, along with its corresponding fields, file identifier, version timestamp, page number, evidence coordinate sequence, segment identifier, and reading order, is written into the output to form a set of text segments.

[0034] S2.2 Construct a language model prompt for controlled decoding based on a preset schema and limit the output fields and output format, and combine the text segment set with the prompt to form a controlled decoding input.

[0035] Generate a field list from the preset schema. The field list lists the field name, value type, whether it is required, the number of times it can appear, the value constraint vocabulary or format expression, and whether evidence pointers are required for each field, while ensuring that the field names are completely consistent with the preset schema. The output format constraints are defined based on the field list. The constraints include the top-level structure of the clause record set, the fixed key name order of the clause records, the requirement that required key names always appear and can be empty, the requirement that key names not in the field list must not appear, the nesting level is limited to the level allowed in the field list, and the evidence pointer must include the page number, page coordinates and the identifier of the source page fragment object. For each type of value, a field value template is generated. For numeric values, only Arabic numerals and decimal points are retained and unit symbols are removed. For date values, the format is unified as year, month and day with hyphens. For range values, two key names are split: start and end. For enumeration values, the entries are limited to the dictionary. For amount values, the currency and the value are separated and placed into the corresponding key names. For unit values, the values ​​are selected from a unified dictionary and placed into the unit key name. The prompt skeleton includes the following: role constraint: extraction tool; task objective: mapping a collection of text segments into structured text; requirements for field mapping rules and field value templates; evidence rules requiring each field to be accompanied by a page number and page coordinates; conflict handling rules stipulating that when the same field appears in multiple places, the segment containing the covering prompt word should be selected first, otherwise the segment with the later page number and later reading order should be selected; and outputting content not in the field list is prohibited. Arrange the text segment collection in ascending order of page number and reading order, and add each segment to the end of the prompt. Add a label before each segment to explain the field candidate information, page number and page coordinates, and segment identifier. Place the text content on the line after the label. If the segment is too long, prioritize retaining segments that hit the field anchor or contain the covering prompt words according to a fixed strategy. The generated structure verification instruction requires the controlled decoding language model to internally check whether the required key names are complete, whether all key names come from the field list, and whether the values ​​conform to the field value template before generating structured text. If any discrepancies are found, the model should automatically correct them within a single generation and provide structured text. Explanatory text is not allowed to be output. Set controlled decoding constraints, adopt deterministic decoding, disable random sampling, limit the output to include only structured text and prohibit free text supplementation, and when the structure check fails, retry within a single call with a fixed number of retries and take the last compliant output as the standard. The context header information, field list, output format constraints, field value templates, prompt skeleton, and sorted text segment set are concatenated in a fixed order to form a complete prompt text, thus forming a controlled decoding input.

[0036] It should also be noted that the controlled decoding language model refers to a general autoregressive language model that is constrained by a preset schema during the generation stage and only outputs structured results that meet the field list and output format constraints. It is obtained by solidifying the preset schema-related constraints in the prompts and setting controlled decoding configurations such as deterministic decoding on the general language model, without the need for additional training.

[0037] S2.3. Based on the controlled decoding input, the language model of the controlled decoding generates a clause record and attaches an evidence pointer to the set of page fragment objects.

[0038] It receives controlled decoding input, text segment set index, and page fragment object set index, directly feeds the controlled decoding input into the controlled decoding language model, and sets deterministic decoding and fixed output structure, allowing only the generation of structured text; The structured text generated by the controlled decoding language model is obtained in one go. The structured text is parsed into a candidate set of clause records. The key name, required fields and hierarchy are checked against the preset schema to see if they are compliant. If they are not compliant, the format is corrected according to the field list and output format constraints in a single call and then parsed into a candidate set of clause records again. Extract the clause identifier, constraint type, and value or range for each clause in the candidate clause record set, and read the segment label information from the controlled decoding input; if the candidate clause record contains a source segment identifier, locate the corresponding segment in the text segment set index using the segment identifier, and find the corresponding page segment object identifier, page number, and page coordinates in the page segment object set index, generate an evidence pointer, and attach it to the candidate clause record; When a candidate clause record does not carry a source segment identifier, a two-stage positioning process is performed in the text segment set: First, precise substring matching is performed, prioritizing the search for segments in the segment text that are completely consistent with the clause record value or range; if no match is found, a normalized approximate matching is performed, with normalization including consistent capitalization, consistent full-width and half-width characters, removal of extra spaces, and consistent punctuation; then, inclusion matching is performed in the segment text, and if a match is found, the page segment object identifier, page number, and page coordinates are retrieved from the page segment object set based on the matched segment, an evidence pointer is generated and attached to the candidate clause record; When the same clause is located in multiple sections, the evidence pointers are selected according to the certainty priority. The priority order is: the section containing the covering prompt word takes precedence over the section without the covering prompt word; the section with the later page number takes precedence over the section with the earlier page number; the section with the later reading order takes precedence over the section with the earlier reading order; finally, the first evidence pointer is retained and the remaining evidence pointers are recorded as supplementary pointers. For candidate clause records with attached evidence pointers, a structural consistency check is performed. The check includes whether all key names come from the preset schema, whether required keys exist, whether the scope class has both start and end, whether the evidence pointer contains file identifier, version timestamp, page number and page coordinates, and page fragment object identifier. Candidate clause records that pass the check are converted into clause records.

[0039] S2.4. Based on the information of unit, currency and date, normalize the clause records and summarize them to form a clause record set.

[0040] The system receives candidate clause records, clause identifiers, constraint types, values ​​or ranges, and evidence pointers. It also loads a unit of measurement mapping table, a currency mapping table, a date expression pattern set, and an exchange rate table. Raw values ​​are first minimally normalized, unifying character encoding, full-width and half-width characters, punctuation, and whitespace, and converting Chinese numerals and quantifiers to continuous numbers. The target unit is determined in the unit of measurement mapping table, and numerical conversion is performed. The start and end points of intervals are processed separately, and endpoint inclusion relationships are clarified. If a unit is missing, the most recent unit in the same field is referenced, and its source is recorded. The currency code is determined in the currency mapping table, and if necessary, converted to a unified currency from the exchange rate table based on the version timestamp, while retaining the original currency. Currency and original amount, including range or tiered rules, are normalized and stored sequentially; based on the date expression pattern set, complete dates, months, years, relative dates and periods are converted into a unified format or absolute period and the resolution and anchor source are marked; after completion, structural consistency check and conflict folding are performed, checking the integrity of field names, required fields, range endpoints and evidence pointers. Those that fail are marked for review and removed from the summary, and those that pass are sorted by clause identifier and reading order, prioritizing the retention of records containing overriding prompts, and then selecting by page number and reading order. Finally, a set of clause records containing the original string and normalized results is output while keeping the evidence pointer unchanged.

[0041] S3. Based on the set of clause records and the version sequence, cross-version alignment is performed on clauses with the same name or synonyms to construct a temporal knowledge graph.

[0042] S3.1 Determine the cross-version alignment relationship of clauses with the same name or synonyms based on the set of clause records and the version sequence.

[0043] Furthermore, a field mapping list is generated based on the preset schema field names, field anchor thesaurus, and synonym list, and synonym merging is performed on the clause identifiers. Within each version node, clause records are grouped according to the field mapping list to form a clause grouping list within the version. Adjacent nodes along the version sequence are compared pairwise, and title phrase matching, paragraph number matching, and evidence pointer page number proximity matching are performed on groups of fields with the same name or synonyms, and the source of the matching score is recorded. When multiple candidate matches are found, they are selected according to deterministic priority, with the following priority order: clause records containing coverage prompts are given priority, followed by later page numbers, and then later reading order.

[0044] To establish cross-version alignment relationships for identified pairs, pointers to preceding and subsequent versions are written, along with a summary of the evidence locations used for matching. Placeholder entries are created for missing fields, indicating the missing type as either absent or obsolete, and maintaining link continuity with adjacent aligned record entries. A consistency check is performed on the entire sequence to resolve one-to-many or many-to-one contradictions, retaining the highest priority pairs and generating conflict summaries for auditing. A list of cross-version alignment relationships and an alignment graph index are output.

[0045] S3.2 Generate a clause instance node for each version based on the cross-version alignment relationship; Specifically, based on cross-version alignment, each field's clause records in each version are bound to the corresponding version node, generating clause instance nodes. The node contains the clause identifier, version timestamp, file identifier, file category, and reading order. The normalized result is fully incorporated into the node attributes, including numerical values ​​or ranges, units, currencies and amounts, dates or periods and resolutions, and the semantics of including or excluding interval endpoints. Based on the evidence pointer, the source page number, page coordinates, page fragment object identifier, and evidence text summary are backfilled into the page fragment object set. When multiple candidates for the same version appear, the primary instance is determined in a fixed order: priority is given to those containing coverage prompts, followed by page numbers, and then by reading order. The remaining instances are recorded as backup instances in the node. When a version is missing or obsolete, a placeholder instance is generated and the missing type and reason for failure are indicated. A unique key (composed of the clause identifier and version timestamp) is calculated for all instances and written to the preceding and following pointers to maintain link continuity. Finally, clause instance nodes arranged in version order are output.

[0046] S3.3. Mark the overlay edge, revision edge, reference edge and repeal edge between clause instance nodes according to the version sequence; Specifically, based on the version sequence, the clause instance nodes with the same clause identifier are traversed from earliest to latest. For each subsequent node, the coverage prompt words and coverage relationship records in the source file are read, and the affected preceding node is located: when "corrected to" or "modified to" appears, a revision edge is marked between the preceding node and the current node; when "supplemented as follows," "subject to," or "replaces" appear, a coverage edge is marked, where the replacement semantics also mark the replaced node with a repeal edge; when the text explicitly cites the clause number or document number of another document, the target node is located in the version sequence according to the number or document number and a citation edge is marked; when "repealed" or "invalidated" appears, the specified node is marked with a repeal edge from the current node back to the index.

[0047] Furthermore, for each edge, record the evidence page number, page coordinates, hit phrase, coverage (clause level or full text level), and the effective version timestamp range; when multiple types of edges hit the same pair of nodes at the same time, retain a single label in the order of repeal over revision, revision over coverage, and coverage over citation, and treat the rest as notes.

[0048] S3.4 Generate covering chains and referencing chains along the covering edges and referencing edges in the order of version sequence, and select the latest valid node set for each clause identifier by combining the markings of the revision edges and repeal edges, and the clause instances that are later in the version sequence and have not been revised or repealed.

[0049] Furthermore, starting from the earliest node, the process proceeds along the coverage edge first, followed by the reference edge, generating coverage chains and reference chains. Within each chain, the node order, the page number from which the edge originates, and the range description are recorded. When parallel successors appear for the same node, a path is selected and solidified as the main path, prioritizing those containing coverage prompts, those with later page numbers, and those with later reading order. Nodes pointed to by abolished edges and all their successors are removed, and jump relationships are added to the chain. Nodes affected by revised edges are marked as invalid, and the revised nodes are added to the end of the coverage chain. If no coverage or reference is available, the node is treated as a single-node coverage chain. On each cleaned chain, the first unrevised and unabolished node is searched backwards from the end, and this is recorded as the latest valid node for that clause. Finally, all the latest valid nodes for all clauses are aggregated into a set of latest valid nodes.

[0050] S3.5. Merge the clause instance nodes, covering edges, revision edges, referencing edges, repealing edges, covering chains, referencing chains, and the latest valid node set to form a temporal knowledge graph.

[0051] Furthermore, the graph structure is initialized and the namespace and field dictionary are fixed; clause instance nodes are written one by one according to the version sequence, with node attributes including clause identifier, version timestamp, file identifier, normalization result, evidence pointer, and reading order, while generating unique keys and fixing the preceding and following pointers; directed edges are batch-created based on the records of coverage edges, revision edges, reference edges, and repeal edges, with edge attributes including evidence page number, page coordinates, and coverage range, and single labels are retained for multi-label conflicts in the order of repeal over revision, revision over coverage, and coverage over reference; coverage chains and reference chains are converted into searchable link indexes and chain-level order and chain length summary are written to the first and last nodes of the chain; the latest valid node set is labeled with valid labels and effective ranges and subordinate associations are established; multi-dimensional indexes are generated according to clause identifier, version timestamp, and file category, and finally persistently stored as a time-series knowledge graph.

[0052] S4. Use an executable procurement constraint language to compile cross-document consistency rules into an executable rule set that can be evaluated on a time-series knowledge graph.

[0053] S4.1 Utilize the controlled decoding language model to parse cross-document consistency rules based on the syntax of the executable procurement constraint language and generate a set of rule candidates.

[0054] The system receives cross-document consistency rules and merges them into parsable text according to language and page number order. Based on the executable procurement constraint language, it prepares a grammar summary, field dictionary, operator list, and fixed output template. The source text is segmented into candidate rule segments according to paragraph title, clause number, and sentence anchor. For each candidate rule segment, semantic tags such as mandatory, prohibited, contain, scope, mutual exclusion, implication, exception, and reference, along with their context windows, are extracted and written to the end of the prompt along with the source file identifier, version timestamp, page number, and layout coordinates. The complete prompt is sent to the controlled decoding language model, which enables deterministic decoding and fixed key name hierarchy, prohibits free text supplementation, and outputs structured rule units from the controlled decoding language model. The content includes rule name, target, scope clue, operator, comparison object, exception condition, and evidence pointer. The output is grammatically checked one by one to verify whether the key name is complete, whether the operator is in the list, whether the field exists in the dictionary, and whether the value type and range match. Unqualified entries are self-corrected once according to the template in a single call. The rule units that pass the verification are aggregated into a rule candidate set.

[0055] S4.2 Align the fields and unify the terminology of the rule candidate set, the clause record set, and the latest valid node set in the time-series knowledge graph to form cross-document consistency rules.

[0056] Based on the rule candidate set, clause record set, and the latest valid node set in the time-series knowledge graph, a standard field mapping table is established using a pre-defined schema field list and a thesaurus. Each rule candidate is traversed, replacing the field names in the rule item with standard field names, and unifying the unit, currency, and date caliber using the normalized results from the clause record set. According to the rule item's objective and field anchors, the corresponding clause instance node set is parsed from the latest valid node set, and evidence pointers are backfilled. When a rule item involves multiple fields, each field is checked for available values ​​on the corresponding node; if missing, a missing marker is recorded, and adjacent preceding nodes are located as alternative value sources. Rule candidates with completely consistent sources, objectives, operators, and calibers are deduplicated and merged, retaining sources with later version timestamps and summarizing evidence positions. Finally, cross-document consistency rules are generated, containing rule identifiers, standard field names, value calibers, objective node set, applicable scope, source file identifier, version timestamp, and evidence pointers.

[0057] S4.3 Determine the scope of each cross-document consistency rule in the temporal knowledge graph and point it to the latest set of valid nodes.

[0058] The process involves analyzing the target field, comparison object, target, scope, and exception conditions for each cross-document consistency rule; locating the set of candidate clause instance nodes within the temporal knowledge graph based on the target field, and extending this set along the coverage and reference chains to all reachable nodes; defining the effective scope by intersecting the latest set of valid nodes with the candidates, and removing revised or repealed nodes based on revision and repeal edges; performing filtering based on the scope, including document category, clause number range, page range, and version time window; removing clause instance nodes that meet the exception conditions from the effective scope; generating a scope for each cross-document consistency rule, recording the pointed-to clause instance node, source document identifier, version timestamp, and evidence pointer; and performing a backtracking along the reference chain to re-definite the previous valid version when the effective scope is empty and the cross-document consistency rule contains a reference field.

[0059] S4.4. Read the normalized results from the set of clause records corresponding to the node within the scope, configure the tolerance strategies for unit, currency and date, and complete the compilation to obtain an executable rule set.

[0060] Within the scope, the normalized results of the clause record set are located node by node, reading the numerical value or range, unit, currency, date or period, resolution, and endpoint meaning. Based on the read results, the current rule is configured with unit tolerance (small deviation and rounding strategy after unifying to the target unit), currency tolerance (precision digits and small difference window after unifying the currency), and date tolerance (determining the judgment criteria and time window for equality and inclusion according to daily, monthly, and other resolutions). The comparison objects, target, and tolerance items of the rule are assembled into an executable statement. The executable statement is statically validated to check whether the field names, value criteria, tolerance items, and scope are complete and consistent. If it fails, the reason is recorded and it is rolled back to the scope index for correction. The statements that pass the validation are summarized to generate an executable rule set. The executable rule set includes the MUST_EQUAL operator, IN operator, RANGE operator, MUTEX operator, IMPLIES operator, and EXCEPT_IF operator.

[0061] S5. Based on the executable rule set, evaluate the scope of each rule on the time-series knowledge graph and generate conflict candidates. After aggregation, obtain the conflict candidate set.

[0062] S5.1. Select the scope of each rule in the temporal knowledge graph based on the executable rule set, and evaluate each rule to obtain the consistency state of each rule.

[0063] In the temporal knowledge graph, locate the intersection of the rule's scope and the corresponding latest valid node set, and remove revised or deprecated nodes; evaluate each rule by operator: MUST_EQUAL: For values ​​that need to be equal within the scope, the unit and currency are unified and compared after being aligned according to the date resolution; if the difference does not exceed the unit tolerance and currency tolerance and the dates are equal or within the date tolerance window, it is considered satisfied; otherwise, it is considered unsatisfactory. At the same time, the direction of the difference and the source of the difference are recorded. IN: Maps the target value to standard terms based on field synonyms and enumerated aliases, and searches for them in the allowed set; a hit is recorded as satisfied, and a miss is recorded as not satisfied, and a summary of the missed terms and allowed set is recorded; RANGE: Converts a number or date into a range or scalar and performs semantic comparison based on endpoints; values ​​within the range or satisfying the inclusion relationship are marked as satisfied, values ​​below the lower limit or above the upper limit are marked as not satisfied, and records the out-of-bounds endpoints and deviation amounts; MUTEX: Clusters based on normalized values ​​within the scope, detects whether disallowed coexistence occurs within the same mutually exclusive group; if no coexistence occurs, it is marked as satisfied; if coexistence occurs, it is marked as unsatisfied, and a list of conflicting members is compiled. IMPLIES: First, determine the antecedent; if the antecedent is satisfied, then evaluate the consequent. If the consequent is satisfied, mark it as satisfied; if the consequent is not satisfied, mark it as not satisfied. If the antecedent is not satisfied, mark it as satisfied (empty true) and retain the value of the antecedent for tracing. EXCEPT_IF: Evaluate the exception conditions after the above operator determination; if the exception is met, change "not satisfied" to "explainable inconsistency" and mark the exception basis and evidence location; if the exception is not met, maintain the original conclusion.

[0064] For example, if the amount consistency requirement is MUST_EQUAL, and the difference between the amounts in two files falls within the currency tolerance and the date is within the allowable window after the amounts are unified to the same currency, it is considered satisfied; if the difference exceeds the window but there is an exception condition of "take this as the standard" and it is met, it is considered an interpretable inconsistency.

[0065] Each judgment is recorded in the temporary results table, including the conclusion, value criteria, tolerance details, evidence pointers, and link fragments.

[0066] S5.2. Generate conflict candidates based on the rules that the consistency state is not satisfied.

[0067] Records with a conclusion of "not satisfied" are filtered from the temporary results table, and conflict candidates are generated according to the rules and scope. Conflict candidates include operator type, violated field or field pair, list of involved clause instance nodes, corresponding coverage chain and reference chain fragments, normalized values ​​listed in a table, tolerance caliber, difference direction or out-of-bounds end, evidence pointer and mismatch description. If it is a cross-document constraint, the nodes and values ​​of each source file are placed side by side in the same candidate. If the same record is rewritten as "explainable inconsistency" by EXCEPT_IF, the exception hit and exception basis are marked in the candidate to facilitate the subsequent hit set calculation to identify exemptable impacts.

[0068] S5.3. Aggregate all conflict candidates to obtain a conflict candidate set.

[0069] All conflict candidates are grouped using rule identifier, operator type, clause identifier, field name, and version time window as keys; multiple inconsistencies caused by the same reason are merged into a single representative item, and the remaining evidence locations are incorporated into the evidence list of the representative item; when the same pair of sources appears repeatedly in multiple places, the representative item is determined according to the priority of inclusion coverage prompt words, page number, and reading order; for each candidate, the scope of impact label (clause level or full text level) and the disposal priority label (correction priority, replacement priority, etc.) are calculated, and the audit information (source document identifier, version timestamp, and evidence summary) is supplemented; the set of conflict candidates is output and sorted by group index and priority.

[0070] S6. Based on the conflict candidate set, calculate the minimum hit set that restores all conflict candidates to the required state, obtain the minimum conflict explanation set and locate the root cause clause instance, and generate the minimum repair suggestion based on the normalization result of the operator and node of the violated rule.

[0071] S6.1 Establish the correspondence between conflict and clause instance nodes based on the conflict candidate set, and calculate the minimum hit set that restores all conflict candidates to the desired state.

[0072] A correspondence is established with conflict candidates on one side and changeable objects on the other side. Changeable objects are limited to clause instance nodes and field pairs within the scope whose judgment can be changed by a single atomic modification. The type of atomic modification is determined by the operator, such as value alignment, unit alignment, currency unification, date endpoint alignment, removal of an item from a mutual exclusion group, completion of consequents or withdrawal of antecedents for implied terms, and completion of triggering conditions for exceptions. The conflict candidate number that can be restored to be satisfied by each changeable object is registered in the correspondence, forming a mapping from changeable objects to conflict candidates.

[0073] A deterministic, progressively deeper backtracking search is used to find the minimum hit set. Specifically, the expansion order is determined by sorting the number of conflict candidates covered by the changeable objects from high to low. Then, the order of objects with the same coverage is determined by fixed rules such as priority of containing coverage hint words, priority of later version timestamps, and priority of later reading order. Starting from the object with the largest number of hits, the upper limit of the number of hits is increased, and backtracking selection is performed. When a coverage subset is completely covered by the selected objects, it is pruned immediately. When there are remaining conflict candidates that can no longer be covered, it is backtracked. The solution that first finds a solution that covers all conflict candidates is the minimum hit set.

[0074] For example, when multiple documents have inconsistent amounts and mutually exclusive options overlap, the objects that can be changed are the alignment of amount field values ​​and the cancellation of mutually exclusive clauses. Each of the two types of objects covers several conflict candidates. The backtracking search first tries to cover the amount alignment object with a larger number of conflicts. If there are still remaining conflicts, the mutually exclusive cancellation object is added until all are covered.

[0075] S6.2 Determine the minimum conflict interpretation set based on the minimum hit set and locate the root cause clause instance on the temporal knowledge graph.

[0076] Furthermore, based on the minimum hit set, all conflict candidates covered by the hit mutable object are collected, and inconsistencies that can be directly explained by exception conditions are eliminated. The remaining set is used as the candidate interpretation set. In the candidate interpretation set, conflict candidates that have a subordinate relationship with the same mutable object are checked in turn. Multiple records that are eliminated simultaneously by the same atomic modification are folded into an interpretation unit. The interpretation unit includes the rule identifier, operator type, field name, mutable object identifier, and evidence pointer. The minimum conflict interpretation set is obtained at the granularity of the interpretation unit. The unique clause instance node is located in the temporal knowledge graph based on the mutable object. The source node that caused the current value to enter the latest valid state is traced back by combining the coverage chain and the reference chain. If the source node is within the scope of the correction notice or replacement, the source node is recorded as the root cause clause instance. Otherwise, the current clause instance node is recorded as the root cause clause instance. For each root cause clause instance, the file identifier, version timestamp, file category, normalization result, and evidence location are recorded and a one-to-one association is established with the corresponding interpretation unit. The minimum conflict interpretation set and the root cause clause instance index are output.

[0077] S6.3. Based on the normalized results of the operator and clause instance nodes of the violated rules, generate a minimum repair suggestion.

[0078] Specifically, the minimum conflict explanation set and root cause clause instance index are read one by one. Deterministic repair action templates are formulated according to operator type, and normalized results and evidence pointers are filled in: For equality constraints, suggestions are given to align to the reference node value, with the latest valid node containing the overriding prompt word and having a later version timestamp being the preferred reference node; for set inclusion constraints, suggestions are given to map the current value to a standard term allowed within the set or to replace it with the entry in the set that best matches the evidence; for range constraints, suggestions are given to move the value to the nearest boundary or adjust the endpoint caliber to achieve inclusion, and the semantics of endpoint inclusion or non-inclusion are clearly defined; for mutual exclusion constraints, suggestions are given... Suggestions include revoking lower-priority options in conflict groups or retaining the latest valid option with coverage hints; for implicit constraints, suggestions include completing the consequent field or withdrawing the antecedent expression, prioritizing the action that satisfies the smaller scope; for exceptional conditions, suggestions include completing the exception triggering conditions or explicitly defining the exception clause in the new version; each fix suggestion includes the source file identifier, version timestamp, page number, and layout coordinates, and provides an affected clause scope label (clause level or full-text level) and the suggestion's landing point (end of the coverage chain or target of the citation chain); the group of all fix actions that can simultaneously cover the corresponding objects of the smallest hit set is taken as the smallest fix suggestion.

[0079] S7. Based on the root cause clause examples and minimum repair recommendations, output an auditable verification result report.

[0080] S7.1. Based on the root cause clause examples and minimum repair recommendations, gather evidence pointers from the set of page fragment objects and assemble the evidence chain.

[0081] Furthermore, the recorded evidence pointers are read from the root cause clause instance to generate the first batch of evidence entries. The coverage chain and citation chain are traced back from earliest to latest to the starting node affecting the value of the root cause clause instance. At each node, the evidence pointers and coverage prompts for the same fields are extracted, and the corresponding original text excerpts, normalized definitions, and change statements are merged into new evidence entries. All evidence entries are deduplicated and sorted, retaining representative entries according to the fixed rule of "priority given to entries containing coverage prompts, later version timestamps, and later reading order," while the rest are merged into the citation column of the representative entries. The table assigns roles to each piece of evidence based on the minimum repair recommendations: evidence matching the recommended target value is labeled "reference evidence," evidence corresponding to the value to be repaired is labeled "evidence to be repaired," and evidence that triggers or corroborates exceptional conditions is labeled "exceptional evidence." An evidence chain is generated according to chronological order and link type, and forward and backward pointers and cross-references are established. The integrity of the evidence chain is verified (the starting point can explain the source of the current value, the ending point points to the root cause clause instance, and the reference evidence is reachable). If gaps exist, the missing evidence is filled in the page fragment object set according to the segment identifier and then rearranged. The evidence chain with sequential numbering and a traceable index is output.

[0082] S7.2 Generate an auditable verification result report based on the chain of evidence and minimum repair recommendations.

[0083] Based on the evidence chain and minimum repair recommendations, the verification result report is assembled according to a fixed format: the cover page includes the project name, tender number, purchaser name, and generation time; the overview section lists the violated rules (rule identifier, operator, scope, tolerance summary) and consistency status statistics; the facts section presents the evidence chain line by line: for each node, it lists the file identifier, version timestamp, file category, page number and layout coordinates, field name, original text and normalized result, and indicates the link label and coverage description between adjacent nodes, while also providing the comparison relationship of "evidence to be repaired → reference evidence"; the analysis section provides a mismatch explanation for each rule that is not satisfied, including the direction of difference, difference, etc. The report identifies whether the threshold or exception has been met, indexed by the node number in the evidence chain. The handling section includes minimum repair recommendations, specifying recommended actions (numerical alignment, unit standardization, currency standardization, date endpoint adjustment, withdrawal of mutually exclusive terms, supplementation of implied consequents, or establishment of exception clauses), the recommended placement (covering the end of the chain or referencing the target chain), the expected evaluation result, and the scope of impact (clause level or full text level). The audit section lists the page fragment object identifiers and fingerprint summaries, the evidence chain integrity verification results, the mapping table used, and the version summary of the tolerance strategy. Finally, a report number is generated, and both machine-readable structure and readable text are output simultaneously, both embedding the evidence chain node number and page coordinates.

[0084] In summary, this invention employs an executable procurement constraint language to compile cross-document consistency rules into an executable rule set that can be evaluated on a temporal knowledge graph. This enables precise evaluation of rules within the latest set of valid nodes, facilitating automatic determination of consistency and exceptions. By calculating the minimum hit set based on the conflict candidate set, obtaining the minimum conflict explanation set, and locating root cause clause instances, it generates minimum repair suggestions to guide value alignment and consistency. Ultimately, it resolves conflicts with minimal changes and outputs traceable verification results.

[0085] It should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and are not intended to limit it. Although the present invention has been described in detail with reference to preferred embodiments, those skilled in the art should understand that modifications or equivalent substitutions can be made to the technical solutions of the present invention without departing from the spirit and scope of the technical solutions of the present invention, and all such modifications or substitutions should be covered within the scope of the claims of the present invention.

Claims

1. An artificial intelligence-based mining document intelligent data processing method, characterized in that, The method comprises the following steps: S1, acquiring multiple-source and multiple-version files pointing to the same procurement project, performing layout rectification and OCR on the multiple-source and multiple-version files to obtain a page fragment object set, and establishing a version sequence; S2, based on the page fragment object set, using a controlled decoding language model to extract clause records according to a preset Schema to form a clause record set; S3, based on the clause record set and the version sequence, performing cross-version alignment on the same-name or synonymous clauses to construct a time-series knowledge graph; S4, using an executable procurement constraint language to compile cross-document consistency rules into an executable rule set that can be evaluated on the time-series knowledge graph; S5, based on the executable rule set, evaluating the scope of each rule on the time-series knowledge graph, and generating conflict candidates, and after convergence, obtaining a conflict candidate set; S6, based on the conflict candidate set, calculating a minimum hit set that makes all conflict candidates satisfy, obtaining a minimum conflict explanation set and locating root cause clause instances, and generating a minimum repair suggestion according to the normalized results of the violated rules and nodes; S7, outputting an auditable verification result report according to the root cause clause instances and the minimum repair suggestion.

2. The artificial intelligence-based tender document intelligent data processing method according to claim 1, characterized in that, In S1, the multiple-source and multiple-version files include a tender announcement, a tender document or a procurement requirement document, a clarification document or a question-answering document and a supplementary document, a correction announcement, a bid document and a bid document attachment, a bid evaluation report, a bid-winning notice, a contract text and a contract change document, an acceptance report, a prequalification document, a bid opening record, a technical specification table, and a drawing and a price list.

3. The artificial intelligence-based bid document intelligent data processing method of claim 2, wherein The layout rectification and OCR on the multiple-source and multiple-version files to obtain a page fragment object set and establish a version sequence comprises: Performing layout rectification on the multiple-source and multiple-version files to form geometrically normalized page images and retain file identifiers and version timestamps; Performing OCR on the geometrically normalized page images to obtain recognition results containing text content and layout coordinates and form page fragment candidates; Based on the page fragment candidates, the file identifiers, the version timestamps, the page numbers and the layout coordinates, constructing a page fragment object set; Based on the version timestamps, establishing a version sequence for the multiple-source and multiple-version files and recording the coverage relationship.

4. The artificial intelligence-based bid document intelligent data processing method of claim 1, wherein S2 specifically comprises: Based on the page fragment object set, performing content segmentation to obtain a text segment set consistent with the mapping of the preset Schema fields; Based on the preset Schema, constructing a controlled decoding language model prompt and limiting the output fields and the output format, combining the text segment set and the prompt to form a controlled decoding input; Based on the controlled decoding input, generating clause records by the controlled decoding language model and adding evidence pointers pointing to the page fragment object set; Based on the information of units, currencies and dates, performing normalization processing on the clause records and summarizing to form a clause record set.

5. The artificial intelligence-based bid document intelligent data processing method of claim 1, wherein S3 specifically comprises: Based on the clause record set and the version sequence, determining the cross-version alignment relationship of the same-name or synonymous clauses; According to the cross-version alignment relationship, generating clause instance nodes for each version; According to the version sequence, labeling coverage edges, revision edges, reference edges and abolition edges between the clause instance nodes; The coverage chain and the reference chain are generated in the version sequence order along the coverage edge and the reference edge, and the latest valid node set is identified for each clause instance by combining the marks of the revision edge and the revocation edge, which is the clause instance behind the version sequence and not revised or revoked; The clause instance node, the coverage edge, the revision edge, the reference edge, the revocation edge, the coverage chain, the reference chain and the latest valid node set are merged to form the time sequence knowledge graph.

6. The artificial intelligence-based bid document intelligent data processing method of claim 1, wherein S4 is specifically: The language model with controlled decoding is used to parse the cross-document consistency rule source according to the syntax of the executable recruitment constraint language and generate a rule candidate set; The rule candidate set, the clause record set and the latest valid node set in the time sequence knowledge graph are field-aligned and term-unified to form the cross-document consistency rule; The scope of each cross-document consistency rule is determined in the time sequence knowledge graph and is pointed to the latest valid node set; The normalized result in the clause record set corresponding to the node is read in the scope, the tolerance strategy of the unit, the currency and the date is configured, and the compilation is completed to obtain the executable rule set.

7. The artificial intelligence-based bid document intelligent data processing method of claim 6, wherein The executable rule set includes MUST_EQUAL operator, IN operator, RANGE operator, MUTEX operator, IMPLIES operator and EXCEPT_IF operator.

8. The artificial intelligence-based bid document intelligent data processing method of claim 1, wherein S5 is specifically: The scope of each rule in the time sequence knowledge graph is selected based on the executable rule set, and each rule is evaluated to obtain the consistency state of each rule; Based on the consistency state of the rule that is not met, a conflict candidate is generated; All conflict candidates are aggregated to obtain a conflict candidate set.

9. The artificial intelligence-based bid document intelligent data processing method of claim 1, wherein S6 is specifically: Based on the conflict candidate set, the correspondence between the conflict and the clause instance node is established, and the minimum hit set that makes all conflict candidates meet is calculated; Based on the minimum hit set, the minimum conflict explanation set is determined and the root cause clause instance is located on the time sequence knowledge graph; Based on the operator of the violated rule and the normalized result of the clause instance node, a minimum repair suggestion is generated.

10. The artificial intelligence-based bid document intelligent data processing method of claim 1, wherein S7 is specifically: Based on the root cause clause instance and the minimum repair suggestion, the evidence pointer in the evidence fragment object set is aggregated and the evidence chain is assembled; Based on the evidence chain and the minimum repair suggestion, an auditable verification result report is generated.

Images