A method, system and program product for verifiable combinatorial reasoning of large models based on combinatorial certificate lattices

Abstract

The application discloses a kind of big model verifiable combination reasoning methods, systems and program products based on combination certificate lattice, method includes: the task to be solved is constructed as combination intermediate representation;Combination certificate lattice state is constructed;Big model is limited to untrusted candidate generator, only output machine can be parsed Proposal;By deterministic combination checker, execute mode check, constraint predicate check, invariant update, upper bound certificate generation and dominance determination;Maintenance anti-chain frontier and according to upper bound certificate and dominance certificate pruning;Refuse certificate is converted into structured counterexample and is fed back to subsequent candidate generation;Output combination solution, objective function value and replayable certificate trajectory.This method separates semantic candidate generation from machine-verifiable certificate at the level of combination mathematics, can reduce the risk of infeasible solution caused by big model illusion, and make the final result and pruning according to auditable and replayable.

Description

Technical Field

[0001] This invention belongs to the technical fields of artificial intelligence, combinatorial optimization, verifiable reasoning, and intelligent computing systems. In particular, it relates to a verifiable combinatorial reasoning method, system, and program product based on combinatorial certificate lattices for large models. Specifically, it relates to a verifiable combinatorial reasoning method, system, and program product that combines the candidate generation capability of large models with constraint predicate verification, combinatorial invariant maintenance, upper bound proof, dominance pruning, anti-chain front maintenance, and certificate trajectory replay in combinatorial mathematics. Background Technology

[0002] Large models can understand natural language tasks, extract entity relations, propose candidate solutions, and generate solution ideas, but their outputs often lack machine-verifiable proofs of combinatorial feasibility. For combinatorial problems such as maximum cover, weighted independent sets, resource allocation, task scheduling, path selection, set packing, and set covering, relying solely on large models to directly provide solutions can easily lead to constraints being omitted, local conflicts, errors in objective function calculation, or unverifiable pruning instructions.

[0003] Traditional combinatorial optimization algorithms can provide deterministic verification and strict pruning, but candidate expansion order, problem decomposition strategies, and local repair strategies often rely on manual modeling or fixed heuristic rules. When the task comes from natural language, semi-structured data, or dynamic business rules, purely traditional algorithms require high modeling costs and struggle to leverage the ability of large models to understand task semantics, constraint importance, and candidate priority.

[0004] Existing large-scale model reasoning methods are mostly based on natural language thought chains, search tree nodes, or combinations of prompt words. They lack stable identifiers, combinatorial invariants, and certificate bindings between search states and combinatorial mathematical objects. Existing automatic modeling methods emphasize generating integer programming or constrained models from large models, but do not limit large models to untrusted candidate sources, nor do they maintain replayable certificate trajectories, anti-chain fronts, dominance certificates, and upper bound certificates at the combinatorial object level.

[0005] Therefore, a technical solution is needed so that the large model only undertakes the role of candidate expansion, candidate decomposition, candidate ranking or local repair suggestions, while the deterministic combinatorial verifier is responsible for feasibility, upper bound, dominance, optimal candidate update and certificate generation, thereby simultaneously obtaining semantic candidate capability, combinatorial optimization solution quality and auditable and replayable engineering credibility.

[0006] A search revealed that Chinese patent application CN120561144A provides a method for generating collaborative SQL for reasoning based on structural hints, which differs from this application in the following ways:

[0007] 1. The technical objects of this application are SQL substructures, SQL generation paths, and candidate SQL; the technical objects of this application are composite objects, composite constraints, composite invariants, and certificate status.

[0008] 2. The verification basis of the previous application is mainly SQL execution feedback and path scoring; the verification basis of this application is deterministic combination constraint verification, upper bound certificate and dominance certificate.

[0009] 3. The output of this application is the SQL query result; this application outputs the combined solution, objective value, certificate set, and replayable trajectory;

[0010] 4. The multi-path reasoning tree of this application cannot replace the anti-chain frontier of this application, because the multi-path scoring does not provide an upper bound proof or a dominance proof in the sense of combinatorial mathematics.

[0011] A search revealed that Chinese patent application CN118939783A provides a method and apparatus for large-scale model reasoning based on knowledge graph retrieval enhancement, which differs from this application in the following ways:

[0012] 1. The pruning object of this application is the evidence subgraph in the knowledge graph; the pruning object of this application is the combination of search states and candidate combination objects.

[0013] 2. The pruning criteria in that application were based on a regression scorer and a score threshold; the pruning criteria in this application are based on the upper bound certificate, the dominance certificate, and the backlink frontier.

[0014] 3. This application addresses the problem of utilizing external knowledge in knowledge-enhanced question answering; this application addresses the problem of verifiable search and proof replay in combinatorial mathematics tasks.

[0015] 4. The application does not disclose the CIR, certificate status q, acceptance / rejection / upper limit / dominance of the certificate, or replayable certificate trajectory;

[0016] 5. This application can only illustrate that "large model reasoning can be combined with external structures and pruned" is a relevant background and cannot teach or cover the combination certificate lattice mechanism of this application.

[0017] A search revealed that Chinese patent application CN120144310A provides a distributed inference task allocation method for large-scale edge computing models, which differs from this application in the following ways:

[0018] 1. The combination selection objects of this application are inference tasks and edge resource allocation; the combination objects of this application are candidate combination solutions that are verified during the inference process.

[0019] 2. The objective of this application is deployment / scheduling benefits and resource utilization; the objective of this application is the feasibility, optimality and certificate verification of the combined reasoning results.

[0020] 3. The solution method of this application is mathematical model reconstruction and approximate optimization; this application is a closed loop of large model candidate generation and deterministic certificate lattice verification.

[0021] 4. The application does not disclose untrusted large model candidates, combinatorial validators, upper bound certificates, dominance certificates, backlink frontiers, or replayable certificate trajectories.

[0022] 5. This application is close to the concept of "combined selection", but it belongs to reasoning deployment scheduling and does not involve the verifiable combined reasoning structure of this application. Therefore, the verifiable combined reasoning structure of this application is not disclosed.

[0023] The above three articles are a combination of the application;

[0024] 1. The applications focus on three areas: SQL generation, knowledge graph-enhanced question answering, and edge reasoning task allocation. Their technical goals differ: one optimizes the generation of correct SQL, one enhances knowledge question answering, and one optimizes resource scheduling; none of them incorporate the output of the large model into the combinatorial mathematical certificate lattice for reliable verification.

[0025] 2. Even if existing technologies suggest "multi-path," "pruning," or "combined selection," they do not provide a mechanism for combining verifiable upper bound certificates, dominance certificates, and anti-chain frontiers. Without these structures, the replayable proof trajectory of this application cannot be obtained;

[0026] 3. This application does not simply apply existing pruning algorithms to large models, but redefines the role of the large model in the system: the large model only proposes candidates, and the trustworthiness judgment is entirely completed by the combined validator and certificate. This separation of roles is the key difference from ordinary large model inference optimization. Summary of the Invention

[0027] The technical problem to be solved by this invention is:

[0028] (1) Avoid infeasible solutions, missing constraint solutions or errors in objective value calculation when the large model directly generates the combinatorial solution; (2) Integrate the candidate suggestions of the large model into the deterministic combinatorial optimization process, and prohibit the large model from directly determining feasibility, optimality or pruning; (3) Ensure that each candidate acceptance, candidate rejection, upper bound pruning, dominance pruning and optimal candidate update has a machine-verifiable certificate; (4) Reduce repeated searches and invalid candidates through anti-link frontier, dominance certificate, upper bound certificate and structured counterexample feedback; (5) Ensure that the final combinatorial solution and search process can be replayed and verified by a third party without re-calling the large model.

