Bid invitation document automatic generation and verification method based on large model

Abstract

The invention provides a bid invitation document automatic generation and verification method based on a large model, and belongs to the technical field of bid invitation document intelligent processing. The method comprises the following steps: firstly, carrying out structural analysis and semantic analysis on a bid invitation file text, bid invitation standard terms and historical bid invitation examples, constructing a chapter and section structure tree and a term element table, and on the basis, establishing a formalized constraint model comprising structural constraints, logic constraints and numerical value consistency constraints; and then performing constraint compiling on the formalized constraint model to generate a constraint solving model and a constraint dependence structure. And under constraint limitation, calling the large model to generate candidate bid invitation documents. According to the method, large model generation is combined with formalized constraint verification, multi-agent confrontation verification and strategy optimization repair, so that automatic generation, accurate verification and minimum modification repair of the bid invitation document are realized, the internal inconsistency and logic error risks of the bid invitation document are effectively reduced, and the reliability and availability of bid invitation document generation are improved.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of intelligent processing of bidding documents, and specifically belongs to the technical field of natural language understanding and semantic processing, and particularly relates to a method for automatically generating and checking bidding documents based on a large model. BACKGROUND

[0002] As a core technical and commercial document in the bidding activity, the bidding document usually needs to be completely, accurately and consistently compiled in terms of structural requirements, clause responses, qualification conditions and parameter information. In existing practice, the bidding document is mainly manually written or manually modified based on a template. This method not only consumes time and effort, but also is prone to problems such as missing chapters, chaotic numbering, incomplete clause responses and inconsistent parameters due to human negligence.

[0003] With the development of natural language processing technology, some existing technologies attempt to introduce a large model to automatically generate or assist in writing a bidding document. However, such solutions usually focus on text generation capabilities and are difficult to effectively model and check the complex structural constraints, logical dependencies and numerical consistency requirements required by the bidding document. This can lead to problems such as hidden errors in the generated content in terms of logic or compliance. In addition, due to the uncertainty of the large model generation process, there may be content omissions, clause mismatches or fabricated information in the generated results, further reducing the reliability of the generated bidding document. Therefore, we propose a method for automatically generating and checking bidding documents based on a large model.

[0004] The above information disclosed in the background section is only intended to enhance the understanding of the background of the present disclosure, and therefore it can include information that does not constitute the prior art known to those of ordinary skill in the art. SUMMARY

[0005] The purpose of the present application is to overcome the deficiencies of the prior art and provide a method for automatically generating and checking bidding documents based on a large model, which solves the technical problems mentioned in the background.

[0006] To achieve the above-mentioned purpose, the present application provides the following technical solutions:

[0007] A method for automatically generating and checking bidding documents based on a large model, comprising the following steps:

[0008] S1, structure analysis and semantic analysis of the bidding document text are performed to extract structural constraints, logical constraints and numerical consistency constraints for limiting the content of the bidding document, and the structural constraints, logical constraints and numerical consistency constraints are uniformly converted into a computable formal constraint model;

[0009] S2, constraint compilation is performed on the constraint model to generate a constraint solving model for checking the consistency and completeness of the bidding document, and a dependency relationship between constraint items is established to form a constraint dependency structure for subsequent checking and repair;

[0010] S3, under the limitation of the constraint solving model, a large model is called to generate the chapter structure, clause content and parameter information of the bidding document, and at least one candidate bidding document is obtained, which is input to the subsequent checking process as a to-be-checked object;

[0011] S4, a multi-agent checking mechanism is introduced for the candidate bidding document, and parallel checking is performed on the candidate bidding document; in the checking process, based on the constraint dependency structure, the text segments that violate the formal constraint in the candidate bidding document are identified, and a conflict graph is constructed by taking the text segments as nodes and the constraint conflict relationship as edges;

[0012] S5, a strategy optimization objective function for minimizing the document modification range is constructed by taking the conflict graph as input, and the minimum repair set required to eliminate all constraint conflicts is determined by solving the strategy optimization of the conflict graph, and the minimum repair set is used to indicate the target text segment and the corresponding repair strategy that need to be modified;

[0013] S6, according to the minimum repair set obtained in step S5, the candidate bidding document is executed directional repair, and the repaired bidding document is re-input into the constraint solving model for consistency checking, and under the condition that the consistency checking is passed, the final bidding document that meets all formal constraints is output.

[0014] S1 specifically includes: obtaining the bidding file text corresponding to the to-be-generated bidding document, the bidding specification clauses and the historical bidding example data source, and uniformly collecting the data source as a to-be-parsed input;

[0015] The to-be-parsed input is executed structure parsing to obtain a chapter structure tree for limiting the document skeleton, and the chapter structure tree includes chapter hierarchy, numbering rules and required chapter list;

[0016] The to-be-parsed input is executed semantic parsing to extract clause elements and generate a clause element table, and the clause element table at least includes qualification requirement elements, response requirement elements, parameter field elements and attachment requirement elements;

[0017] Based on the chapter structure tree and the clause element table, the constraints are extracted and uniformly modeled as a formal constraint model, and the formal constraint model at least includes structure constraints, logic constraints and numerical consistency constraints, and each constraint is bound to a corresponding trigger condition and a check item identifier.

[0018] S2 specifically includes: standardizing the structural constraints, logical constraints and numerical consistency constraints in the formal constraint model, and unifying the constraint granularity, constraint scope and constraint verification output format;

[0019] The standardized formal constraint model is compiled to generate a computable and decisionable constraint solution model, which is used to verify the consistency and completeness of the bidding documents.

[0020] Based on the preconditions and reference relationships between constraints in the formal constraint model, a constraint dependency structure is established. The constraint dependency structure is used to indicate the order of constraint triggering and the propagation path.

[0021] Based on the constraint solution model and constraint dependency structure, the verification output interface required for consistency verification is generated, so that subsequent steps can output the pass, fail, and corresponding trigger constraint identifiers and location information in a unified format.

[0022] S3 specifically includes: constructing a generation input package for large models to call based on the chapter structure tree, clause element table and formal constraint model. The generation input package includes chapter skeleton, field list, constraint hints and output format requirements.

[0023] Call the large model to generate the input package and generate at least one candidate tender document. The candidate tender document contains chapter content, clause response content and parameter field content.

[0024] The candidate bidding documents are input into the constraint solving model, and a fast verification based on structural constraints is performed. Candidates that do not meet the structural constraints are eliminated, and the target candidate bidding documents that enter the subsequent verification process are still recorded as the candidate bidding documents.