[0029] To achieve the objectives of this invention, the technical solution adopted is as follows:

[0030] A large-model verifiable combinatorial reasoning method based on combinatorial certificate lattices includes:

[0031] S1, Receive the task to be solved T, and construct the task to be solved T as a combined intermediate representation CIR=(E,O,C,I,w,K,B,D,H), where E is the set of basic elements, O is the set of candidate combined objects, C is the set of constraint predicates, I is the set of combined invariants and their update functions, w is the objective function, K is the set of candidate expansion operators, B is the set of upper bound certificate generators, D is the set of dominance decision templates, and H is the normalized serialization and hashing rule; Each type of task to be solved is configured with a corresponding set of constraint predicates C, combined invariants I, set of upper bound certificate generators B, set of dominance decision templates D, and hashing rule H.

[0032] S2, assign a stable object identifier to each candidate combination object in O, and generate at least one type of machine-resolvable load including coverage load, cost load, conflict load, resource load and ordering load;

[0033] S3, initialize the combined certificate grid state q0=(S0,R0,F0,v0,b0,P0,h0), where S0 is an empty set of selected objects, R0 is the initial set of remaining candidate objects, F0 is an empty set of prohibited objects, v0=I(S0), b0 is calculated by B, P0 is an empty certificate set, and h0 is calculated by H after normalizing and serializing the state field; the current best candidate x* is initialized to an empty solution or a preset feasible solution, and the objective function value is initialized to w(x*) or a preset inferior value.

[0034] S4, maintain the open state set Q, the anti-chain frontier A and the current best candidate x*. The combined certificate grid is composed of the certificate grid state set, the certificate set, the dominant partial order defined by D, the anti-chain frontier A and the state hash defined by H. Take out the state to be expanded q from Q, and generate an upper bound certificate and discard q when the upper bound b(q) of q is not greater than the objective function value of x*.

[0035] S5, when q is not pruned by the upper bound, construct a candidate request record based on the canonical state summary, constraint summary, generated counterexamples and candidate budgets of q, and input the candidate request record into the large model candidate generator to obtain a finite number of machine-resolvable candidate proposals; in the complete solution mode, the deterministic candidate completer also generates candidate proposals that are not output by the large model candidate generator but are still within the scope based on K, R(q), F(q) and CIR; in the budget solution mode, write the node budget, time budget or candidate budget into the candidate request record and certificate trajectory.

[0036] S6, perform pattern verification on each proposal first;

[0037] If the operator identifier of the proposal does not belong to K, the target object does not belong to R(q), the target object belongs to F(q), or the parameter type does not conform to CIR, then a candidate rejection certificate is generated.

[0038] For proposals that pass the pattern validation, the deterministic combinatorial validator executes the constraint predicate in C, the invariant update function in I, the upper bound certificate generator in B, and the dominance decision template in D one by one to generate candidate acceptance certificates, candidate rejection certificates, upper bound certificates, dominance certificates, counterexamples, or optimal candidate update certificates.

[0039] S7. When the proposal is accepted, a new state q' is generated. The antichain frontier A is used to determine whether q' is dominated by an existing state. If it is dominated, a domination certificate is generated and q' is discarded. If q' dominates an existing state in A, the dominated state is deleted and q' is written to A and Q.

[0040] When a proposal is rejected, the violation of constraints, the minimum set of conflicting objects, and the repair action in the candidate rejection certificate are encoded as a structured counterexample, and the structured counterexample is used as the exclusion condition, weighting condition, or decomposition condition for subsequent candidate generation.

[0041] S8, when Q is empty and in complete solution mode, outputs the replayable optimal candidate x*, objective function value, certificate trajectory and state hash sequence; when the node budget or time budget is reached, outputs the current optimal candidate x* within the budget, objective function value, budget termination flag, certificate trajectory and state hash sequence, so that the third party can replay and verify the final combined solution and pruning process without calling the large model candidate generator again.

[0042] Further, the element record in the basic element set E is e=(ElementId,AttributeVector,Weight,GroupId), where ElementId is the stable identifier of the basic element, AttributeVector is the attribute vector of the basic element, Weight is the weight or benefit value of the basic element, and GroupId is the group identifier to which the basic element belongs.

[0043] The object record in the candidate combination object set O is o=(ObjectId,ElementMask,CostVector,ConflictMask,ResourceVector,PrecedenceVector,ObjectPayload), where ObjectId is the stable identifier of the candidate combination object, ElementMask represents the basic element covered or affected by the object, CostVector represents the cost vector of the object, ConflictMask represents the object that cannot be selected together with the object, ResourceVector represents the resources consumed or released by the object, PrecedenceVector represents the order or dependency relationship of the object, and ObjectPayload represents the business payload of the object;

[0044] Each constraint predicate Cj in the constraint predicate set C is represented as a deterministic function Cj(S,o,Args)->(Pass,ViolationCode,Witness), where Cj represents the j-th constraint predicate, S represents the currently selected object set, o represents the candidate object to be verified, Args represents the candidate extension parameters, Pass indicates whether the candidate satisfies the constraint, ViolationCode represents the constraint violation number, and Witness represents the minimum evidence used for replay verification; the deterministic combined verifier accepts the candidate only when all constraint predicates return Pass=True;

[0045] The combined invariant and its update function I include at least one of the following: overlay mask, used budget, remaining budget, number of selected items, conflict disabling mask, connectivity summary, matching endpoint summary, rank function summary, and cumulative value of objective function; for an accepted candidate o, the update function generates a new invariant according to v'=Update(v,o,Args), and the difference between v and v' is recorded in the certificate.

[0046] Further, the input to the large model candidate generator in step S5 does not include the free-form search history, but includes StateSummary=(StateHash,SelectedIds,RemainingSummary,ForbiddenSummary,InvariantVector,BoundValue,IncumbentValue,ConstraintDigest,CounterExampleDigest,Budget), where StateHash is the hash value obtained by canonical serialization and hash calculation of the state field of the current state to be expanded q according to H, SelectedIds is the set of selected object identifiers in S(q), RemainingSummary is the compressed digest of R(q), ForbiddenSummary is the compressed digest of F(q), InvariantVector is the current combined invariant vector, BoundValue is the state upper bound value calculated by the upper bound certificate generator, and IncumbentValue is the current optimal candidate. The objective function value, ConstraintDigest is the summary of the constraint predicate set C and its versions, CounterExampleDigest is the summary of the generated structured counterexample set, Budget is the quantity budget, node budget, time budget or token budget of the candidate generation in this round; and the Proposal output by the large model candidate generator is Proposal=(ProposalId,OpId,TargetIds,Arguments,Priority,RationaleHash), where ProposalId is the unique identifier of the candidate, OpId is the candidate expansion operator identifier and belongs to K, TargetIds is the set of candidate combination object identifiers for this expansion, Arguments is the set of operator parameter key values, Priority is the candidate expansion priority, RationaleHash is the hash value calculated by H for the large model natural language reason or prompt context, and can be parsed by JSON, ProtocolBuffers, MessagePack or key-value field serialization format composed of the above field names and field values.

[0047] Further, the candidate rejection certificate records CertType, StateHash, ProposalHash, ViolatedConstraintId, ViolationCode, MinimalWitness, RepairHint, and VerifierVersion, where CertType is the certificate type, StateHash is the hash value obtained by serializing and hashing the state field of the verified state according to H, ProposalHash is the candidate hash value obtained by serializing and hashing the field name and field value of the Proposal according to H, ViolatedConstraintId is the identifier of the failed constraint, ViolationCode is the violation type code, MinimumWitness is the minimum replayable evidence, RepairHint is the candidate repair hint, and VerifierVersion is the deterministic composite verifier version;

[0048] The candidate acceptance certificate records include CertType, StateHash, ProposalHash, AcceptedObjectIds, SatisfiedConstraintIds, OldInvariant, NewInvariant, DeltaValue, and ReplayParameters, where AcceptedObjectIds is the set of accepted object identifiers, SatisfiedConstraintIds is the set of constraint-satisfied identifiers, OldInvariant is the combined invariant before acceptance, NewInvariant is the combined invariant after acceptance, DeltaValue is the objective function increment, and ReplayParameters are the parameters required for replay verification.

[0049] The upper bound certificate record contains CertType, StateHash, BoundGeneratorId, BoundValue, IncumbentValue, BoundPayload, and ComparisonResult. BoundGeneratorId is the identifier of the upper bound certificate generator, BoundValue is the target upper bound achievable by the current state, IncumbentValue is the current optimal candidate target value, BoundPayload is the upper bound computational load, and ComparisonResult is the deterministic comparison result between BoundValue and IncumbentValue. When ComparisonResult indicates that BoundValue is not greater than IncumbentValue, the state is pruned, and this pruning does not depend on the natural language interpretation output by the large model.

[0050] Furthermore, each template Dk in the dominance decision template set D is represented as a deterministic function Dk(StateA,StateB)->(Dominated,FieldComparison,Witness), where Dk represents the k-th dominance decision template, StateA is the first certificate state to be compared, StateB is the second certificate state to be compared, Dominated is the Boolean result indicating whether a dominance relationship exists, FieldComparison is the comparison record of fields such as target value, remaining expandable set, constraint margin, combinatorial invariant, and state upper bound, and Witness is the minimum replayable evidence for the dominance decision. Only when Dominated=True and the target value, remaining expandable set, constraint margin, combinatorial invariant, and state upper bound recorded in FieldComparison all satisfy the preset dominance conditions will the system generate a dominance certificate and delete or discard the dominated state.

[0051] Furthermore, when the task to be solved, T, is a maximum coverage task, the dominance determination template set D is configured as follows: if two states have the same processing position and selected quantity, and the CoveredMask of the first state contains the CoveredMask of the second state, then the first state dominates the second state; wherein the first state is an existing state in the antichain frontier A or a state to be compared, StateA, and the second state is a new state q' or a state to be compared, StateB; when the first state comes from A and dominates q', q' is discarded; when q' dominates an existing state in A as the first state, the dominated existing state is deleted; the dominance certificate records the same processing position, the same selected quantity, and the inclusion relationship of CoveredMask.

[0052] Furthermore, when the task to be solved, T, is a weighted conflict selection task, the dominance determination template set D is configured as follows: if two states have the same set of candidate vertices, and the current cumulative weight of the first state is not less than the current cumulative weight of the second state, then the first state dominates the second state; the dominance certificate records the comparison result of the candidate vertex set hash and the cumulative weight.

[0053] Furthermore, when the task to be solved, T, is a maximum coverage task with budget conflicts, the dominance decision template set D is configured as follows: if two states have the same processing position, the same number of selected objects, and the same used budget, and the CoveredMask of the first state contains the CoveredMask of the second state, and the remaining scalable candidate object set of the first state contains the remaining scalable candidate object set of the second state, then the first state dominates the second state; wherein the first state is an existing state or a state to be compared, StateA, in the antichain frontier A, and the second state is a new state q' or a state to be compared, StateB; when the first state comes from A and dominates q', q' is discarded; when q' dominates an existing state in A as the first state, the dominated existing state is deleted; the dominance certificate records the processing position, the number of selected objects, the used budget, the inclusion relationship of the remaining scalable candidate object set, and the inclusion relationship of CoveredMask.

[0054] Furthermore, when the task to be solved, T, is the maximum coverage task, the upper bound certificate generator is configured to: sort the remaining candidate objects in descending order of their marginal coverage gains relative to the current CoveredMask, sum them with the remaining number of options as the truncation length, and use the sum of the current coverage gain corresponding to the current CoveredMask and the summation result as BoundValue; if BoundValue is not greater than the current optimal coverage gain, then prune the state.

[0055] Furthermore, when the task T to be solved is a weighted conflict selection task, the upper bound certificate generator performs a deterministic clique cover or a greedy clique cover on the remaining conflict graph, and uses the sum of the maximum vertex weights in each clique as the upper bound of the independent set weights; if the sum of the current cumulative weight and the upper bound is not greater than the current optimal weight, then the state is pruned.

[0056] Furthermore, when the task T to be solved is the maximum coverage task with budget conflicts, the upper bound certificate generator sorts the remaining candidate objects according to the ratio of marginal coverage benefit to cost, and performs fractional knapsack relaxation under the constraints of remaining budget and remaining number of options to obtain the upper bound of coverage benefit; if the upper bound of coverage benefit is not greater than the current optimal benefit, then the state is pruned.

[0057] Further, the structured counterexample in step S7 is represented as CounterExample=(FailedOp,FailedTargetIds,ViolatedConstraintId,MinimalConflictSet,ForbiddenPattern,RepairHint,TTL), where FailedOp is the failure operator identifier, FailedTargetIds is the set of failed target object identifiers, ViolatedConstraintId is the identifier of the violated constraint, MinimalConflictSet is the minimum set of conflicting objects that caused the failure, ForbiddenPattern is the pattern that subsequent candidates should avoid, RepairHint is the repair action hint, and TTL represents the effective round number of the counterexample in the subsequent candidate generation. When a subsequent Proposal hits ForbiddenPattern, the system generates a fast rejection certificate before calling the deterministic combination validator, or reduces the extension priority of the Proposal.

[0058] Further, in step S8, the certificate trace is stored as Trace=(CIRDigest,InitialStateHash,OrderedStateRecords,OrderedProposalRecords,OrderedCertificateRecords,IncumbentUpdateRecords,FinalSolutionRecord), where CIRDigest is the combined intermediate representation digest, InitialStateHash is the initial state hash, OrderedStateRecords are the state records arranged in replay order, OrderedProposalRecords are the candidate records arranged in generation order, OrderedCertificateRecords are the certificate records arranged in verification order, IncumbentUpdateRecords are the optimal candidate update records, and FinalSolutionRecord is the final combined solution record. During replay verification, the replayer only reads the Trace and CIR, and recalculates the state hash, constraint predicate, invariant difference, upper bound comparison, and dominance comparison according to the certificate order.

[0059] Furthermore, when the task T to be solved has a multi-objective function, w is represented as an objective vector and a deterministic comparator, the current best candidate x* is replaced by a Pareto candidate set, and the upper bound certificate and dominance certificate both record the comparison results relative to the Comparator or Pareto dominance relation.

[0060] Furthermore, when multiple combined certificate grid states are expanded in parallel, state hash deduplication, certificate log appending, anti-chain front atomic merging, and comparison of the current best candidate version number are adopted; when two parallel branches generate the same state hash, only the state record with the smaller certificate trajectory lexicographical order or the objective function value is retained.