[0025] A document location mapping is established for candidate bidding documents. The document location mapping is used to correspond one-to-one with the chapters, clauses, and parameter fields and their positions in the candidate bidding documents, so as to serve as a unified location basis for subsequent multi-agent verification and conflict location.

[0026] S4 specifically includes: constructing a multi-agent verification mechanism, which includes at least a generation verification agent, a logical consistency verification agent, and an anti-illusion verification agent, and uses candidate bidding documents, constraint solving models, constraint dependency structures, and document location mappings as unified verification inputs;

[0027] The control multi-agent verification mechanism performs parallel verification on candidate bidding documents, generates verification agent output structure and format verification results, logic consistency verification agent outputs logic constraint verification results, and anti-illusion verification agent outputs credibility verification results for key parameters and key statements. Each verification result is bound to trigger constraint identifiers and location information.

[0028] The verification results output by the multi-agent verification mechanism are merged and deduplicated to form a list of conflict items. Each conflict item contains at least the target text fragment, trigger constraint identifier, conflict type and location information.

[0029] A conflict graph is constructed based on a list of conflict items and a constraint dependency structure. The nodes of the conflict graph are the target text fragments corresponding to the conflict items, and the edges of the conflict graph are the conflict relationships determined by the constraint dependency structure, which are used to characterize the direction of conflict propagation and the scope of mutual influence.

[0030] S5 specifically includes: constructing a set of repair strategies corresponding to the conflict type. The set of repair strategies includes at least a targeted rewrite strategy, a field backfilling strategy, a number alignment strategy, and a numerical consistency correction strategy. For each repair strategy, the target text fragment type and the scope of its application are defined.

[0031] Based on the conflict graph, candidate repair schemes are generated according to the constraint dependency structure. Each candidate repair scheme consists of several target text fragments and repair strategy pairs, and the candidate repair scheme is kept executable under the constraint dependency structure.

[0032] The candidate repair schemes are optimized by performing strategy optimization, with the goal of eliminating the conflict relationships represented by all conflict graph edges and minimizing the modification range. The passability of the candidate repair schemes is evaluated by combining the constraint solving model, and the minimum repair set that satisfies the optimization objective is output.

[0033] The minimum repair set consists of the target text fragments that need to be modified and their corresponding repair strategies. The minimum repair set is sorted according to the constraint dependency structure to generate a repair execution sequence, so as to ensure that subsequent targeted repairs follow the order of constraint triggering and avoid introducing new dependency conflicts.

[0034] S6 specifically includes: performing targeted repair on candidate bidding documents according to the repair execution sequence to obtain repaired bidding documents. Targeted repair only applies to the target text fragments indicated by the minimum repair set and adopts the indicated repair strategy; inputting the repaired bidding documents into the constraint solving model to perform consistency verification and outputting consistency verification results. The consistency verification results include the pass or fail corresponding trigger constraint identifier and location information.

[0035] If the consistency check result is unsuccessful, update the conflict item list and conflict graph based on the consistency check result, and return to step S5 with the updated conflict graph as input to resolve the minimum repair set.

[0036] If the consistency check result is passed, the repaired bidding document is output as the final bidding document, and the corresponding verification pass record is output to prove that the final bidding document satisfies the formal constraint model.

[0037] The beneficial effects of this invention are as follows:

[0038] This invention performs structural and semantic analysis on the text and standard clauses of bidding documents to construct chapter structure trees and clause element tables. Furthermore, it establishes a formal constraint model, ensuring that bidding documents are uniformly constrained by structural, logical, and numerical consistency constraints from the generation stage. This avoids issues such as missing chapters, omitted clauses, or content mismatches caused by relying solely on large models for free generation. All constraints required by the bidding documents are uniformly compiled into a constraint-solving model, and an executable verification function is used to perform consistency verification on the generated documents. This transforms the verification process from manual experience-based judgment to a calculable and repeatable automatic verification process, thereby significantly improving the accuracy and coverage of bidding document verification.

[0039] This invention introduces a multi-agent verification mechanism and combines it with a constraint dependency structure to construct a conflict graph. This allows for a systematic depiction of the dependency and propagation relationships between different conflicts in a tender document. It can not only identify single-point errors but also identify chain conflicts caused by preceding and subsequent dependencies, improving the detection capability for complex logical errors and hidden consistency problems. Based on the conflict graph, candidate repair schemes are constructed, and the minimum repair set is solved through strategy optimization. While ensuring the elimination of all constraint conflicts, the scope of modification to the original content of the tender document is minimized, thereby avoiding large-scale rewriting that introduces new errors and improving the stability and controllability of the automatic repair process.

[0040] This invention generates a repair execution sequence based on constraint dependencies, ensuring that repair actions are executed sequentially according to the order in which constraints are triggered. This avoids introducing new dependency conflicts due to improper repair order and guarantees the logical consistency of the tender document repair process from a technical perspective. When the consistency check fails, the conflict graph is automatically updated and the execution strategy is optimized. When the consistency check passes, the final tender document and the check pass record are output, forming a closed-loop process of automatic generation, automatic verification, and automatic repair. This significantly improves the reliability of the final output tender document in terms of structural integrity, logical consistency, and numerical accuracy. Attached Figure Description

[0041] Figure 1 This is a schematic diagram of an automatic generation and verification method for bidding documents based on a large model according to the present invention. Detailed Implementation

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

[0043] Example: Figure 1 As shown in the figure, this embodiment provides a method for automatically generating and verifying bidding documents based on a large model, including the following steps:

[0044] S1. Tender Constraint Acquisition and Formal Modeling Steps: Acquire the tender document text, tender specification clauses, and historical tender examples corresponding to the tender document to be generated; perform structural and semantic analysis on the tender document text; extract the structural constraints, logical constraints, and numerical consistency constraints used to limit the content of the tender document; and uniformly convert the structural constraints, logical constraints, and numerical consistency constraints into a computable formal constraint model.

[0045] S2. Formal constraint compilation and constraint solution model construction steps: The formal constraint model obtained in step S1 is compiled to generate a constraint solution model for verifying the consistency and completeness of the bidding documents, and the dependencies between constraint items are established to form a constraint dependency structure for subsequent verification and repair.

[0046] S3. The candidate bidding document generation step based on the large model: Under the constraint solving model constructed in step S2, the large model is called to generate the chapter structure, clause content and parameter information of the bidding document to obtain at least one candidate bidding document. The candidate bidding document is input as the object to be verified into the subsequent verification process.