[0061] Furthermore, the task T to be solved includes at least one of the following: maximum coverage, maximum coverage with budget, maximum coverage with conflict, weighted independent set, set packing, set coverage, matching, path selection, graph partitioning, task allocation, resource allocation, vehicle routing, job scheduling, and multi-objective constraint selection. For the task T to be solved, C, I, B, D, and H corresponding to that task are pre-configured.

[0062] This invention also provides a large-model verifiable combinatorial reasoning system based on combinatorial certificate lattices for implementing the above method, comprising:

[0063] The task normalization module is used to generate CIR=(E,O,C,I,w,K,B,D,H);

[0064] The certificate status module is used to initialize and update q=(S,R,F,v,b,P,h);

[0065] The candidate request module is used to construct candidate request records based on the state summary and the counterexample summary;

[0066] The large model candidate generation module is used to output machine-parseable proposals;

[0067] The schema verification module is used to verify the structure and scope of the Proposal.

[0068] The deterministic combination verification module is used to perform constraint predicates, invariant updates, upper bound certificate generation, and dominance determination.

[0069] The antichain front module is used to maintain a set of mutually non-dominant states;

[0070] The Counterexample feedback module is used to generate and apply CounterExamples;

[0071] The certificate log module is used to save the trace; the output module is used to output the combined solution, objective function value and replayable certificate trace.

[0072] The present invention also provides a computer program product, including a computer program or instructions, which, when executed by a processor, implement the above-described method.

[0073] The present invention also provides a computer device, including a memory, a processor, and a computer program or instructions stored in the memory and executable by the processor, wherein the processor executes the computer program or instructions to implement the above-described method.

[0074] The present invention also provides a computer-readable storage medium having a computer program or instructions stored thereon, which, when executed by a processor, implement the above-described method.

[0075] Compared with the prior art, the technical solution of the present invention has the following beneficial technical effects:

[0076] 1. The large model is limited to candidate sources, and its feasibility, optimality or pruning cannot be directly confirmed, which reduces the risk of the illusion output entering the final solution;

[0077] 2. CIR, combined certificate status, Proposal, Certificate, and Trace are all structured objects, reducing ambiguity in natural language;

[0078] 3. Upper bound certificates and control certificates provide verifiable pruning evidence, improving search efficiency while preserving audit evidence;

[0079] 4. Structured counterexamples feed back failure modes to subsequent candidate generation, reducing invalid candidates that repeatedly violate the same constraint;

[0080] 5. The replayer can verify the final solution, objective function value, state hash, and pruning comparison without calling a large model, thus enhancing project deliverability;

[0081] 6. This method can be reused in various combined tasks such as maximum coverage, budget conflict coverage, weighted conflict selection, task allocation, scheduling, and path selection. Attached Figure Description

[0082] Figure 1 This is a schematic diagram of the task representation and certificate lattice initialization process in a large-model verifiable combinatorial inference method based on combinatorial certificate lattices, provided as an embodiment of the present invention; wherein, q in the figure represents a general certificate lattice state, and q0 represents an initial certificate lattice state instance.

[0083] Figure 2 This is a schematic diagram of the candidate generation and deterministic combination verification process in a large-model verifiable combinatorial reasoning method based on combinatorial certificate lattices according to an embodiment of the present invention.

[0084] Figure 3 This is a schematic diagram of the search advancement, frontier maintenance, and pruning process in a large-model verifiable combinatorial inference method based on combinatorial certificate lattices according to an embodiment of the present invention.

[0085] Figure 4This is a schematic diagram of the certificate classification, auditable output, and replay verification process in a large-model verifiable combinatorial reasoning method based on combinatorial certificate lattices according to an embodiment of the present invention. Detailed Implementation

[0086] The specific embodiments of the present invention will now be described in detail with reference to the accompanying drawings.

[0087] Example 1:

[0088] This embodiment provides a large-model verifiable combinatorial reasoning method based on combinatorial certificate lattices, such as... Figures 1 to 4 As shown, it includes:

[0089] S1 receives the task T to be solved and constructs it into a combined intermediate representation CIR=(E,O,C,I,w,K,B,D,H), where E is the set of basic elements, O is the set of candidate combined objects, C is the set of constraint predicates, I is the combinational invariant and its update function, w is the objective function, K is the set of candidate expansion operators, B is the set of upper bound certificate generators, D is the set of dominance decision templates, and H is the normalized serialization and hashing rule. The task T to be solved includes at least one of the following: maximum coverage, maximum coverage with budget, maximum coverage with conflict, weighted independent set, set packing, set coverage, matching, path selection, graph partitioning, task allocation, resource allocation, vehicle routing, job scheduling, and multi-objective constraint selection. Each type of task to be solved is configured with a corresponding set of constraint predicates C, combinational invariant I, set of upper bound certificate generators B, set of dominance decision templates D, and hashing rule H.

[0090] The element record in the basic element set E is e=(ElementId,AttributeVector,Weight,GroupId), where ElementId is the stable identifier of the basic element, AttributeVector is the attribute vector of the basic element, Weight is the weight or benefit value of the basic element, and GroupId is the group identifier to which the basic element belongs.

[0091] The object record in the candidate combination object set O is o=(ObjectId,ElementMask,CostVector,ConflictMask,ResourceVector,PrecedenceVector,ObjectPayload), where ObjectId is the stability identifier of the candidate combination object, ElementMask represents the basic element covered or affected by the object, CostVector represents the cost vector of the object, ConflictMask represents the object that cannot be selected together with the object, ResourceVector represents the resources consumed or released by the object, PrecedenceVector represents the order or dependency relationship of the object, and ObjectPayload represents the business payload of the object;

[0092] Each constraint predicate Cj in the constraint predicate set C is represented as a deterministic function Cj(S,o,Args)->(Pass,ViolationCode,Witness), where Cj represents the j-th constraint predicate, S represents the currently selected object set, o represents the candidate object to be verified, Args represents the candidate extension parameters, Pass indicates whether the candidate satisfies the constraint, ViolationCode represents the constraint violation number, and Witness represents the minimum evidence used for replay verification. The deterministic combined verifier accepts a candidate only when all constraint predicates return Pass=True.

[0093] The combined invariant and its update function I include at least one of the following: overlay mask, used budget, remaining budget, number of selected items, conflict disabling mask, connectivity summary, matching endpoint summary, rank function summary, and cumulative value of objective function; for an accepted candidate o, the update function generates a new invariant according to v'=Update(v,o,Args), and the difference between v and v' is recorded in the certificate.

[0094] S2 assigns a stable object identifier to each candidate combination object in O and generates at least one type of machine-resolvable load, including coverage load, cost load, conflict load, resource load, and ordering load.

[0095] S3, initialize the combined certificate lattice state q0=(S0,R0,F0,v0,b0,P0,h0), where S0 is an empty set of selected objects, R0 is the initial set of remaining candidate objects, F0 is an empty set of prohibited objects, v0=I(S0), b0 is calculated by B, P0 is an empty certificate set, and h0 is calculated by H after normalizing and serializing the state fields. The current optimal candidate x* is initialized as an empty solution or a preset feasible solution, and the objective function value is initialized as w(x*) or a preset inferior value.

[0096] S4, maintain the open state set Q, the anti-chain frontier A and the current best candidate x*. The combined certificate grid is composed of the certificate grid state set, the certificate set, the dominant partial order defined by D, the anti-chain frontier A and the state hash defined by H. Take out the state to be expanded q from Q, and generate an upper bound certificate and discard q when the upper bound b(q) of q is not greater than the objective function value of x*.

[0097] S5, when q is not pruned by the upper bound, construct a candidate request record based on the canonical state summary, constraint summary, generated counterexamples and candidate budgets of q, and input the candidate request record into the large model candidate generator to obtain a finite number of machine-parseable candidate proposals; in the complete solution mode, the deterministic candidate completer also generates candidate proposals that are not output by the large model candidate generator but are still within the scope based on K, R(q), F(q) and CIR; in the budget solution mode, write the node budget, time budget or candidate budget into the candidate request record and certificate track.

[0098] The input to the large model candidate generator does not include the free-form search history, but includes StateSummary = (StateHash, SelectedIds, RemainingSummary, ForbiddenSummary, InvariantVector, BoundValue, IncumbentValue, ConstraintDigest, CounterExampleDigest, Budget), where StateHash is the hash value obtained after serializing the current combinatorial certificate lattice state using the H-canonical method, SelectedIds is the set of selected object identifiers, RemainingSummary is the compressed digest of R(q), ForbiddenSummary is the compressed digest of F(q), InvariantVector is the current combinatorial invariant vector, BoundValue is the upper bound of the state calculated by the upper bound certificate generator, IncumbentValue is the objective function value of the current optimal candidate, and ConstraintDigest, CounterExampleDigest, Budget is the input. `aintDigest` is a summary of the constraint predicate set C and its versions; `CounterExampleDigest` is a summary of the generated structured counterexample set; `Budget` is the quantity budget, node budget, time budget, or token budget for this round of candidate generation; and the output of the large model candidate generator is `Proposal=(ProposalId,OpId,TargetIds,Arguments,Priority,RationaleHash)`, where `ProposalId` is the unique identifier of the candidate, `OpId` is the identifier of the candidate expansion operator and belongs to K, `TargetIds` is the set of candidate combination object identifiers for this expansion, `Arguments` is the set of operator parameter key values, `Priority` is the candidate expansion priority, and `RationaleHash` is the hash value calculated by `H` from the large model's natural language reasoning or prompt context, and can be parsed by JSON, ProtocolBuffers, MessagePack, or a key-value field serialization format consisting of the above field names and field values.

[0099] S6, perform pattern verification on each proposal first;

[0100] If the operator identifier of the proposal does not belong to K, the target object does not belong to R(q), the target object belongs to F(q), or the parameter type does not conform to CIR, then a candidate rejection certificate is generated.

[0101] For proposals that pass the pattern validation, the deterministic combinatorial validator executes the constraint predicate in C, the invariant update function in I, the upper bound certificate generator in B, and the dominance decision template in D one by one to generate candidate acceptance certificates, candidate rejection certificates, upper bound certificates, dominance certificates, counterexamples, or optimal candidate update certificates.

[0102] The candidate rejected certificate record contains CertType, StateHash, ProposalHash, ViolatedConstraintId, ViolationCode, MinimalWitness, RepairHint, and VerifierVersion. CertType is the certificate type, StateHash is the hash value of the verified state, ProposalHash is the hash value of the candidate, ViolatedConstraintId is the identifier of the failed constraint, ViolationCode is the violation type code, MinimalWitness is the minimum replayable evidence, RepairHint is the candidate repair hint, and VerifierVersion is the deterministic composite verifier version.

[0103] The candidate acceptance certificate records include CertType, StateHash, ProposalHash, AcceptedObjectIds, SatisfiedConstraintIds, OldInvariant, NewInvariant, DeltaValue, and ReplayParameters. Among them, AcceptedObjectIds is the set of accepted object identifiers, SatisfiedConstraintIds is the set of constraint identifiers that have been satisfied, OldInvariant is the combination invariant before acceptance, NewInvariant is the combination invariant after acceptance, DeltaValue is the objective function increment, and ReplayParameters are the parameters required for replay verification.

[0104] The upper bound certificate records CertType, StateHash, BoundGeneratorId, BoundValue, IncumbentValue, BoundPayload, and ComparisonResult. BoundGeneratorId is the identifier of the upper bound certificate generator, BoundValue is the target upper bound that the current state can reach, IncumbentValue is the current optimal candidate target value, BoundPayload is the upper bound computational load, and ComparisonResult is the deterministic comparison result between BoundValue and IncumbentValue. When ComparisonResult indicates that BoundValue is not greater than IncumbentValue, the state is pruned, and this pruning does not depend on the natural language interpretation of the large model output.

[0105] S7. When the proposal is accepted, a new state q' is generated. The antichain frontier A is used to determine whether q' is dominated by an existing state. If it is dominated, a domination certificate is generated and q' is discarded. If q' dominates an existing state in A, the dominated state is deleted and q' is written to A and Q.

[0106] Each template Dk in the dominance decision template set D is represented as a deterministic function Dk(StateA,StateB)->(Dominated,FieldComparison,Witness), where Dk represents the k-th dominance decision template, StateA is the first certificate state to be compared, StateB is the second certificate state to be compared, Dominated is the Boolean result indicating whether a dominance relationship exists, FieldComparison is the comparison record of fields such as target value, remaining expandable set, constraint margin, combination invariant, and state upper bound, and Witness is the minimum replayable evidence for the dominance decision. Only when Dominated=True and the target value, remaining expandable set, constraint margin, combination invariant, and state upper bound recorded in FieldComparison all satisfy the preset dominance conditions will the system generate a dominance certificate and delete or discard the dominated state.

[0107] When the task to be solved, T, is a maximum coverage task, the dominance decision template set D is configured as follows: if two states have the same processing position and number of selected states, and the CoveredMask of the first state contains the CoveredMask of the second state, then the first state dominates the second state; where the first state is an existing state in the antichain frontier A or a state to be compared, StateA, and the second state is a new state q' or a state to be compared, StateB; when the first state comes from A and dominates q', q' is discarded; when q' dominates an existing state in A as the first state, the dominated existing state is deleted; the dominance certificate records the same processing position, the same number of selected states, and the inclusion relationship of CoveredMask;

[0108] The upper bound certificate generator sorts the remaining candidate objects in descending order of their marginal coverage gain relative to the current CoveredMask, and sums them up using the remaining number of options as the truncation length to obtain the BoundValue; if the BoundValue is not greater than the current best coverage gain, then the state is pruned.

[0109] When the task T to be solved is a weighted conflict selection task, the dominance decision template set D is configured as follows: if two states have the same set of candidate vertices, and the current cumulative weight of the first state is not less than the current cumulative weight of the second state, then the first state dominates the second state; the dominance certificate records the comparison result of the candidate vertex set hash and the cumulative weight; the upper bound certificate generator performs a deterministic clique cover or a greedy clique cover on the remaining conflict graph, and uses the sum of the maximum vertex weights in each clique as the upper bound of the independent set weights; if the sum of the current cumulative weight and the upper bound is not greater than the current optimal weight, then the state is pruned;