[0047] S4. Adversarial multi-agent verification and conflict graph construction steps: For the candidate bidding documents, a multi-agent verification mechanism is introduced, including at least a generation verification agent, a logical consistency verification agent, and an anti-illusion verification agent, to perform parallel verification on the candidate bidding documents; During the verification process, based on the constraint dependency structure of step S2, text fragments in the candidate bidding documents that violate formal constraints are identified, and a conflict graph is constructed to describe the inconsistencies within the documents, using the text fragments as nodes and the constraint conflict relationships as edges.

[0048] S5. Strategy optimization and minimum repair set solution based on conflict graph: Taking the conflict graph constructed in step S4 as input, a strategy optimization objective function is constructed to minimize the scope of document modification. By performing strategy optimization on the conflict graph, the minimum repair set required to eliminate all constraint conflicts is determined. The minimum repair set is used to indicate the target text fragment that needs to be modified and the corresponding repair strategy.

[0049] S6. Constraint consistency verification based on minimum repair set: In the document generation step, according to the minimum repair set obtained in step S5, targeted repair is performed on the candidate bidding documents, and the repaired bidding documents are re-input into the constraint solving model for consistency verification. Under the condition that the consistency verification passes, the final bidding document that satisfies all formal constraints is output.

[0050] S1 specifically includes the following sub-steps:

[0051] S110, Data Source Acquisition Sub-step: Acquire the tender document text, tender specification clauses, and historical tender examples corresponding to the tender document to be generated, and encapsulate the three types of data sources into a unified document object. Each document object shall contain at least: document type, document text content, page number and text position mapping (if present), and document version identifier.

[0052] All document objects are grouped into a document collection, and a version identifier is generated for each document object, specifically as follows:

[0053]

[0054] in, Represents a collection of documents; Let i represent the i-th document object; n represent the total number of document objects; and i represent the index of the document object that satisfies the following conditions: .

[0055]

[0056] in, This represents the version identifier of the i-th document object; Represents the hash generation function; [the function is used to] generate the document set. It serves as the input to be parsed and is provided to subsequent structural and semantic parsing.

[0057] S120, Structure parsing sub-step: Perform structure parsing on the input to be parsed to identify chapter titles, unify chapter numbers, and construct chapter hierarchical relationships to obtain a chapter structure tree; wherein the chapter title identification adopts a joint determination of "numbering pattern + title keywords".

[0058] Scoring of the title candidates for the k-th line of text:

[0059]

[0060] in, This represents the title confidence score of the k-th line of text; k represents the line index. This indicates a numbered pattern matching indicator variable (1 for a match, 0 for otherwise). This indicates the title keyword hit score (calculated based on a preset keyword list);

[0061] a represents the numbering pattern weight coefficient; b represents the keyword hit weight coefficient, and a+b=1.

[0062] The text in line k is determined to be a chapter title when the following condition is met:

[0063]

[0064] in, This represents the threshold for title determination. After title determination is completed, the chapter structure tree is constructed based on the hierarchical relationship of chapter numbers, and the chapter structure tree is represented as follows:

[0065]

[0066] Where T represents the chapter structure tree; V represents the set of chapter nodes; and E represents the set of parent-child edges. Each chapter node contains at least a chapter number, a chapter title, and its start and end positions in the input to be parsed, thus providing a locatable structural basis for subsequent constraint extraction.

[0067] S130, Semantic Processing and Parsing Sub-step: Using natural language semantic processing technology, perform semantic parsing on the input to be parsed, extract the elements used to limit the content of the bidding document in the bidding terms, and form a clause element table; the clause element table shall at least include: element type, element name, element value, element location information, constraint association key and element confidence.

[0068] Calculate the element confidence score for the j-th extracted clause element:

[0069]

[0070] in, This indicates the confidence level of the j-th clause element; j represents the clause element index. Represents the feature vector of the j-th clause element; Represents the weight vector; This represents the vector transpose operation; This represents the Sigmoid function, which maps numbers to (0,1).

[0071] When the following formula is satisfied, the j-th clause element is marked as a low-confidence element for subsequent key verification:

[0072]

[0073] in, This represents the confidence threshold of the element; thus, the extraction results of the clause elements have an achievable closed loop of "quantifiable confidence + triggerable subsequent verification".

[0074] In a preferred implementation of this embodiment, a pre-trained language model (PLM) is used to obtain the feature vector of the elements. Specifically, the BERT-base-chinese model is used as the encoder. The text content of the j-th clause element is input into the model, and the [CLS] tag vector output from the last hidden layer is extracted as the semantic representation of that element, i.e., the feature vector. This vector has a dimension of 768, which can capture the deep semantic context information of the clause elements, thus providing high-dimensional feature input for subsequent Sigmoid confidence calculation.

[0075] S140, Formal Constraint Modeling Sub-step: Based on the chapter structure tree T and the clause element table, extract the constraints used to limit the generation and verification of the bidding documents, and model all constraints into a formal constraint model; the formal constraint model includes at least structural constraints, logical constraints and numerical consistency constraints, and each constraint is bound to a trigger condition and a verification item identifier.

[0076] The m-th constraint can be represented as:

[0077]

[0078] in, This represents the m-th constraint; m represents the constraint index. Indicates the identifier of the check item for the m-th constraint; The indicator variable represents the trigger condition of the m-th constraint (1 for trigger, 0 otherwise). This indicates the result of the judgment of the m-th constraint (1 if satisfied, 0 if not satisfied). This indicates the scope of the m-th constraint, used to indicate the chapter, clause element, or set of parameter fields corresponding to the constraint.

[0079] To ensure that the three types of constraints have computable decision expressions, at least the following simple form should be used:

[0080] (1) Structural constraints: All required chapters are complete

[0081]

[0082] in, This indicates the set of required chapters; This represents the set of chapters in the tender document to be verified; "" indicates a set inclusion relationship.

[0083] (2) Logical constraints: Dependency relationship (if A exists, then B must exist)

[0084]

[0085] in, The variable indicates the presence of the element identified as A in the clause (1 if present, 0 otherwise).

[0086] The variable indicates the presence of the element identified as B (1 if present, 0 otherwise); A indicates dependence on the preceding element identifier; B indicates dependence on the following element identifier.

[0087] (3) Numerical consistency constraint: The total value must be consistent with the sum of its components.

[0088]

[0089] in, Represents a summary value; Represents the value of the i-th item; N represents the number of items; i represents the item index and satisfies ; Indicates the allowable error threshold; This represents the absolute value operation;

[0090] Furthermore, the conditions for passing the global consistency check are given to ensure that the formal constraint model can be directly used for subsequent constraint solution model construction and verification:

[0091]

[0092] in, This indicates that the consistency check has passed (1 for passing, 0 otherwise).