[0110] When the task T to be solved is a maximum coverage task with budget conflicts, the dominance decision template set D is configured as follows: if two states have the same processing position, the same number of selected states, and the same used budget, and the CoveredMask of the first state contains the CoveredMask of the second state, and the set of remaining expandable candidate objects of the first state contains the set of remaining expandable candidate objects of the second state, then the first state dominates the second state; where the first state is an existing state or a state to be compared, StateA, in the antichain frontier A, and the second state is a new state q' or a state to be compared, StateB; when the first state comes from A and dominates q', q' is discarded; when q' dominates an existing state in A as the first state, the dominated existing state is deleted; the dominance certificate records the processing position, the number of selected states, the used budget, the inclusion relationship of the set of remaining expandable candidate objects, and the inclusion relationship of CoveredMask; the upper bound certificate generator sorts the remaining candidate objects according to the ratio of marginal coverage benefit to cost, and performs fractional knapsack relaxation under the constraints of remaining budget and remaining optional quantity to obtain the upper bound of coverage benefit; if the upper bound of coverage benefit is not greater than the current optimal benefit, then the state is pruned;

[0111] When the task to be solved, T, is the maximum coverage task, the upper bound certificate generator is configured to: sort the remaining candidate objects in descending order of their marginal coverage gains relative to the current CoveredMask, sum them with the remaining number of options as the truncation length, and use the sum of the current coverage gain corresponding to the current CoveredMask and the summation result as the BoundValue; if the BoundValue is not greater than the current optimal coverage gain, then prune the state.

[0112] When a proposal is rejected, the violation of constraints, the minimum set of conflicting objects, and the repair action in the candidate rejection certificate are encoded as structured counterexamples, and the structured counterexamples are used as exclusion conditions, weighting conditions, or decomposition conditions for subsequent candidate generation.

[0113] A structured counterexample is represented as CounterExample=(FailedOp,FailedTargetIds,ViolatedConstraintId,MinimalConflictSet,ForbiddenPattern,RepairHint,TTL), where FailedOp is the failure operator identifier, FailedTargetIds is the set of failed target object identifiers, ViolatedConstraintId is the identifier of the violated constraint, MinimalConflictSet is the minimum set of conflicting objects that caused the failure, ForbiddenPattern is the pattern that should be avoided by subsequent candidates, RepairHint is the repair action hint, and TTL represents the effective round number of the counterexample in the subsequent candidate generation. When a subsequent proposal hits ForbiddenPattern, the system generates a fast rejection certificate before calling the deterministic combination validator, or reduces the extension priority of the proposal.

[0114] S8, when Q is empty and in complete solution mode, outputs the replayable optimal candidate x*, objective function value, certificate trajectory and state hash sequence; when the node budget or time budget is reached, outputs the current optimal candidate x* within the budget, objective function value, budget termination flag, certificate trajectory and state hash sequence, so that the third party can replay and verify the final combined solution and pruning process without calling the large model candidate generator again.

[0115] The certificate trace is stored as Trace=(CIRDigest,InitialStateHash,OrderedStateRecords,OrderedProposalRecords,OrderedCertificateRecords,IncumbentUpdateRecords,FinalSolutionRecord), where CIRDigest is the combined intermediate representation digest, InitialStateHash is the initial state hash, OrderedStateRecords are the state records arranged in replay order, OrderedProposalRecords are the candidate records arranged in generation order, OrderedCertificateRecords are the certificate records arranged in verification order, IncumbentUpdateRecords are the optimal candidate update records, and FinalSolutionRecord is the final combined solution record. During replay verification, the replayer only reads the Trace and CIR, and recalculates the state hash, constraint predicate, invariant difference, upper bound comparison, and dominance comparison according to the certificate order.

[0116] Example 2:

[0117] When the task T to be solved has a multi-objective function, w in Example 1 is represented as the objective vector and the deterministic comparator, the current best candidate x* is replaced by the Pareto candidate set, and the upper bound certificate and the dominance certificate record the comparison results relative to the Comparator or Pareto dominance relationship.

[0118] Example 3:

[0119] When multiple combined certificate grid states are expanded in parallel, state hash deduplication, certificate log appending, anti-chain front atomic merging, and comparison of the current best candidate version number are used; when two parallel branches generate the same state hash, only the state record with the smaller certificate trajectory lexicographical order or the objective function value is retained.

[0120] Example 4:

[0121] This embodiment provides a large-model verifiable combinatorial reasoning system based on combinatorial certificate lattices, based on embodiment 1, including:

[0122] The task normalization module is used to generate CIR=(E,O,C,I,w,K,B,D,H);

[0123] The certificate status module is used to initialize and update q=(S,R,F,v,b,P,h);

[0124] The candidate request module is used to construct candidate request records based on the state summary and the counterexample summary;

[0125] The large model candidate generation module is used to output machine-parseable proposals;

[0126] The schema verification module is used to verify the structure and scope of the Proposal.

[0127] The deterministic combination verification module is used to perform constraint predicates, invariant updates, upper bound certificate generation, and dominance determination.

[0128] The antichain front module is used to maintain a set of mutually non-dominant states;

[0129] The Counterexample feedback module is used to generate and apply CounterExamples;

[0130] The certificate log module is used to save the trace; the output module is used to output the combined solution, objective function value and replayable certificate trace.

[0131] Example 5:

[0132] This embodiment provides a computer program product, including a computer program or instructions, which, when executed by a processor, implement the method in Embodiment 1.

[0133] Example 6:

[0134] This embodiment provides a computer device, including a memory, a processor, and a computer program or instructions stored in the memory and executable by the processor, characterized in that the processor implements the method in Embodiment 1 when executing the computer program or instructions.

[0135] Example 7:

[0136] This embodiment provides a computer-readable storage medium storing a computer program or instructions thereon, characterized in that the computer program or instructions, when executed by a processor, implement the method in Embodiment 1.

[0137] Example 8:

[0138] In this embodiment, the method described in Embodiment 1 is also applicable to scenarios such as task scheduling, resource orchestration, path planning, set packaging, set coverage, graph partitioning, matching, vehicle routing, and multi-objective constraint selection.

[0139] The above description is merely a preferred embodiment of the present invention and is not intended to limit the present invention in any other way. Any modifications or equivalent changes made based on the technical essence of the present invention shall still fall within the scope of protection claimed by the present invention.

Claims