[0093] Represents the set of constraint indexes; This indicates that a continuous logical AND operation is performed on the elements of the set; thus, the formal constraint model has a unified representation, triggering mechanism, computable decision and global pass condition, satisfying the requirements of sufficient disclosure and implementability.

[0094] S2 specifically includes the following sub-steps:

[0095] S210, Constraint Standardization Sub-step: Standardize each constraint in the formal constraint model obtained in step S140. Standardize to ensure that all constraints are consistent in terms of "constraint type, scope expression, trigger condition expression, and validation output format".

[0096] Introduce a constraint type identifier for each constraint. and the scope of effect Standardization is defined as a set consisting of several positioning units, specifically:

[0097]

[0098] in, Indicates the first The constraint type identifier of a constraint; when =1 indicates a structural constraint, when =2 indicates a logical constraint, when =3 indicates a numerical consistency constraint; Indicates a constraint index.

[0099]

[0100] in, Indicates the first The scope of the constraint; Indicates the first Within the scope of the constraint, the first One positioning unit; Represents the location cell index and satisfies ; Indicates the first The number of positioning units contained in a constraint.

[0101] Through the above standardization, subsequent constraint compilation and verification outputs can complete conflict location and repair under a unified location semantics.

[0102] S220, Constraint Compilation Sub-step: Compile the standardized constraints Compile into an executable verification function, and form a constraint solution model based on it to support subsequent consistency verification and conflict localization.

[0103] For each constraint Generate the corresponding executable verification function and the constraint determination result The output of this function is written uniformly as follows:

[0104]

[0105] in, Indicates the first The result of the constraint determination (1 if satisfied, 0 if not satisfied); Indicates the first An executable verification function for the constraints; This represents the input data for verification, used to carry the scope of the tender document being verified. The corresponding structural information, clause element information, and numerical information (served as a function input container for easy implementation).

[0106] The entire set of executable verification functions and the set of constraint indices are encapsulated together into a constraint solving model:

[0107]

[0108] in, Represents the constraint solution model; Represents the set of constraint indexes; This represents the set of executable verification functions. Through the compilation of the above constraints, the formal constraint model acquires a computationally executable form.

[0109] S230, Dependency Establishment Sub-step: Based on the triggering conditions, reference relationships, and overlapping scope relationships of each constraint, establish the sequential dependencies between constraints to form a constraint dependency structure that can be used to verify sequence control and conflict propagation analysis.

[0110] Define the set of constraint-dependent edges :

[0111]

[0112] in, Represents the set of constraint-dependent edges; " indicates the Cartesian product operation; when When, it indicates the first The constraint is the first Pre-dependent constraints of a constraint; and All represent constrained indexes and satisfy and .

[0113] To facilitate implementation and quick querying, Further represented as a dependency adjacency matrix :

[0114]

[0115] in, Representing the dependency adjacency matrix In the Line 1 Column elements; =1 indicates the existence of " → The dependency edge must be "" or otherwise does not exist.

[0116] Further define the first Pre-dependency set of constraints :

[0117]

[0118] in, Indicates the first The set of prerequisite dependencies for each constraint.

[0119] The resulting constraint dependency structure can be used to specify the order in which constraints are triggered and the path for conflict propagation.

[0120] S240, Verification of output interface generation sub-step: Based on constraint solution model With constraint dependency structure (by This generates the required verification output interface for consistency verification, enabling subsequent steps to output consistency verification pass indicators and conflict location information in a unified format.

[0121] Define conflict set Used to hold all output items that do not meet constraints:

[0122]

[0123] in, Represents a set of conflicts; This indicates a conflicting output item; Indicates the first The identifier of the validation item for the constraint; Indicates the first The trigger condition indicator variable for the constraint (1 for trigger, 0 otherwise); Indicates the first The result of determining the constraint; Indicates the positioning unit; Represents the set of scopes.

[0124] The consistency check of the output from the verification interface has passed. The results are aggregated from the constraint determination results as follows:

[0125]

[0126] in, This indicates that the consistency check has passed (1 for passing, 0 otherwise). This indicates that a series of logical AND operations are performed on the elements of the set that meet the conditions.

[0127] Therefore, the verification output interface can output uniformly. and conflict set This provides structured input for subsequent multi-agent verification and conflict graph construction.

[0128] S3 specifically includes the following sub-steps:

[0129] S310, Sub-step for generating input package: Based on the chapter structure tree T, clause element table and formal constraint model, a generating input package is constructed for the large model to call, so that the large model generation process has clear input constraints at the structural, element and constraint levels.

[0130] The definition of the terms and conditions elements table is as follows:

[0131]

[0132] in, Presents a table of terms and conditions; Indicates the first Each clause element is recorded; Indicates the total number of clause element records; Indicates the index of clause elements and satisfies .

[0133] Define the formal constraint model as follows:

[0134]

[0135] in, Representing a formal constraint model; Indicates the first Constraints; Represents the set of constraint indexes; Represents a constrained index that satisfies .

[0136] Build and generate the input package:

[0137]

[0138] in, This indicates the generation of the input packet; Represents the chapter structure tree; and The meaning is as above; This represents a set of output format requirements, used to specify the chapter output order, field output format, and numbering rules.

[0139] S320, Sub-step for generating candidate tender documents: Calling the large model to generate the input package. Generate at least one candidate tender document and organize the generated candidate tender documents into a candidate set for subsequent screening.

[0140] Define the large model generation function as follows:

[0141]

[0142] in, This represents a large model generation function used to generate textual tender documents based on the input.

[0143] Generate a collection of candidate tender documents:

[0144]

[0145] in, This represents a set of candidate tender documents; Indicates the first One candidate tender document; Indicates the number of candidate tender documents; Indicates the index of candidate tender documents and satisfies .

[0146] Each candidate tender document is generated from a large model:

[0147]

[0148] in, Indicates the first The generation control parameters for each candidate tender document are used to control the diversity of generated documents and the stability of output.

[0149] S330, Quick Structure Screening Sub-step: Select the candidate tender document set Input constraint solution model Prioritize the rapid verification of structural constraints, filter out candidates that do not meet the structural constraints, and determine the target candidate bidding documents to enter the subsequent verification process.

[0150] To distinguish between the triggers and judgment results under candidate documents, trigger and judgment symbols related to candidate documents are introduced:

[0151]

[0152] in, Indicates the first The first candidate tender document The trigger condition indicator variable for the constraint (1 for trigger, 0 otherwise); Indicates the first The first candidate tender document The result of the constraint determination (1 if satisfied, 0 if not satisfied).

[0153] The executable verification function is compiled based on the constraints defined above. , for the Each candidate tender document constructs its validation input data:

[0154]

[0155] in, Indicates the first The verification input data for each candidate tender document is used to carry the structural information, clause element information, and numerical information of the candidate tender document within the scope of each constraint.

[0156] And calculate the judgment result:

[0157]

[0158] in, Indicates the first The executable verification function for the constraint; the meanings of the other symbols are the same as above.

[0159] Based on constraint type identifier (Its definition is consistent with the previous text, and) =1 represents a structural constraint), defining the first... The structure verification of each candidate bidding document has passed:

[0160]

[0161] in, Indicates the first The structure verification of each candidate bidding document has passed (1 for passing, 0 otherwise); " indicates a logical AND operation.

[0162] When it exists When a candidate has a value of 1, it is retained and proceeds to the subsequent verification process; when multiple candidates pass, a structural satisfaction score is introduced to determine the target candidate.

[0163]

[0164] in, Indicates the first The structural satisfaction score of each candidate tender document; "∑" represents the summation operation.

[0165] And select the target candidate index:

[0166]

[0167] in, This indicates the index of target candidate tender documents; This represents the index operation that maximizes the objective function.

[0168] Will The document that is identified as a target candidate bidding document for subsequent verification processes will still be recorded as a candidate bidding document.

[0169] S340, Document Location Mapping Sub-step: Establish a document location mapping for the candidate bidding documents, so that chapters, clause elements and parameter fields all have reusable unified location basis, so as to support the closed-loop consistency of subsequent multi-agent verification output and conflict location.

[0170] Define the set of document elements for the candidate tender documents:

[0171]

[0172] in, Represents a collection of document elements; Indicates the first One document element; Indicates the total number of document elements; Represents the document element index and satisfies The document elements include at least chapter elements, clause response elements, and parameter field elements.

[0173] Define the set of location units for this candidate tender document:

[0174]

[0175] in, Represents a set of positioning units; Indicates the first One positioning unit; Indicates the total number of positioning units; Represents the location cell index and satisfies Each positioning unit This is used to indicate the position of the corresponding text fragment within the candidate tender document, including page number and character start and end positions. (Note:) Related to the previous text Both represent "locating units," differing only in their index format but sharing the same meaning.

[0176] Establish document location mapping:

[0177]

[0178] in, Indicates document location mapping; Indicates the first The positioning unit corresponding to each document element; Indicates document element index The mapping relationship to the positioning unit index.

[0179] This limits the scope of constraint in subsequent steps. Document location mapping By establishing a closed-loop association between "constraint-document element-location unit", consistent conflict location and repair can be achieved.

[0180] S4 specifically includes the following sub-steps:

[0181] S410, Multi-agent verification initialization sub-step: Construct a multi-agent verification mechanism for performing adversarial verification on candidate bidding documents, and take candidate bidding documents, constraint solving models, constraint dependency structures and document location mappings as unified inputs.

[0182] Define the set of intelligent agents as:

[0183]

[0184] in, Represents a set of intelligent agents; This indicates the generation of a verification agent, used to check the consistency of the chapter structure, numbering, and format of candidate bidding documents; This represents a logical consistency verification agent used to check the consistency of candidate bidding documents in terms of dependencies, mutual exclusions, and references under logical constraints. This represents an anti-illusion verification agent used to check the credibility and constraint matching of key clause responses and key parameter fields in candidate bidding documents.

[0185] The target candidate bidding documents that proceed to the subsequent verification process will still be recorded as candidate bidding documents. ,in: Indicates candidate tender documents; This indicates the index of the target candidate tender documents.

[0186] The following objects are used as the unified input for the multi-agent verification mechanism: constraint solving model. Dependency Adjacency Matrix Scope of constraint and document location mapping .