1. A large-model verifiable combinatorial reasoning method based on combinatorial certificate lattices, characterized in that, include: S1, Receive the task to be solved T, and construct the task to be solved T as a combined intermediate representation CIR=(E,O,C,I,w,K,B,D,H), where E is the set of basic elements, O is the set of candidate combined objects, C is the set of constraint predicates, I is the combination invariant and its update function, w is the objective function, K is the set of candidate expansion operators, B is the set of upper bound certificate generators, D is the set of dominance decision templates, and H is the normalized serialization and hashing rule; Each type of task to be solved is configured with a corresponding set of constraint predicates C, combination invariant I, set of upper bound certificate generators B, set of dominance decision templates D, and hashing rule H; S2, assign a stable object identifier to each candidate combination object in O, and generate at least one type of machine-resolvable load including coverage load, cost load, conflict load, resource load and ordering load; S3, initialize the combined certificate grid state q0=(S0,R0,F0,v0,b0,P0,h0), where S0 is an empty set of selected objects, R0 is the initial set of remaining candidate objects, F0 is an empty set of prohibited objects, v0=I(S0), b0 is calculated by B, P0 is an empty certificate set, and h0 is calculated by H after normalizing and serializing the state field; the current best candidate x* is initialized to an empty solution or a preset feasible solution, and the objective function value is initialized to w(x*) or a preset inferior value; S4, maintain the open state set Q, the anti-chain frontier A and the current best candidate x*. The combined certificate grid is composed of the certificate grid state set, the certificate set, the dominant partial order defined by D, the anti-chain frontier A and the state hash defined by H. Take out the state q to be expanded from Q, and generate an upper bound certificate and discard q when the upper bound b(q) of q is not greater than the objective function value of x*. S5, when q is not pruned by the upper bound, a candidate request record is constructed based on the canonical state summary, constraint summary, generated counterexamples, and candidate budget of q. The candidate request record is input into the large model candidate generator to obtain a finite number of machine-resolvable candidate proposals. In the complete solution mode, the deterministic candidate completer also generates candidate proposals that are not output by the large model candidate generator but are still within the scope based on K, R(q), F(q), and CIR. In the budget solution mode, the node budget, time budget, or candidate budget is written into the candidate request record and certificate track. S6, perform pattern verification on each proposal first; If the operator identifier of the proposal does not belong to K, the target object does not belong to R(q), the target object belongs to F(q), or the parameter type does not conform to CIR, then a candidate rejection certificate is generated. For proposals that pass the pattern validation, the deterministic combinatorial validator executes the constraint predicate in C, the invariant update function in I, the upper bound certificate generator in B, and the dominance decision template in D one by one to generate candidate acceptance certificates, candidate rejection certificates, upper bound certificates, dominance certificates, counterexamples, or optimal candidate update certificates. S7. When the proposal is accepted, a new state q' is generated. The antichain frontier A is used to determine whether q' is dominated by an existing state. If it is dominated, a domination certificate is generated and q' is discarded. If q' dominates an existing state in A, the dominated state is deleted and q' is written to A and Q. When a proposal is rejected, the violation of constraints, the minimum set of conflicting objects, and the repair action in the candidate rejection certificate are encoded as a structured counterexample, and the structured counterexample is used as the exclusion condition, weighting condition, or decomposition condition for subsequent candidate generation. S8, when Q is empty and in complete solution mode, outputs the replayable optimal candidate x*, objective function value, certificate trajectory and state hash sequence; when the node budget or time budget is reached, outputs the current optimal candidate x* within the budget, objective function value, budget termination flag, certificate trajectory and state hash sequence, so that the third party can replay and verify the final combined solution and pruning process without calling the large model candidate generator again.

2. The large-model verifiable combinatorial reasoning method based on combinatorial certificate lattices according to claim 1, characterized in that, The element record in the basic element set E is e=(ElementId,AttributeVector,Weight,GroupId), where ElementId is the stable identifier of the basic element, AttributeVector is the attribute vector of the basic element, Weight is the weight or benefit value of the basic element, and GroupId is the group identifier to which the basic element belongs. The object record in the candidate combination object set O is o=(ObjectId,ElementMask,CostVector,ConflictMask,ResourceVector,PrecedenceVector,ObjectPayload), where ObjectId is the stable identifier of the candidate combination object, ElementMask represents the basic element covered or affected by the object, CostVector represents the cost vector of the object, ConflictMask represents the object that cannot be selected together with the object, ResourceVector represents the resources consumed or released by the object, PrecedenceVector represents the order or dependency relationship of the object, and ObjectPayload represents the business payload of the object; Each constraint predicate Cj in the constraint predicate set C is represented as a deterministic function Cj(S,o,Args)->(Pass,ViolationCode,Witness), where Cj represents the j-th constraint predicate, S represents the currently selected object set, o represents the candidate object to be verified, Args represents the candidate extension parameters, Pass indicates whether the candidate satisfies the constraint, ViolationCode represents the constraint violation number, and Witness represents the minimum evidence used for replay verification; the deterministic combined verifier accepts the candidate only when all constraint predicates return Pass=True; The combined invariant and its update function I include at least one of the following: overlay mask, used budget, remaining budget, number of selected items, conflict disabling mask, connectivity summary, matching endpoint summary, rank function summary, and cumulative value of objective function; for an accepted candidate o, the update function generates a new invariant according to v'=Update(v,o,Args), and the difference between v and v' is recorded in the certificate.

3. The large-model verifiable combinatorial reasoning method based on combinatorial certificate lattices according to claim 1, characterized in that, The input to the large model candidate generator in S5 does not include the free-form search history, but includes StateSummary=(StateHash,SelectedIds,RemainingSummary,ForbiddenSummary,InvariantVector,BoundValue,IncumbentValue,ConstraintDigest,CounterExampleDigest,Budget), where StateHash is the hash value obtained by canonical serialization and hash calculation of the state field of the current state to be expanded q according to H, SelectedIds is the set of selected object identifiers in S(q), RemainingSummary is the compressed digest of R(q), ForbiddenSummary is the compressed digest of F(q), InvariantVector is the current combined invariant vector, BoundValue is the upper bound value of the state calculated by the upper bound certificate generator, and IncumbentValue is the objective function of the current best candidate. The numerical values ​​are: ConstraintDigest, which is a summary of the constraint predicate set C and its versions; CounterExampleDigest, which is a summary of the generated structured counterexample set; and Budget, which is the quantity budget, node budget, time budget, or token budget for this round of candidate generation. Furthermore, the large model candidate generator outputs Proposal=(ProposalId, OpId, TargetIds, Arguments, Priority, RationaleHash), where ProposalId is a unique identifier for the candidate, OpId is the identifier of the candidate expansion operator and belongs to K, TargetIds is the set of candidate combination object identifiers for this expansion, Arguments is the set of operator parameter key values, Priority is the candidate expansion priority, and RationaleHash is the hash value calculated by H from the large model's natural language reasoning or prompt context, and can be parsed by JSON, ProtocolBuffers, MessagePack, or a key-value field serialization format consisting of the above field names and values.

4. The large-model verifiable combinatorial reasoning method based on combinatorial certificate lattices according to claim 1, characterized in that, The candidate rejection certificate record contains CertType, StateHash, ProposalHash, ViolatedConstraintId, ViolationCode, MinimalWitness, RepairHint, and VerifierVersion. CertType is the certificate type, StateHash is the hash value obtained by serializing and hashing the state field of the verified state according to H, ProposalHash is the candidate hash value obtained by serializing and hashing the field name and field value of the Proposal according to H, ViolatedConstraintId is the identifier of the failed constraint, ViolationCode is the violation type code, MinimumWitness is the minimum replayable evidence, RepairHint is the candidate repair hint, and VerifierVersion is the deterministic composite verifier version. The candidate acceptance certificate records include CertType, StateHash, ProposalHash, AcceptedObjectIds, SatisfiedConstraintIds, OldInvariant, NewInvariant, DeltaValue, and ReplayParameters, where AcceptedObjectIds is the set of accepted object identifiers, SatisfiedConstraintIds is the set of constraint identifiers that have been satisfied, OldInvariant is the combined invariant before acceptance, NewInvariant is the combined invariant after acceptance, DeltaValue is the objective function increment, and ReplayParameters are the parameters required for replay verification. The upper bound certificate record contains CertType, StateHash, BoundGeneratorId, BoundValue, IncumbentValue, BoundPayload, and ComparisonResult. BoundGeneratorId is the identifier of the upper bound certificate generator, BoundValue is the target upper bound achievable by the current state, IncumbentValue is the current optimal candidate target value, BoundPayload is the upper bound computational load, and ComparisonResult is the deterministic comparison result between BoundValue and IncumbentValue. When ComparisonResult indicates that BoundValue is not greater than IncumbentValue, the state is pruned, and this pruning does not depend on the natural language interpretation output by the large model.