[0187] Specifically, anti-hallucination verification agent A dual verification strategy based on "historical data statistics" and "source document tracing" is adopted. First, a historical bidding parameter database is constructed. For key numerical parameters (such as "registered capital" and "construction period in days") in candidate bidding documents, the agent obtains their distribution range in the historical database. (in The mean, The standard deviation is used to determine whether a generated parameter value exceeds this range. If the generated parameter value exceeds this range, it is considered a suspected numerical illusion. Secondly, for non-numerical key clauses (such as "qualification level requirements"), the agent uses Retrieval Augmentation Generation (RAG) technology. The generated clause text is used as a query vector to search for the semantically most similar original basis in the bidding specification clause library. If the maximum similarity score found is lower than a preset credibility threshold (e.g., 0.75), it is considered a content fabrication illusion. Through these two strategies, a credibility verification result is output.

[0188] S420, Parallel Verification Execution Sub-Step: Control Agent Set Each intelligent agent in the process views the candidate bidding documents. Parallel verification is performed, and the verification outputs of each agent are unified into a structured form of "constraint identifier-location unit" for subsequent merging and conflict graph construction.

[0189] For each intelligent agent The set of agent conflicts output by the system is defined as follows:

[0190]

[0191] in, Represents intelligent agents A set of conflicting agents; Indicates the first The identifier of the validation item for the constraint; This indicates a positioning unit used to indicate candidate tender documents. The text location that triggered the conflict.

[0192] Meanwhile, based on the constraint solution model Candidate tender documents The consistency verification result determines the triggering and judgment of the candidate bidding document:

[0193] Indicates candidate tender documents Next The trigger condition indicator variable for the constraint (1 for trigger, 0 otherwise); Indicates candidate tender documents Next The result of the constraint determination (1 if satisfied, 0 if not satisfied).

[0194] S430, Conflict Item List Generation Sub-step: Generate the conflict set output by the constraint solution model. and the conflict set of each agent Merge and deduplicate to generate a list of conflict items for conflict graph construction and subsequent repair solutions.

[0195] Define the set of merge conflicts as:

[0196]

[0197] in, Indicates merging conflict sets; " represents the union operation of sets; "⋃" represents the union operation of a family of sets.

[0198] Merge conflict sets Organizations listed as conflict items:

[0199]

[0200] in, Represents a list of conflicting items; Indicates the first One conflicting item; Indicates the total number of conflicting items; Represents a conflicting index that satisfies .

[0201] To ensure that subsequent conflict graphs can directly reference the dependency adjacency matrix Each conflicting item is defined as:

[0202]

[0203] in, Indicates the first The constraint indexes corresponding to each conflict term and satisfying ; Indicates the constraint index is (Verification item identifier); Indicates the first The location unit corresponding to each conflict item; Indicates the constraint index is Constraint type identifier (1 for structural constraint, 2 for logical constraint, 3 for numerical consistency constraint).

[0204] To enhance transparency and quantify multi-agent consensus, conflict voting is introduced. :

[0205]

[0206] in, Indicates the first The number of conflicting votes for each conflicting item; This indicates an indicator function that evaluates to 1 if the condition within the parentheses is true, and 0 otherwise. (Note: Conflict vote count) This is only used for subsequent prioritization and remediation strategy selection; it does not change the location or constraint identifiers of conflicting items.

[0207] S440, Conflict Graph Construction Sub-step: Based on the list of conflict items With the dependency adjacency matrix Construct a conflict graph to describe the propagation and mutual influence of conflicts, so that the subsequent "minimum repair set solution" has a computable graph structure input.

[0208] First, define the candidate bidding documents. The set of indexes that violate constraints:

[0209]

[0210] in, This indicates a set of indexes that violate constraints.

[0211] Constructing a conflict graph:

[0212]

[0213] in, Representing a conflict diagram; Represents the set of nodes in a conflict graph; This represents the set of edges in a conflict graph.

[0214] List of conflict items One-to-one mapping to conflict graph nodes, defined as:

[0215]

[0216] in, Indicates conflicting items The corresponding node.

[0217] To reflect the conflict propagation relationship caused by constraint dependencies, the set of edges in the conflict graph is defined as follows:

[0218]

[0219] in, Indicates from node Pointing to node The directed edges; Representing the dependency adjacency matrix The element (a value of 1 indicates the existence of a dependency edge); and Representing nodes respectively With nodes The corresponding constraint index.

[0220] Therefore, the conflict diagram Capable of simultaneously expressing "conflict item location unit" "and "constrained dependency propagation" The closed-loop relationship of “” provides a computable input for the subsequent solution of the minimum repair set.

[0221] S5 specifically includes the following sub-steps:

[0222] S510, Repair Strategy Set Construction Sub-step: Construction and Constraint Type Identification It also provides a set of repair strategies that match the characteristics of conflict items, and defines the conflict types and scope of each repair strategy to facilitate the generation of candidate repair schemes and the optimization of strategies.

[0223] Define the set of repair strategies as follows:

[0224]

[0225] in, Represents the set of repair strategies Indicates the first One repair strategy; Indicates the number of repair strategies; Indicates the repair strategy index and satisfies .

[0226] To clarify the "conflict type → available strategy" relationship, a strategy application mapping function is defined:

[0227]

[0228] in, The constraint type identifier is A subset of available repair strategies at that time; Indicates the constraint type identifier (1 for structural constraint, 2 for logical constraint, 3 for numerical consistency constraint). Indicates the first Each repair strategy is applicable to the type. The applicable indicator variable (1 if applicable, 0 otherwise).

[0229] (Note: For example, you can...) Specifically, this is implemented through strategies such as targeted rewriting, field backfilling, number alignment, and numerical correction.

[0230] S520, Candidate Repair Scheme Generation Sub-step: Based on the Conflict Item List Conflict diagram For each conflict, an available remediation strategy is selected and combined to form a set of candidate remediation schemes, making the candidate remediation schemes executable under dependency constraints.

[0231] Define the repair action as:

[0232]

[0233] in, Indicates a repair action; Indicates the first Conflict items (including constraint indexes) Verification item identifier Positioning unit Constraint type identifier ); Indicates the repair strategy; Indicates the index of conflicting items.

[0234] For each conflicting item It limits its optional repair strategies to those from That is, satisfying:

[0235]

[0236] in, Indicates the constraint index is Constraint type identifier.

[0237] Define the set of candidate repair solutions as:

[0238]

[0239] in, Represents the set of candidate repair solutions; Indicates the first One candidate repair solution; Indicates the number of candidate repair solutions; Indicates the index of candidate repair schemes and satisfies .

[0240] Each candidate repair scheme consists of several repair actions:

[0241]

[0242] in, Indicates the first The first of the candidate repair solutions One repair action; Indicates the first The number of repair actions included in each candidate repair scheme; Indicates that the action index is repaired and satisfies .

[0243] S530, Strategy Optimization Solution Sub-step: For the set of candidate repair solutions... The execution strategy is optimized with the goal of "eliminating conflicts and minimizing the scope of modifications", and the output is the minimum set of repairs that satisfies the optimization goal.

[0244] To quantify the "scope of modification", for each conflicting item Define its modification cost:

[0245]

[0246] in, Indicates the first The cost of modifying a conflicting item; Indicates the first The number of conflicting votes for each conflicting item; Represents a set of intelligent agents; Represents a set of intelligent agents The number of elements; ≥0 indicates a cost adjustment coefficient, which is used to adjust the strength of the impact of voting consensus on the cost of modification.

[0247] Definition of the first The cost function of each candidate repair scheme:

[0248]

[0249] in, Indicates the first The cost of each candidate repair solution; Indicates repair action The corresponding conflict item index (i.e.) ).

[0250] For each candidate repair scheme Apply the corresponding repair actions to the candidate tender documents. The repaired tender document was obtained, and the constraint solution model was used. Calculate its consistency verification pass flag, denoted as:

[0251]

[0252] in, Indicates the adoption of candidate repair schemes The consistency check is passed and marked as 1 (if passed, it is 0 otherwise).

[0253] The index of candidate repair schemes that satisfy consistency checks and have the lowest cost is selected through strategy optimization:

[0254]

[0255] in, This represents the index of the optimal candidate repair solution; This represents the index operation that minimizes the objective function; " indicates that the constraint conditions are met.

[0256] The optimal candidate repair scheme is determined as the minimum repair set:

[0257]

[0258] in, This represents the minimal repair set, whose elements are repair actions. Used to indicate the target text segment that needs to be modified (by the positioning unit) (Provided) and corresponding repair strategies .

[0259] S540, Repair the execution sequence generation sub-step: based on the dependency adjacency matrix With the set of predecessor dependencies For the minimum repair set The repair actions are sorted to generate a repair execution sequence, so that targeted repairs follow the constraint dependency order and avoid introducing new dependency conflicts.

[0260] Define the set of constraint indices extracted from the minimal repair set:

[0261]

[0262] in, This indicates that the minimum repair set involves the set of constraint indexes; Indicates conflicting items The corresponding constraint index.

[0263] The repair execution sequence is defined as follows:

[0264]

[0265] in, Indicates the repair execution sequence; Indicates the first position in the sequence One repair action; Indicates the total number of repair actions and satisfies ; Represents the position index of the sequence and satisfies ; This represents the operation of counting the elements in a set; to ensure consistency in dependency order, a sequence position function is introduced:

[0266]

[0267] in, This function represents the position of the repair action within the repair execution sequence.

[0268] For any two repair actions and If the corresponding constraint index satisfies the dependency relationship, then their order in the sequence must satisfy the following:

[0269]

[0270] in, Representing the dependency adjacency matrix The element (a value of 1 indicates the existence of a dependency edge); and Representing conflicting items , Constraint indexes.

[0271] The resulting repair execution sequence It can serve as the sole sequential input for subsequent "targeted repair execution," ensuring that the logical loop is consistent with the reference.

[0272] S6 specifically includes the following sub-steps:

[0273] S610, Targeted Repair Execution Sub-step: Follow the repair execution sequence (Its meaning is consistent with the preceding text), regarding candidate bidding documents Perform targeted repair to obtain the repaired tender documents.

[0274] To make "targeted repair" feasible and reproducible, a repair operator is introduced:

[0275]

[0276] in, Indicates the positioning unit in document x The repair strategy s is applied to the indicated target text fragment, and the repaired document is output; x represents the input tender document; The 's' represents the location unit (meaning consistent with the previous text); 's' represents the repair strategy (belonging to the set of repair strategies). (The meaning is the same as in the previous text).

[0277] Use candidate tender documents as initial values ​​for iteration:

[0278]

[0279] in, The initial document representing the repair iteration; This indicates the candidate tender document (consistent with the previous text).

[0280] For the t-th repair action (Its meaning is consistent with the preceding text, and) Perform targeted repair iterations:

[0281]

[0282] in, This represents the document after the t-th repair action has been executed; T represents the total number of repair actions (as before); t represents the repair action number. This represents the index of the conflict item corresponding to the t-th repair action; This represents the index of the repair strategy corresponding to the t-th repair action; Indicates conflicting items The corresponding positioning unit; Indicates the first One repair strategy.

[0283] Define the final iteration result as the repaired tender document:

[0284]

[0285] in This indicates the repaired tender document.

[0286] S620, Consistency Verification Sub-step: Transfer the repaired tender document... Input constraint solution model Perform a consistency check and output the consistency check pass identifier and conflict set to ensure that the repaired bidding documents meet the formal constraint model.

[0287] To differentiate between triggers and judgments under the repaired tender document, the following is introduced:

[0288]

[0289] in, This indicates the repaired tender document. The trigger condition indicator variable for the m-th constraint (1 for trigger, 0 otherwise); This indicates the repaired tender document. The result of determining the m-th constraint (1 if satisfied, 0 if not satisfied); m represents the constraint index and the constraint satisfies... .

[0290] Based on the executable verification function defined above ,right Construct its validation input data And calculate:

[0291]

[0292] in, This indicates the repaired tender document. Validate the input data.

[0293] Define the consistency verification flag for the repaired bidding documents:

[0294]

[0295] in, This indicates the repaired tender document. The consistency check pass flag (1 for pass, 0 otherwise); Represents the logical AND operation.

[0296] It also outputs the set of conflicts in the repaired tender documents:

[0297]

[0298] in, This indicates the repaired tender document. The set of conflicts; Indicates the identifier of the check item for the m-th constraint; Indicates the scope of the m-th constraint; This indicates a positioning unit.

[0299] S630, Closed-loop update sub-step: After the consistency check passes the flag... Under the condition of, based on the repaired conflict set Update the list of conflict items and the conflict graph, and return to step S5 with the updated conflict graph as input to resolve the minimum repair set, thus forming a closed loop of "verification-repair-reverification".

[0300] Define the closed-loop trigger condition:

[0301]

[0302] in, The meaning is consistent with the above. When the closed-loop triggering condition is met, based on Generate an updated list of conflicting items:

[0303]

[0304] in, This indicates the repaired tender document. List of conflicting items; This indicates the repaired tender document. The s-th conflicting item; This indicates the total number of conflict items after the fix; s represents the index of the conflict items after the fix.

[0305] And construct an updated conflict graph:

[0306]

[0307] in, This indicates the repaired tender document. Conflict diagram; This represents the set of nodes in the conflict graph after repair. This represents the set of edges in the conflict graph after repair.

[0308] Note: The construction rules are consistent with S440 above, still based on the dependent adjacency matrix A and the violation of constraints to establish edge relationships, ensuring consistency between the referencing of closed loops and the implementation; the updated conflict graph will be used. Return to step S5 as a new conflict graph input to re-execute "Candidate Repair Scheme Generation - Strategy Optimization Solution - Repair Execution Sequence Generation".

[0309] S640, Final Output Sub-step: After the consistency check passes the flag... Under the given conditions, the repaired tender document is output as the final tender document, and a verification pass record is output to prove that the final tender document satisfies the formal constraint model.

[0310] Define the final output conditions:

[0311]

[0312] in, The meaning is consistent with the above. When the final output conditions are met, define the final tender document:

[0313]

[0314] in, This refers to the final tender document; This indicates the repaired tender document (consistent with the aforementioned).

[0315] Simultaneously output the verification success record:

[0316]

[0317] in, This indicates a record that passed the verification. This indicates that the m-th constraint is in the revised tender document. The trigger and judgment records below; The meanings are consistent with those mentioned above.

[0318] Thus, the "final tender document" is achieved. +Verification passed record A traceable output closed loop.

[0319] The above formulas are all dimensionless calculations. The formulas are derived from software simulations based on a large amount of collected data to obtain the most recent real-world results. The preset parameters and thresholds in the formulas are set by those skilled in the art according to the actual situation.

[0320] Those skilled in the art will recognize that the modules and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this application.

[0321] In conclusion, the above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

Claims

1. A method for automatic generation and verification of tender documents based on a large model, characterized in that, Includes the following steps: S1. Perform structural and semantic analysis on the tender document text, extract the structural constraints, logical constraints, and numerical consistency constraints used to limit the content of the tender document, and convert the structural constraints, logical constraints, and numerical consistency constraints into a computable formal constraint model. S2. Perform constraint compilation on the constraint model to generate a constraint solution model for verifying the consistency and completeness of the bidding documents, and establish the dependency relationship between constraint items to form a constraint dependency structure for subsequent verification and repair. S3. Under the constraints of the solution model, the large model is called to generate the chapter structure, clause content and parameter information of the bidding document, and at least one candidate bidding document is obtained. The candidate bidding document is input as the object to be verified into the subsequent verification process. S4. Introduce a multi-agent verification mechanism for candidate bidding documents to perform parallel verification on candidate bidding documents; During the verification process, based on the constraint dependency structure, text fragments in candidate bidding documents that violate formal constraints are identified, and a conflict graph is constructed using text fragments as nodes and constraint conflict relationships as edges. S5. Using the conflict graph as input, construct a strategy optimization objective function to minimize the scope of document modification. By solving the strategy optimization problem on the conflict graph, determine the minimum repair set required to eliminate all constraint conflicts. The minimum repair set is used to indicate the target text fragments that need to be modified and the corresponding repair strategies.