5. The large-model verifiable combinatorial reasoning method based on combinatorial certificate lattices according to claim 1, characterized in that, Each template Dk in the dominance decision template set D is represented as a deterministic function Dk(StateA,StateB)->(Dominated,FieldComparison,Witness), where Dk represents the k-th dominance decision template, StateA is the first certificate state to be compared, StateB is the second certificate state to be compared, Dominated is the Boolean result indicating whether a dominance relationship exists, FieldComparison is the comparison record of fields such as target value, remaining expandable set, constraint margin, combination invariant, and state upper bound, and Witness is the minimum replayable evidence for the dominance decision. Only when Dominated=True and the target value, remaining expandable set, constraint margin, combination invariant, and state upper bound recorded in FieldComparison all satisfy the preset dominance conditions will the system generate a dominance certificate and delete or discard the dominated state. When the task T to be solved is a maximum coverage task, the dominance determination template set D is configured as follows: if two states have the same processing position and selected quantity, and the CoveredMask of the first state contains the CoveredMask of the second state, then the first state dominates the second state; where the first state is an existing state in the antichain frontier A or a state to be compared, StateA, and the second state is a new state q' or a state to be compared, StateB; when the first state comes from A and dominates q', q' is discarded; when q' dominates an existing state in A as the first state, the dominated existing state is deleted; the dominance certificate records the same processing position, the same selected quantity, and the inclusion relationship of CoveredMask; When the task T to be solved is a weighted conflict selection task, the dominance determination template set D is configured as follows: if two states have the same set of candidate vertices, and the current cumulative weight of the first state is not less than the current cumulative weight of the second state, then the first state dominates the second state; the dominance certificate records the comparison result of the candidate vertex set hash and the cumulative weight. The upper bound certificate generator performs a deterministic clique cover or a greedy clique cover on the remaining conflict graph and uses the sum of the maximum vertex weights in each clique as the upper bound of the independent set weights; if the sum of the current cumulative weight and this upper bound is not greater than the current optimal weight, then the state is pruned. When the task T to be solved is a maximum coverage task with budget conflicts, the dominance decision template set D is configured as follows: if two states have the same processing position, the same number of selected states, and the same used budget, and the CoveredMask of the first state contains the CoveredMask of the second state, and the set of remaining expandable candidate objects of the first state contains the set of remaining expandable candidate objects of the second state, then the first state dominates the second state; where the first state is an existing state or a state to be compared, StateA, in the antichain frontier A, and the second state is a new state q' or a state to be compared, StateB; when the first state comes from A and dominates q', q' is discarded; when q' dominates an existing state in A as the first state, the dominated existing state is deleted; the dominance certificate records the processing position, the number of selected states, the used budget, the inclusion relationship of the set of remaining expandable candidate objects, and the inclusion relationship of CoveredMask; the upper bound certificate generator sorts the remaining candidate objects according to the ratio of marginal coverage benefit to cost, and performs fractional knapsack relaxation under the constraints of remaining budget and remaining optional quantity to obtain the upper bound of coverage benefit; if the upper bound of coverage benefit is not greater than the current optimal benefit, then the state is pruned; When the task to be solved, T, is the maximum coverage task, the upper bound certificate generator is configured to: sort the remaining candidate objects in descending order of their marginal coverage gains relative to the current CoveredMask, sum them with the remaining number of options as the truncation length, and use the sum of the current coverage gain corresponding to the current CoveredMask and the summation result as the BoundValue; if the BoundValue is not greater than the current optimal coverage gain, then prune the state.

6. The large-model verifiable combinatorial reasoning method based on combinatorial certificate lattices according to claim 1, characterized in that, The structured counterexample in S7 is represented as CounterExample=(FailedOp,FailedTargetIds,ViolatedConstraintId,MinimalConflictSet,ForbiddenPattern,RepairHint,TTL), where FailedOp is the failure operator identifier, FailedTargetIds is the set of failed target object identifiers, ViolatedConstraintId is the identifier of the violated constraint, MinimalConflictSet is the minimum set of conflicting objects that caused the failure, ForbiddenPattern is the pattern that subsequent candidates should avoid, RepairHint is the repair action hint, and TTL represents the effective round number of the counterexample in the subsequent candidate generation. When a subsequent Proposal hits ForbiddenPattern, the system generates a fast rejection certificate before calling the deterministic combination validator, or reduces the extension priority of the Proposal.

7. The large-model verifiable combinatorial reasoning method based on combinatorial certificate lattices according to claim 1, characterized in that, The certificate trace in S8 is stored as Trace=(CIRDigest,InitialStateHash,OrderedStateRecords,OrderedProposalRecords,OrderedCertificateRecords,IncumbentUpdateRecords,FinalSolutionRecord), where CIRDigest is the combined intermediate representation digest, InitialStateHash is the initial state hash, OrderedStateRecords are the state records arranged in replay order, OrderedProposalRecords are the candidate records arranged in generation order, OrderedCertificateRecords are the certificate records arranged in verification order, IncumbentUpdateRecords are the optimal candidate update records, and FinalSolutionRecord is the final combined solution record. During replay verification, the replayer only reads the Trace and CIR, and recalculates the state hash, constraint predicate, invariant difference, upper bound comparison, and dominance comparison according to the certificate order.

8. The large-model verifiable combinatorial reasoning method based on combinatorial certificate lattices according to claim 1, characterized in that, When the task T to be solved has a multi-objective function, w is represented as the objective vector and the deterministic comparator, the current best candidate x* is replaced by the Pareto candidate set, and the upper bound certificate and the dominance certificate record the comparison results relative to the Comparator or the Pareto dominance relationship. When multiple combined certificate grid states are expanded in parallel, state hash deduplication, certificate log appending, anti-chain front atomic merging, and comparison of the current best candidate version number are used; when two parallel branches generate the same state hash, only the state record with the smaller certificate trajectory lexicographical order or the objective function value is retained. The task T to be solved includes at least one of the following: maximum coverage, maximum coverage with budget, maximum coverage with conflict, weighted independent set, set packing, set coverage, matching, path selection, graph partitioning, task allocation, resource allocation, vehicle routing, job scheduling, and multi-objective constraint selection; for the task T to be solved, C, I, B, D, and H corresponding to the task are pre-configured.

9. A large-model verifiable combinatorial reasoning system based on a combinatorial certificate lattice, for implementing the method as described in any one of claims 1-8, characterized in that, include: The task normalization module is used to generate CIR=(E,O,C,I,w,K,B,D,H); The certificate status module is used to initialize and update q=(S,R,F,v,b,P,h); The candidate request module is used to construct candidate request records based on the state summary and the counterexample summary; The large model candidate generation module is used to output machine-parseable proposals; The schema verification module is used to verify the structure and scope of the Proposal. The deterministic combination verification module is used to perform constraint predicates, invariant updates, upper bound certificate generation, and dominance determination. The antichain front module is used to maintain a set of mutually non-dominant states; The Counterexample feedback module is used to generate and apply CounterExamples; The certificate log module is used to save the trace; the output module is used to output the combined solution, objective function value and replayable certificate trace.

10. A computer program product, comprising a computer program or instructions, characterized in that, When the computer program or instructions are executed by a processor, they implement the method described in any one of claims 1-8.

Images