2. The method for automatic generation and verification of bidding documents based on a large model according to claim 1, characterized in that, Also includes: S6. Based on the minimum repair set obtained in step S5, perform targeted repair on the candidate bidding documents, and re-input the repaired bidding documents into the constraint solution model for consistency verification. If the consistency verification passes, output the final bidding document that satisfies all formal constraints.

3. The method for automatic generation and verification of bidding documents based on a large model according to claim 1, characterized in that, S1 specifically includes: Obtain the tender document text, tender specification clauses, and historical tender sample data sources corresponding to the tender document to be generated, and unify the data sources into the input to be parsed; The input to be parsed is parsed to obtain a chapter structure tree that defines the document skeleton. The chapter structure tree contains chapter levels, numbering rules and a list of required chapters. Semantic parsing is performed on the input to be parsed to extract the clause elements and generate a clause element table. The clause element table must contain at least qualification requirement elements, response requirement elements, parameter field elements, and attachment requirement elements. Constraints are extracted based on the chapter structure tree and clause element table, and the constraints are uniformly modeled as a formal constraint model. The formal constraint model includes at least structural constraints, logical constraints and numerical consistency constraints, and each constraint is bound with a corresponding trigger condition and verification item identifier.

4. The method for automatic generation and verification of bidding documents based on a large model according to claim 1, characterized in that, S2 specifically includes: Standardize the structural constraints, logical constraints, and numerical consistency constraints in the formal constraint model to unify the constraint granularity, constraint scope, and constraint verification output format. The standardized formal constraint model is compiled to generate a computable and decisionable constraint solution model, which is used to verify the consistency and completeness of the bidding documents. Based on the preconditions and reference relationships between constraints in the formal constraint model, a constraint dependency structure is established. The constraint dependency structure is used to indicate the order of constraint triggering and the propagation path. Based on the constraint solution model and constraint dependency structure, the verification output interface required for consistency verification is generated, so that subsequent steps can output the pass, fail, and corresponding trigger constraint identifiers and location information in a unified format.

5. The method for automatic generation and verification of bidding documents based on a large model according to claim 1, characterized in that, S3 specifically includes: Based on the chapter structure tree, clause element table and formal constraint model, a generation input package is constructed for large models to call. The generation input package includes chapter skeleton, field list, constraint hints and output format requirements. Call the large model to generate the input package and generate at least one candidate tender document. The candidate tender document contains chapter content, clause response content and parameter field content. The candidate bidding documents are input into the constraint solving model, and a fast verification based on structural constraints is performed. Candidates that do not meet the structural constraints are eliminated, and the target candidate bidding documents that enter the subsequent verification process are still recorded as the candidate bidding documents. A document location mapping is established for candidate bidding documents. The document location mapping is used to correspond one-to-one with the chapters, clauses, and parameter fields and their positions in the candidate bidding documents, so as to serve as a unified location basis for subsequent multi-agent verification and conflict location.

6. The method for automatic generation and verification of bidding documents based on a large model according to claim 1, characterized in that, S4 specifically includes: A multi-agent verification mechanism is constructed, which includes at least a generation verification agent, a logical consistency verification agent, and an anti-illusion verification agent, and uses candidate bidding documents, constraint solving models, constraint dependency structures, and document location mappings as unified verification inputs. The control multi-agent verification mechanism performs parallel verification on candidate bidding documents, generates verification agent output structure and format verification results, logic consistency verification agent outputs logic constraint verification results, and anti-illusion verification agent outputs credibility verification results for key parameters and key statements. Each verification result is bound to trigger constraint identifiers and location information. The verification results output by the multi-agent verification mechanism are merged and deduplicated to form a list of conflict items. Each conflict item contains at least the target text fragment, trigger constraint identifier, conflict type and location information. A conflict graph is constructed based on a list of conflict items and a constraint dependency structure. The nodes of the conflict graph are the target text fragments corresponding to the conflict items, and the edges of the conflict graph are the conflict relationships determined by the constraint dependency structure, which are used to characterize the direction of conflict propagation and the scope of mutual influence.

7. The method for automatic generation and verification of bidding documents based on a large model according to claim 1, characterized in that, S5 specifically includes: Construct a set of repair strategies corresponding to the conflict type. The set of repair strategies includes at least the targeted rewrite strategy, the field backfilling strategy, the number alignment strategy, and the numerical consistency correction strategy. Define the target text fragment types and the scope of application for each repair strategy. Based on the conflict graph, candidate repair schemes are generated according to the constraint dependency structure. Each candidate repair scheme consists of several target text fragments and repair strategy pairs, and the candidate repair scheme is kept executable under the constraint dependency structure. The candidate repair schemes are optimized by eliminating the conflict relationships represented by all conflict graph edges and minimizing the modification range. The passability of the candidate repair schemes is evaluated by combining the constraint solving model, and the minimum repair set that satisfies the optimization objective is output.

8. The method for automatic generation and verification of bidding documents based on a large model according to claim 7, characterized in that, S5 also includes: the minimum repair set consists of the target text fragments that need to be modified and their corresponding repair strategies; the minimum repair set is sorted according to the constraint dependency structure to generate a repair execution sequence, so as to ensure that subsequent targeted repairs follow the order of constraint triggering and avoid introducing new dependency conflicts.

9. The method for automatic generation and verification of bidding documents based on a large model according to claim 2, characterized in that, S6 specifically includes: According to the repair execution sequence, targeted repair is performed on the candidate bidding documents to obtain the repaired bidding documents. Targeted repair only applies to the target text fragments indicated by the minimum repair set and adopts the indicated repair strategy. The repaired tender document is input into the constraint solving model to perform a consistency check, and the consistency check result is output. The consistency check result includes the corresponding trigger constraint identifier and location information for passing or failing. If the consistency check result is unsuccessful, update the conflict item list and conflict graph based on the consistency check result, and return to step S5 with the updated conflict graph as input to resolve the minimum repair set.

10. The method for automatic generation and verification of bidding documents based on a large model according to claim 9, characterized in that, S6 also includes: under the condition that the consistency verification result is passed, outputting the repaired bidding document as the final bidding document, and outputting the verification pass record corresponding to the final bidding document, so as to prove that the final bidding document satisfies the formal constraint model.

Images