Method and system for generating and verifying multi-jurisdictional salary calculation criteria based on large models

Abstract

The application provides a large model-based multi-jurisdiction salary calculation standard generation and verification method and system, including: preprocessing based on salary regulation data to obtain unified structured salary regulation data; generating a candidate salary standard object based on the unified structured salary regulation data and a preset output constraint using a large model; verifying based on the candidate salary standard object; performing a trial calculation on the candidate salary standard object based on a preset sample wage; generating feedback data based on the deterministic verification result, the probe pass rate, and the actual execution deviation and correction record of the historical published salary standard object; calculating the confidence based on the deterministic verification result, the trial calculation result, and the feedback data, and judging the candidate salary standard object based on the confidence score and the trial calculation result to obtain a verified candidate salary standard object; calling the corresponding salary calculation standard to perform salary calculation; and when the actual execution deviation meets a preset trigger rollback condition, rolling back to the last published version of the salary standard object.

Description

Technical Field

[0001] This application belongs to the field of artificial intelligence technology and relates to a method and system for generating and verifying multi-domain salary calculation standards based on a large model. Background Technology

[0002] With the development of cross-border and multi-jurisdictional employment models, it has become a common business need for companies to conduct employment, payroll, taxation, and social security contributions in multiple countries or regions. Due to significant differences between different jurisdictions in areas such as individual income tax rate structures, social security contribution bases, employer contribution rates, pre-tax deductions, payment frequency, statutory benefits, and effective date rules, the generation and verification of multi-jurisdictional payroll calculation rules have long relied on local payroll experts or external service providers for manual interpretation and rule maintenance of regulatory texts.

[0003] In existing technologies, common solutions include: manual updates of payroll rules by operations personnel based on government announcements; maintenance of tax and social security parameters using static templates; generation of summaries, question-and-answer, or explanatory data from regulatory texts using general large language models; or translation of some business rules into code using a general rule engine. These solutions typically have the following problems:

[0004] First, the interpretation of regulations and the translation of rules rely heavily on the experience of distributed experts, and it is difficult to maintain consistent translation standards among different countries, teams, and service providers.

[0005] Second, there is a significant time lag between the release, implementation, entry, and launch of regulations, which can easily lead to overlap of old and new rules, omissions of rules, and incorrect setting of effective time.

[0006] Third, although general-purpose large language models can generate candidate content from regulatory texts, their output structure is unstable and the probability of missing fields is high, making it difficult to directly form executable salary rules.

[0007] Fourth, relying solely on textual understanding to manually review candidate rules makes it difficult to detect deviations at the implementation level, such as errors in tax tiers, social security cap boundaries, currency conversion errors, or abnormal year-to-date cumulative values.

[0008] Fifth, the rules already implemented lack a feedback loop that links with the actual salary execution results. When deviations occur, they usually rely on manual review and manual rollback, which is inefficient and the audit trail is incomplete. Summary of the Invention

[0009] This application provides a method and system for generating and verifying multi-domain salary calculation standards based on a large model, which solves the problem of low efficiency in salary calculation caused by excessive reliance on manual labor in the existing technology.

[0010] Firstly, this application provides a method for generating and verifying multi-jurisdictional salary calculation standards based on a large model. The method includes: acquiring salary regulation data for the target jurisdiction; the salary regulation data includes regulation text data, regulation source data, effective date data, and / or version identifier data; preprocessing the salary regulation data to obtain unified structured salary regulation data; the unified structured salary regulation data is the clause structured data of a unified salary standard model; generating candidate salary standard objects conforming to the unified salary standard model using a large model based on the unified structured salary regulation data and preset output constraints; the preset output constraints can constrain the candidate salary standard objects to trace back to the original source clauses; performing deterministic verification on the candidate salary standard objects to obtain deterministic verification results; the deterministic verification includes model integrity verification, source index verification, effective interval overlap verification, conflict matrix verification, and / or historical version difference verification; and performing trial calculations on the candidate salary standard objects based on preset sample wages to obtain trial calculation results, the trial calculation results including probe pass rate and resistance. The number of interruption failures is counted. Feedback data is generated based on the deterministic verification results, the probe pass rate, and the actual execution deviations and correction records of historically published salary standard objects. This feedback data is then returned to the candidate salary standard object generation step for subsequent candidate salary standard object generation. Confidence is calculated based on the deterministic verification results, the trial calculation results, and the feedback data to obtain the confidence score of the candidate salary standard object. The status of the candidate salary standard object is then judged based on the confidence score, the probe pass rate, and the number of interruption failures to obtain verified candidate salary standard objects. Based on the verified candidate salary standard objects, the corresponding salary calculation standard is called to perform salary calculation. During salary calculation, actual execution deviations and correction records are collected in real time. When the actual execution deviation meets the preset trigger rollback conditions, the process rolls back to the previous published version of the salary standard object, records the rollback result, and uses it as feedback data for the next round of candidate salary standard object generation. The rollback result includes the rollback reason, rollback time, scope of impact, and related salary slip identifiers.

[0011] In one implementation of the first aspect, preprocessing the salary regulation data to obtain unified structured salary regulation data includes: performing clause segmentation, field extraction, and semantic normalization on the salary regulation data to generate clause structured data corresponding to the unified salary standard model; wherein, the unified structured salary regulation data includes at least clause number, clause category, variable name, scope of application, effective conditions, source index, original text fragment, and semantic tags; the unified salary standard model includes at least the legal domain identifier, rule category, applicable object, income item, deduction item, tax rate item, social security item, effective start and end time, calculation base, currency, rounding method, and priority field.

[0012] In one implementation of the first aspect, the preset output constraints include fixed field templates, field type constraints, field mandatory constraints, field dependency constraints, source reference constraints, and numerical range constraints.

[0013] In one implementation of the first aspect, the schema integrity check is used to verify whether the candidate salary standard object conforms to the field integrity, field type compliance, and inter-field logical constraints defined by the unified salary standard schema; the source index check is used to verify whether the source reference of the candidate salary standard object that has passed the schema integrity check can be traced back to the original legal clause; wherein the source reference field in the candidate salary standard object that has passed the schema integrity check has passed the field existence and format correctness verification; the effective interval overlap check is used to, based on the candidate salary standard object that has passed the schema integrity check, check multiple candidate salary standards with the same legal domain identifier, rule category, and applicable object. The effective start and end times of candidate salary standard objects are overlapped. The legal domain identifier, rule category, applicable object, and effective start and end time fields in the candidate salary standard objects that have passed the pattern integrity verification have passed format validation. The conflict matrix verification is used to further compare the parameter ranges and priorities of each candidate salary standard object within the same group based on the overlapping rule pairs output by the effective interval overlap verification, to identify mutually exclusive rules, duplicate rules, and overriding rules. The historical version difference verification is used to verify the differences in key fields between the candidate salary standard objects that have passed the pattern integrity verification and the previously published candidate salary standard objects, and to determine whether the differences conform to the range of changes described in the source clause. Mutually exclusive rules refer to candidate salary standard objects with the same priority but conflicting rule logic within the same effective interval and parameter range; duplicate rules refer to candidate salary standard objects with completely identical effective intervals, parameter ranges, and priorities; and overriding rules refer to candidate salary standard objects whose effective intervals have an inclusion relationship but differ in priority.

[0014] In one implementation of the first aspect, the preset sample salary includes at least basic salary, allowances, bonuses, pre-tax deductions, social security base, currency, payment frequency, and identity parameters. The process of performing a trial calculation on the candidate salary standard object based on the preset sample salary to obtain the probe pass rate and the number of blocking failures includes: performing a trial calculation on the candidate salary standard object based on the preset sample salary to obtain the trial calculation result; comparing the trial calculation result with the preset result item by item and calculating the probe pass rate and the number of blocking failures; wherein, the probe pass rate is the ratio of the number of sample salaries that passed the trial calculation to the total number of sample salaries in the preset sample salary, and the number of blocking failures is the number of failed sample salaries that caused the calculation process to terminate.

[0015] In one implementation of the first aspect, calculating the confidence score of the candidate salary standard object based on the deterministic verification result, the trial calculation result, and the feedback data includes: calculating the confidence score of the candidate salary standard object based on the weight scores of each verification item in the deterministic verification result, the regression probe weight scores in the trial calculation result, and the historical operational stability weight scores in the feedback data. The formula for calculating the confidence score is: C = w1×Ssource + w2×Sschema + w3×Sconflict + w4×Sprobe + w5×Sdiff + w6×Sruntime; where C represents the confidence score, Ssource represents the source credibility score, Sschema represents the schema integrity score, Sconflict represents the conflict verification score, Sprobe represents the regression probe score, Sdiff represents the version difference rationality score, Sruntime represents the historical running stability score, and w1-w6 represent the corresponding weights, and the sum of w1 to w6 is 1 or normalized.

[0016] In one implementation of the first aspect, determining the status of the candidate salary standard object based on the confidence score, the probe pass rate, and the number of blocking failures to obtain a verified candidate salary standard object includes: if the number of blocking failures is greater than 0, marking the candidate salary standard object as a verification failure state; if the confidence score is greater than or equal to a first confidence threshold and the probe pass rate is greater than or equal to a preset release pass rate threshold, marking the candidate salary standard object as a release state; if the confidence score is less than the first confidence threshold but greater than or equal to a second confidence threshold, marking the candidate salary standard object as a test state; if the confidence score is less than the second confidence threshold, marking the candidate salary standard object as a draft state; and using the candidate salary standard object in the release state as a verified candidate salary standard object.

[0017] In one implementation of the first aspect, the process of invoking the corresponding salary calculation standard based on the verified candidate salary standard object to perform salary calculation includes: invoking the corresponding salary calculation standard based on the verified candidate salary standard object; performing salary calculation on the salary calculation data to be processed based on the salary calculation standard to obtain actual salary data; the actual salary data includes at least pre-tax salary, taxable salary, individual income tax, employee social security, employer social security, after-tax salary and / or cumulative value from the beginning of the year to date; performing hash processing on the verified candidate salary standard object to generate a corresponding rule snapshot hash, and saving the verified candidate salary standard object, the rule snapshot hash and the actual salary data.

[0018] In one implementation of the first aspect, the preset trigger rollback condition includes: DeviationRate > D_max or CriticalSlipMismatchCount ≥ N_max, where DeviationRate represents the actual execution deviation rate; D_max represents the maximum allowable deviation threshold; CriticalSlipMismatchCount represents the number of critical payroll mismatches; and N_max represents the critical payroll mismatch number threshold.

[0019] Secondly, this application provides a multi-jurisdictional salary calculation standard generation and verification system based on a large model. The system includes: a regulatory data acquisition module configured to acquire salary regulatory data for a target jurisdiction; the salary regulatory data includes regulatory text data, regulatory source data, effective date data, and / or version identifier data; a preprocessing module configured to preprocess the salary regulatory data to obtain unified structured salary regulatory data; the unified structured salary regulatory data is clause structured data of a unified salary standard model; and a candidate rule generation module configured to generate rules based on the unified structured salary regulatory data. Based on the preset output constraints, a large model is used to generate candidate salary standard objects that conform to the unified salary standard pattern. The preset output constraints can constrain the candidate salary standard objects to trace back to the original source clauses. A deterministic verification module is configured to perform deterministic verification based on the candidate salary standard objects and obtain the deterministic verification results. The deterministic verification includes pattern integrity verification, source index verification, effective interval overlap verification, conflict matrix verification, and / or historical version difference verification. A trial calculation module is configured to perform trial calculations on the candidate salary standard objects based on preset sample salaries to obtain probe pass rate and blocking failure rate. The quantity; the feedback optimization module is configured to generate feedback data based on the deterministic verification result, the probe pass rate, and the actual execution deviation and correction records of historically published salary standard objects, and return the feedback data to the candidate salary standard object generation step for subsequent candidate salary standard object generation; the confidence calculation and status judgment module is configured to perform confidence calculation based on the deterministic verification result, the trial calculation result, and the feedback data, obtain the confidence score of the candidate salary standard object, and adjust the candidate salary standard according to the confidence score, the probe pass rate, and the number of blocking failures. The system performs a status check on the object to obtain verified candidate salary standard objects. A deterministic execution module is configured to call the corresponding salary calculation standard to perform salary calculation based on the verified candidate salary standard objects. An automatic rollback module is configured to collect actual execution deviations and correction records in real time during salary calculation. When the actual execution deviation meets preset rollback trigger conditions, it rolls back to the previous published version of the salary standard object, records the rollback result, and uses it as feedback data for the generation of the next round of candidate salary standard objects. The rollback result includes the rollback reason, rollback time, scope of impact, and related salary slip identifiers.

[0020] Thirdly, this application provides an electronic device, which includes: a memory storing a computer program; and a processor communicatively connected to the memory, which executes the above-described method for generating and verifying multi-domain salary calculation standards based on a large model when the computer program is invoked.

[0021] Fourthly, this application provides a computer-readable storage medium storing a computer program thereon, which, when executed by a processor, implements the above-described method for generating and verifying multi-domain salary calculation standards based on a large model.

[0022] As described above, the method and system for generating and verifying multi-domain salary calculation standards based on a large model, as described in this application, have the following beneficial effects:

[0023] This application obtains unified structured salary regulation data by preprocessing salary regulation data from the target jurisdiction, and then constrains this unified structured salary regulation data using preset output constraints and a large model. This enables the original regulatory text to be stably converted into candidate salary standard objects that conform to a unified pattern. These candidate salary standard objects can be traced back to their original source clauses, reducing reliance on the experience of a single expert. This is particularly suitable for salary rule processing scenarios involving multiple jurisdictions, currencies, payment frequencies, and frequent regulatory updates, and can alleviate the inefficiency caused by the uneven distribution of salary expert capabilities across multiple jurisdictions. This application also addresses the issues of effective intervals, rule conflicts, and historical data. This application automatically verifies version differences, enabling the detection of potential conflicts and structural anomalies before rules go live; by performing sample salary calculations on candidate rules, it can identify salary calculation deviations that cannot be detected at the text level before actual payroll; by issuing candidate rules in a tiered manner, this application prevents unverified rules from directly entering the actual execution process; by collecting and automatically rolling back execution deviations, this application can form a closed-loop feedback mechanism for rule generation, verification, execution, and rollback; by saving rule versions, rule snapshot hashes, input summaries, output summaries, and year-to-date cumulative values, this application can improve the system's audit traceability. Attached Figure Description

[0024] Figure 1 The diagram shows a hardware application scenario of the method for generating and verifying multi-domain salary calculation standards based on a large model as described in the embodiments of this application.

[0025] Figure 2 The diagram shows a flowchart of the method for generating and verifying multi-domain salary calculation standards based on a large model, as described in an embodiment of this application.

[0026] Figure 3 The flowchart shown is a process for candidate rule generation, deterministic verification, and tiered release as described in the embodiments of this application.

[0027] Figure 4 The diagram shows a flowchart of the regression probe trial calculation and probe pass rate calculation as described in the embodiments of this application.

[0028] Figure 5 The flowchart shown is a closed-loop process diagram of runtime monitoring, automatic rollback, and feedback as described in the embodiments of this application.

[0029] Figure 6 The diagram shown is a structural schematic of the multi-domain salary calculation standard generation and verification system based on a large model as described in this application embodiment.

[0030] Figure 7 The diagram shown is a structural schematic of the electronic device described in an embodiment of this application. Detailed Implementation

[0031] The following specific examples illustrate the implementation of this application. Those skilled in the art can easily understand other advantages and effects of this application from the content disclosed in this specification. This application can also be implemented or applied through other different specific embodiments, and various details in this specification can also be modified or changed based on different viewpoints and applications without departing from the spirit of this application. It should be noted that, unless otherwise specified, the following embodiments and features in the embodiments can be combined with each other.

[0032] It should be noted that the illustrations provided in the following embodiments are only schematic representations of the basic concept of this application. Therefore, the drawings only show the components related to this application and are not drawn according to the actual number, shape and size of the components in the actual implementation. In the actual implementation, the form, quantity and proportion of each component can be arbitrarily changed, and the layout of the components may also be more complex.

[0033] The following embodiments of this application provide a method and system for generating and verifying multi-domain salary calculation standards based on a large model, which solves the problem of low efficiency in salary calculation caused by excessive reliance on manual labor in the prior art.

[0034] like Figure 1 As shown in the diagram, this embodiment provides a hardware application scenario illustration of a method for generating and verifying multi-domain salary calculation standards based on a large model. The multi-agent collaborative system is deployed on at least one server or in a cloud computing environment, specifically including: a data acquisition layer for acquiring regulatory texts, policy announcements, source metadata, and manual correction records; an agent collaboration layer for enabling the collaborative operation of a regulatory acquisition agent, a clause structuring agent, a candidate rule generation agent, a deterministic verification agent, a regression probe agent, a feedback optimization agent, a release decision agent, and a runtime monitoring feedback agent; a rule storage layer for storing candidate salary standard objects, release status rules, historical version rules, and feedback logs; an execution layer for performing salary calculations through a deterministic gross-to-net computing engine; and an audit trail layer for recording rule versions, rule snapshot hashes, input summaries, output summaries, and cumulative values.

[0035] The regulatory acquisition agent is used to retrieve regulatory and policy information from official legal databases, government announcement websites, tax and social security agency guidelines, FAQ documents, historical rule source snapshots, and manual correction records.

[0036] The clause-structured intelligent agent is used to clean, standardize, segment, extract fields, and normalize semantics of the acquired regulatory text to form clause-structured data.

[0037] The candidate rule generation agent is used to call the large language model based on a unified salary standard pattern and preset output constraints to generate candidate salary standard objects.

[0038] The deterministic verification agent is used to perform schema integrity verification, effective interval overlap verification, rule conflict matrix verification, historical version difference verification, and source index integrity verification on candidate salary standard objects.

[0039] The regression probe agent is used to perform salary calculations on candidate salary standard objects based on a pre-defined sample salary input vector in order to obtain the probe pass rate and the number of blocking failures at the execution level.

[0040] The feedback optimization agent is used to generate feedback data based on the deterministic verification results, regression probe results, actual execution deviations, and manually corrected reflux data, and then return the feedback data to the candidate rule generation agent.

[0041] The decision-making agent is used to calculate rule confidence based on source credibility, structural integrity, conflict verification results, regression probe results, and feedback data, and to mark candidate salary standard objects as draft, test, release, or verification failure states according to preset thresholds.

[0042] A deterministic gross-to-net computation engine used to invoke validated rules to perform payroll calculations in actual payroll tasks.

[0043] The runtime monitoring and feedback agent is used to collect actual execution deviations, manual correction records, and version switching results, and feed these results back to the feedback optimization process and the candidate rule generation process.

[0044] This application proposes a novel multi-jurisdictional salary calculation rule generation and verification scheme, which enables regulatory texts to be stably transformed into executable salary standard objects. Through automated verification, sample regression, hierarchical release, execution monitoring, and rollback feedback, a technical closed loop is formed, thereby reducing the reliance on salary experts whose manpower is unevenly distributed across multiple jurisdictions and improving the stability of rule deployment and the accuracy of salary calculation.

[0045] The technical solutions in the embodiments of this application will be described in detail below with reference to the accompanying drawings.

[0046] like Figure 2 As shown in the figure, this embodiment provides a method for generating and verifying multi-domain salary calculation standards based on a large model. The method includes the following steps S201 to S209.

[0047] Step S201: Obtain salary regulations data for the target jurisdiction; the salary regulations data includes regulations text data, regulations source data, effective date data and / or version identifier data.

[0048] In some embodiments, this application utilizes a regulatory acquisition agent to obtain salary regulation data of a target legal domain; the salary regulation data includes regulatory text data, regulatory source data, effective date data, and / or version identifier data.

[0049] Step S202: Preprocess the salary regulation data to obtain unified structured salary regulation data; the unified structured salary regulation data is the clause structured data of the unified salary standard model.

[0050] In some embodiments, this application utilizes a clause-structured intelligent agent to preprocess the salary regulation data to obtain unified structured salary regulation data; the unified structured salary regulation data is clause-structured data of a unified salary standard model.

[0051] Step S203: Based on the unified structured salary regulations data and preset output constraints, a large model is used to generate candidate salary standard objects that conform to the unified salary standard pattern. The preset output constraints can ensure that the candidate salary standard objects are traceable back to the original source clauses.

[0052] In some embodiments, this application utilizes a candidate rule generation agent to generate candidate salary standard objects that conform to the unified salary standard pattern based on the unified structured salary regulations data and preset output constraints using a large model.

[0053] Step S204: Perform deterministic verification based on the candidate salary standard object and obtain the deterministic verification result. The deterministic verification includes schema integrity verification, source index verification, effective interval overlap verification, conflict matrix verification, and / or historical version difference verification.

[0054] In some embodiments, this application utilizes a deterministic verification agent to perform deterministic verification based on the candidate salary standard object and obtains the deterministic verification result.

[0055] Step S205: Perform a trial calculation on the candidate salary standard object based on the preset sample salary, and obtain the trial calculation results, which include the probe pass rate and the number of blocking failures.

[0056] In some embodiments, this application utilizes a regression probe agent to perform trial calculations on the candidate salary standard object based on preset sample wages, and obtains the trial calculation results, which include probe pass rate and number of blocking failures.

[0057] Step S206: Based on the deterministic verification result, the probe pass rate, and the actual execution deviation and correction records of historically published salary standard objects, generate feedback data and return the feedback data to the candidate salary standard object generation step for subsequent candidate salary standard object generation.

[0058] In some embodiments, this application utilizes a feedback optimization agent to generate feedback data based on the deterministic verification result, the probe pass rate, and the actual execution deviation and correction records of historically published salary standard objects, and returns the feedback data to the candidate salary standard object generation step for subsequent candidate salary standard object generation.

[0059] Step S207: Calculate the confidence score based on the deterministic verification result, the trial calculation result, and the feedback data to obtain the confidence score of the candidate salary standard object. Then, determine the status of the candidate salary standard object based on the confidence score, the probe pass rate, and the number of blocking failures to obtain the candidate salary standard object that has passed the verification.

[0060] In some embodiments, this application utilizes a decision-making agent to calculate confidence based on the deterministic verification result, the trial calculation result, and the feedback data to obtain the confidence score of the candidate salary standard object, and to determine the status of the candidate salary standard object based on the confidence score, the probe pass rate, and the number of blocking failures, thereby obtaining the candidate salary standard object that has passed verification.

[0061] Step S208: Based on the verified candidate salary standard object, call the corresponding salary calculation standard to perform salary calculation.

[0062] In some embodiments, this application utilizes a deterministic computation engine to perform salary calculations based on the verified candidate salary standard objects and invoking the corresponding salary calculation standards. The deterministic computation engine is the deterministic gross-to-net computation engine described in the above embodiments.

[0063] Step S209: When performing salary calculation, collect actual execution deviations and correction records in real time. When the actual execution deviation meets the preset trigger rollback conditions, rollback to the previous published version of the salary standard object, record the rollback result and use it as feedback data for the generation of the next round of candidate salary standard objects. The rollback result includes the rollback reason, rollback time, scope of impact and related salary slip identifier.

[0064] In some embodiments, when performing salary calculation, a runtime monitoring feedback agent is used to collect actual execution deviations and correction records in real time. When the actual execution deviation meets the preset trigger rollback conditions, the system rolls back to the previous published version of the salary standard object, records the rollback result, and uses it as feedback data for the generation of the next round of candidate salary standard objects. The rollback result includes the rollback reason, rollback time, scope of impact, and related salary slip identifier.

[0065] This application leverages the collaboration of a regulatory acquisition agent, a clause structuring agent, and a candidate rule generation agent to stably convert original regulatory texts into candidate salary standard objects conforming to a unified pattern, reducing reliance on the experience of a single expert. A deterministic verification agent automatically verifies effective periods, rule conflicts, and historical version differences, enabling the detection of potential conflicts and structural anomalies before rules go live. A regression probe agent performs sample salary calculations on candidate rules, identifying salary calculation deviations that cannot be detected at the text level before actual payroll. Finally, a release decision agent hierarchically releases candidate rules, preventing unverified rules from directly entering the actual execution process.

[0066] In some embodiments, this application utilizes a regulatory acquisition agent to retrieve documents from official regulatory websites, tax bureau announcement websites, social security authority websites, and internal regulatory archives. Each document includes at least the following metadata: document source identifier, document publication date, document effective date, document expiration date, document version number, original language, and acquisition timestamp.

[0067] In some embodiments, this application utilizes a clause-structured intelligent agent to perform the following processing on the document: removing headers, footers, and irrelevant formatting information; performing language detection; performing text standardization; segmenting clauses based on clause number, title, and semantic boundaries; identifying tax rate ranges, social security bases, applicable objects, income types, effective dates, and priority information; and forming clause-structured data.

[0068] In one embodiment of this application, preprocessing the salary regulation data to obtain unified structured salary regulation data includes step S2021: performing clause segmentation, field extraction, and semantic normalization processing based on the salary regulation data to generate clause structured data corresponding to the unified salary standard pattern.

[0069] The unified structured salary regulations data includes at least the clause number, clause category, variable name, scope of application, effective conditions, source index, original text fragment, and semantic tags;

[0070] The unified salary standard model includes at least the following fields: jurisdiction identifier, rule category, applicable object, income item, deduction item, tax rate item, social security item, effective start and end time, calculation base, currency, rounding method, priority field, region identifier, source reference, parameter object, rule status, rule version and / or rule confidence. Table 1 shows the unified salary standard model described in the embodiments of this application.

[0071] Table 1

[0072] field name type Required illustrate jurisdiction String yes Jurisdiction identifiers, such as SG, US, CN region String no Area identifiers, such as CA, NY ruleCategory Enum yes Rule categories: income_tax / Social_insurance workerType Enum yes Applicable to: employees / contractors incomeltemType Enum yes Income item type: base_salary / bonus deductionltemType Enum no Deduction Item Types taxBasisType Enum yes Tax base type: annualized / monthly social insurance Basis Type Enum no Social security base types effectiveFrom Date yes Effective start time effectiveTo Date no Effective and termination dates, null indicates continued validity. currency String yes Currencies: SGD, USD, CNY roundingMode Enum yes Rounding method: HALF_UP / FLOOR priority Integer yes Priority, the higher the value, the higher the priority. parameters Object yes Rule parameter objects (tax rate tiers, base cap, etc.) sourceRefs Array yes Source Citation List status Enum yes Rule status: draft / testing / published confidence Float yes Rule confidence [0, 1] version String yes Rule version number

[0073] As shown in Table 1, the unified salary standard model in this application is represented by structured objects, for example:

[0074] {

[0075] "jurisdiction": "SG",

[0076] "region": null,

[0077] "ruleCategory": "income_tax",

[0078] "workerType": "employee",

[0079] "incomeItemType": "base_salary",

[0080] "deductionItemType": "pre_tax_deduction",

[0081] "taxBasisType": "annualized",

[0082] "socialInsuranceBasisType": "monthly_capped_wage",

[0083] "effectiveFrom": "20XX-XX-XX",

[0084] "effectiveTo": null,

[0085] "currency": "SGD",

[0086] "roundingMode": "HALF_UP",

[0087] "priority": 10,

[0088] "parameters": {

[0089] "bands": [

[0090] { "start": 0, "end": 20000, "rate": 0.00},

[0091] { "start": 20000, "end": 30000, "rate": 0.02}

[0092] ],

[0093] "cap": null

[0094] },

[0095] "sourceRefs": [

[0096] { "sourceId": "gazette-20XX-XX-XX", "clauseId": "sec-8-2"}

[0097] ],

[0098] "status": "draft",

[0099] "confidence": 0.0,

[0100] "version": "20XX.XX.XX.1"

[0101] }

[0102] The functions of each field in the structured object of the unified salary standard pattern described above are explained below:

[0103] "jurisdiction" indicates the jurisdiction identifier field, which is used to identify the country or region to which the candidate salary standard object applies. It is encoded using the ISO 3166-1 alpha-2 standard, for example, "SG" represents Singapore.

[0104] "region" represents the region identifier field, which is used to identify the sub-region of the candidate salary standard object within the jurisdiction. This field is null when the rule applies to the entire jurisdiction.

[0105] "ruleCategory" represents the rule category field, which identifies the rule type of the candidate salary standard object. For example, "income_tax" represents the personal income tax rule. Other optional values ​​include employee_social_insurance, employee_social_insurance, and pre_tax_deduction.

[0106] "workerType" indicates the applicable object field, which identifies the type of employee to which the rule applies. For example, "employee" indicates a full-time employee, and other optional values ​​include contractor and intern.

[0107] "incomeItemType" indicates the income item type field, which is used to identify the type of income item to which the rule applies. For example, "base_salary" indicates the basic salary. Other optional values ​​include bonus and allowance.

[0108] "deductionItemType" indicates the deduction item type field, which is used to identify the type of deduction item to which the rule applies. For example, "pre_tax_deduction" indicates pre-tax deduction items.

[0109] "taxBasisType" indicates the tax base type field, which is used to identify the tax base method used by the rule. For example, "annualized" indicates annualized taxation. Other optional values ​​include monthly and cumulative_ytd.

[0110] "socialInsuranceBasisType" indicates the social security base type field, which is used to identify the social security contribution base method adopted by the rule. For example, "monthly_capped_wage" means that the social security base is calculated based on the monthly capped wage.

[0111] "effectiveFrom" indicates the effective start date field, which identifies the date on which the rule begins to take effect. It uses the ISO 8601 date format, for example, "20XX-XX-XX" means 20XX year XX month XX day;

[0112] "effectiveTo" represents the effective end date field, which is used to identify the date on which the rule will stop being effective. When the rule continues to be effective and no end date is set, this field is null.

[0113] "currency" indicates the currency field, which identifies the currency type to which the rules apply. It uses the ISO 4217 standard encoding, for example, "SGD" represents Singapore Dollar.

[0114] "roundingMode" indicates the rounding mode field, which is used to identify how the rules round the numbers in the salary calculation process. For example, "HALF_UP" means rounding to the nearest whole number.

[0115] "priority" indicates the priority field, which is used to determine the execution priority order of candidate salary standard objects when there are multiple candidate salary standard objects under the same legal domain, the same rule category, and the same applicable object. The larger the value, the higher the priority. For example, 10 indicates that the candidate salary standard object has a relatively high priority among the candidate salary standard objects in the same group.

[0116] "parameters" indicates the parameter object field, used to store the specific calculation parameters of the candidate salary standard object, including two sub-fields: bands and cap. Bands is an array of tax rate ranges, each range containing three fields: start (range start value), end (range end value), and rate (applicable tax rate). For example, {"start": 0, "end": 20000,"rate": 0.00} indicates that the applicable tax rate is 0% for incomes between 0 and 20000, and {"start": 20000, "end": 30000, "rate": 0.02} indicates that the applicable tax rate is 2% for incomes between 20000 and 30000. Cap is the cap value field, used to set the upper limit of the calculation base; it is null when there is no cap.

[0117] "sourceRefs" represents an array of source references, used to record the original regulatory clauses corresponding to the candidate salary standard object. Each source reference contains two fields: sourceId (source document identifier) ​​and clauseId (clause identifier). For example, {"sourceId": "gazette-20XX-XX-XX", "clauseId": "sec-8-2"} indicates that the rule originates from Article 8, Paragraph 2 of the Gazette issued on XX / XX / 20XX, used to achieve traceability from the rule to the original regulation.

[0118] "status" represents the rule status field, which is used to identify the current verification status of the candidate salary standard object. Optional values ​​include draft, testing, published, and failed. For example, "draft" means that the candidate salary standard object is still in the draft state and has not undergone a complete verification process.

[0119] "confidence" refers to the confidence score field, which records the comprehensive confidence score calculated by the decision-making agent. The value ranges from 0.0 to 1.0, with an initial state of 0.0. After deterministic verification, regression probe calculation, and feedback data processing, it is updated to the actual calculated value.

[0120] "version" indicates the rule version field, which is used to identify the version number of the candidate salary standard object. It adopts the format "date.serial number", for example, "20XX.XX.XX.1" indicates the first version generated on XX month XX day of 20XX year. When multiple versions are generated on the same day, the serial number is incremented.

[0121] In this embodiment, the application uses candidate rules to generate an agent that outputs candidate salary standard objects that conform to the unified salary standard pattern, and does not allow the output of free text that cannot be parsed.

[0122] Figure 3 The flowchart shown is a process for candidate rule generation, deterministic verification, and tiered release as described in the embodiments of this application. Figure 3 As shown, in some embodiments, this application utilizes a candidate rule generation agent to construct a context based on structured data of terms, historically valid rules, and a unified salary standard pattern, and calls a large language model to generate candidate salary standard objects. The pseudocode for the candidate rule generation process is as follows:

[0123] Input: structuredClauses, schemaTemplate, historicalActiveRules, sourceMetadata

[0124] Output: candidateRuleSet

[0125] 1. context <- buildContext(structuredClauses, schemaTemplate, historicalActiveRules, sourceMetadata)

[0126] 2. prompt <- renderConstrainedPrompt(context)

[0127] 3. rawOutput<- LLM.generate(prompt)

[0128] 4. parsedRules<- parseStructuredOutput(rawOutput, schemaTemplate)

[0129] 5. repairedRules<- repairMinorFormatIssues(parsedRules,schemaTemplate)

[0130] 6. attachSourceRefs(repairedRules, structuredClauses)

[0131] 7. Return repairedRules

[0132] The function of each line in the pseudocode for the above candidate rule generation process is explained as follows:

[0133] The Input line defines the input parameters for the candidate rule generation process, including structuredClauses (structured clause data, i.e., unified structured salary regulations data processed by the clause structured agent), schemaTemplate (schema template, i.e., field definitions and constraint rules of the unified salary standard schema), historicalActiveRules (historical active rules, i.e., the collection of salary standard objects that have been published and are currently in effect), and sourceMetadata (source metadata, i.e., the source identifier, issuing agency, and version information of the regulatory text).

[0134] The Output line defines the output result candidateRuleSet of the candidate rule generation process, which is a collection of candidate salary standard objects that conform to the unified salary standard pattern;

[0135] The first line calls the buildContext function, which assembles the clause structured data, pattern templates, historical valid rules and source metadata into a context object, which is used to provide a complete basis for the generation of the large language model.

[0136] The second line calls the renderConstrainedPrompt function, which generates a prompt with preset output constraints based on the context object. The preset output constraints include fixed field templates, field type constraints, and field mandatory constraints, which are used to constrain the output format of the large language model.

[0137] The third line calls the LLM.generate function, inputs the constrained prompt words into the large language model, and obtains the raw output rawOutput;

[0138] Line 4 calls the parseStructuredOutput function, which performs structured parsing on the raw output of the large language model based on the pattern template, and extracts the set of candidate salary standard objects parsedRules that conform to the unified salary standard pattern.

[0139] Line 5 calls the repairMinorFormatIssues function to repair the format of the parsed candidate salary standard objects. The repair includes numeric type conversion, date format standardization, and enumeration value normalization, and obtains the repaired candidate salary standard object set repairedRules.

[0140] Line 6 calls the attachSourceRefs function to associate each repaired candidate salary standard object with the original clause structured data and populate the sourceRefs field to ensure that each rule can be traced back to the original regulatory clause;

[0141] Line 7 returns the repairedRules set of candidate salary criteria objects after repairing and associating source references as the final output.

[0142] In this implementation, the preset output constraints ensure that each candidate rule output by the large language model has the following capabilities: it can be parsed by a machine; it can be mapped to a unified salary standard pattern; it can trace the source clause; and it can be directly processed by the subsequent verification and execution modules.

[0143] In one embodiment of this application, the preset output constraints include fixed field templates, field type constraints, field mandatory constraints, field dependency constraints, source reference constraints, numerical range constraints, and / or parameter template constraints for specific rule categories.

[0144] In one embodiment of this application, the deterministic verification includes schema integrity verification, source index verification, effective interval overlap verification, conflict matrix verification, and / or historical version difference verification; wherein

[0145] The pattern integrity check is used to verify whether the candidate salary standard object conforms to the field integrity, field type compliance and logical constraints between fields defined by the unified salary standard pattern;

[0146] The source index verification is used to verify whether the source reference of the candidate salary standard object that has passed the schema integrity verification can be traced back to the original regulatory clause; wherein, the source reference field in the candidate salary standard object that has passed the schema integrity verification has passed the field existence and format correctness verification;

[0147] The overlap check of effective periods is used to detect overlap in the effective start and end times of multiple candidate salary standard objects with the same legal domain identifier, rule category, and applicable object, based on the candidate salary standard objects that have passed the pattern integrity check; wherein the legal domain identifier, rule category, applicable object, and effective start and end time fields in the candidate salary standard objects that have passed the pattern integrity check have passed the format verification;

[0148] The conflict matrix verification is used to further compare the parameter ranges and priorities of each candidate salary standard object in the same group based on the overlapping rule pairs output by the effective interval overlap verification, so as to identify mutually exclusive rules, duplicate rules and coverage rules.

[0149] The historical version difference verification is used to verify the differences in key fields between the candidate salary standard object and the previously published candidate salary standard object based on the candidate salary standard object that has passed the pattern integrity verification, and to determine whether the difference conforms to the range of change described in the source terms.

[0150] The mutual exclusion rule refers to candidate salary standard objects with the same priority but conflicting rule logic within the same effective interval and parameter interval. The duplication rule refers to candidate salary standard objects with completely identical effective intervals, parameter intervals, and priorities. The coverage rule refers to candidate salary standard objects with an inclusion relationship in their effective intervals and different priorities.

[0151] In some embodiments, the five checks—schema integrity check, source index check, effective interval overlap check, conflict matrix check, and historical version difference check—are performed in the following order and dependency relationship:

[0152] The first step is to perform a schema integrity check. This schema integrity check is a prerequisite for all subsequent checks and is used to verify whether the candidate salary standard object conforms to the field integrity, field type compliance, and logical constraints between fields defined by the unified salary standard schema. If the candidate salary standard object fails the schema integrity check, it is directly marked as a verification failure and no further checks are performed.

[0153] The second step involves parallel execution of source index verification, effective period overlap verification, and historical version difference verification after the schema integrity verification passes. The source index verification relies on the existence and format correctness of the source reference field in the candidate salary standard object after the schema integrity verification passes. Based on this, it further verifies whether the source reference can be traced back to the original legal clause. Failure of the source index verification does not prevent the execution of subsequent verification steps, but it affects the Ssource score. The effective period overlap verification relies on the format verification of the legal domain identifier, rule category, applicable object, and effective start and end time fields in the candidate salary standard object after the schema integrity verification passes. Based on this, it detects overlap in the effective start and end times of multiple candidate salary standard objects with the same legal domain identifier, rule category, and applicable object. The historical version difference verification only depends on the schema integrity verification passing and does not depend on the results of the source index verification and effective period overlap verification. It is used to compare the key field differences between the candidate salary standard object and the previously published candidate salary standard object to determine whether the differences conform to the range of changes described in the source clause. These three verifications have no direct dependency on each other and can be executed in parallel.

[0154] The third step is to perform a conflict matrix verification after the overlap verification of the effective intervals is completed. The conflict matrix verification depends on the result of the overlap verification of the effective intervals. It further compares the parameter ranges and priorities of each candidate salary standard object in the same group only on rule pairs whose effective intervals have been identified as overlapping, in order to identify mutually exclusive rules, duplicate rules and covering rules. The conflict matrix verification is a deepening of the overlap verification of the effective intervals. It is only necessary to perform conflict matrix verification on rule pairs whose effective intervals have overlapping.

[0155] The results of the five verifications correspond to different sub-scores in the confidence formula: the source index verification result corresponds to Ssource, the schema integrity verification result corresponds to Sschema, the conflict matrix verification result (including the effective interval overlap verification result) corresponds to Sconflict, and the historical version difference verification result corresponds to Sdiff.

[0156] In some embodiments, this application utilizes a deterministic verification agent to perform at least the following verifications on candidate rules: schema integrity verification, used to verify the completeness of required fields, the correctness of field types, and the legality of dependencies between fields; effective interval overlap verification, used to verify whether there are conflicting effective intervals for rules under the same legal domain, the same rule category, and the same scope of applicable objects; conflict matrix verification, which groups candidate salary standard objects according to legal domain, rule category, applicable object, income item, deduction item, and priority fields, and compares the effective intervals, parameter intervals, and priorities of rules in the same group to identify mutually exclusive rules, duplicate rules, and overriding rules; historical version difference verification, used to compare the key field differences between candidate salary standard objects and the previously published candidate salary standard objects, and determine whether the differences conform to the range of changes described in the source clauses; and source index integrity verification, used to verify whether the source references in the candidate salary standard objects can be traced back to the original regulatory clauses.

[0157] In this embodiment, the processing logic for conflict matrix verification can be expressed as follows:

[0158] for each group in groupBy(jurisdiction, ruleCategory, workerType,incomeItemType, deductionItemType):

[0159] for each ruleA, ruleB in pairwise(group.rules):

[0160] if overlap(ruleA.effectiveWindow, ruleB.effectiveWindow):

[0161] if samePriority(ruleA, ruleB) and inconsistentParameters(ruleA,ruleB):

[0162] markBlockingConflict(ruleA, ruleB)

[0163] else if covered(ruleA, ruleB):

[0164] markCoverageRelation(ruleA, ruleB)

[0165] The functions of each line in the above conflict matrix verification pseudocode are explained below:

[0166] The first line of the outer loop calls the groupBy function to group all candidate salary standard objects according to five dimensions: jurisdiction identifier jurisdiction, rule category ruleCategory, applicable object type workerType, income item type incomeItemType, and deduction item type deductionItemType, to ensure that rule conflict comparisons are only performed within the same group.

[0167] The inner loop in line 2 calls the pairwise function to pair rules in the same group, generating rule pairs ruleA and ruleB, which are used for conflict detection on a pairwise basis.

[0168] The third line calls the overlap function to determine whether there is a time overlap between the effective windows of rule pairs A and B. If there is no overlap, the subsequent detection of the rule pair is skipped.

[0169] If the effective ranges overlap, line 4 calls the samePriority function to determine if the priorities of the two rules are the same, and calls the inconsistentParameters function to determine if there is a logical conflict in the calculation parameters of the two rules. If the priorities are the same but the parameters are inconsistent, then line 5 is executed.

[0170] Line 5 calls the markBlockingConflict function to mark the rule pair as a blocking conflict. The blocking conflict includes mutual exclusion rules and duplicate rules. The blocking conflict will directly affect the conflict check score Sconflict.

[0171] Line 6 is the else if branch, which calls the covered function to determine whether there is an inclusion relationship between the effective ranges of the two rules and whether there is a difference in priority. If the conditions are met, line 7 is executed.

[0172] Line 7 calls the markCoverageRelation function to mark the rule pair as a coverage relationship. The coverage relationship belongs to the warning conflict and is weighted by the conversion factor α in the conflict check score calculation.

[0173] In one embodiment of this application, the preset sample wage includes at least basic wage, allowances, bonuses, pre-tax deductions, social security base, currency, payment frequency, identity parameters, cumulative income parameters, and / or cumulative tax parameters.

[0174] In one embodiment of this application, the candidate salary standard object is calculated based on a preset sample salary, and the calculation result is obtained by the following steps S2051 to S2052.

[0175] Step S2051: Perform a trial calculation on the candidate salary standard object based on the preset sample salary to obtain the trial calculation results. The trial calculation results include the probe pass rate and the number of blocking failures.

[0176] Step S2052: Compare the trial results and preset results item by item and calculate the probe pass rate and the number of blocking failures.

[0177] Wherein, the probe pass rate is the ratio of the number of sample wages that passed the trial calculation in the preset sample wages to the total number of sample wages, and the number of blocking failures is the number of failed sample wages that caused the calculation process to terminate.

[0178] In some embodiments, this application uses a regression probe agent to perform trial calculations on the candidate salary standard objects based on the preset sample salary, and obtains the trial calculation results. The trial calculation results include the probe pass rate and the number of blocking failures; the probe pass rate and the number of blocking failures are calculated and obtained by comparing the trial calculation results with the preset results item by item. Figure 4 This is a schematic diagram illustrating the regression probe trial calculation and probe pass rate calculation process described in an embodiment of this application. Figure 4 As shown, the regression probe agent performs trial calculations based on a pre-defined sample wage input vector. The deterministic gross-to-net computation engine performs trial calculations based on candidate rules, outputting pre-tax wage, taxable wage, individual income tax, employee social security, employer social security, after-tax wage, and year-to-date cumulative value. The system compares the trial calculation results with the expected results and calculates the probe pass rate.

[0179] ProbePassRate = PassedProbeCount / TotalProbeCount

[0180] If a candidate rule experiences a critical deviation in the high-income boundary probe or the social security cap probe, it is recorded as a blocking failure.

[0181] Wherein, ProbePassRate represents the probe pass rate, PassedProbeCount represents the number of probes whose trial results are equal to the expected results, and TotalProbeCount represents the total number of probes, and TotalProbeCount is an integer value greater than 0.

[0182] In some embodiments, the input vector of the preset sample salary can be divided into the following probe sets: regular employee probe, high income boundary probe, social security cap probe, bonus distribution probe, pre-tax deduction probe, currency conversion probe, year-to-date cumulative probe, and specific employment status probe.

[0183] In one embodiment of this application, calculating the confidence score of the candidate salary standard object based on the deterministic verification result, the trial calculation result, and the feedback data includes step S2071: calculating the confidence score of the candidate salary standard object based on the weight scores of each verification item in the deterministic verification result, the regression probe weight scores in the trial calculation result, and the historical operational stability weight scores in the feedback data. The formula for calculating the confidence score is as follows:

[0184] C = w1×Ssource + w2×Sschema + w3×Sconflict + w4×Sprobe + w5×Sdiff + w6×Sruntime;

[0185] Where C represents the confidence score, Ssource represents the source credibility score, Sschema represents the schema integrity score, Sconflict represents the conflict verification score, Sprobe represents the regression probe score, Sdiff represents the version difference rationality score, Sruntime represents the historical running stability score, and w1-w6 represent the corresponding weights, and the sum of w1 to w6 is 1 or normalized.

[0186] In some embodiments, this application utilizes a decision-making agent to calculate the confidence score of the candidate salary standard object based on the weight scores of each verification item in the deterministic verification result, the regression probe weight scores in the trial calculation result, and the historical operational stability weight scores in the feedback data.

[0187] In one embodiment of this application, the formula for calculating the source credibility score Ssource is:

[0188] Ssource = ValidRefCount / TotalRefCount

[0189] Wherein, ValidRefCount represents the number of source references in the candidate salary standard object that can be successfully traced back to the original regulatory clause, and TotalRefCount represents the total number of all source references in the candidate salary standard object; when all source references can be traced back to the original regulatory clause, Ssource=1.0. TotalRefCount is an integer greater than 0. When TotalRefCount=0, it means that the candidate salary standard object has no source references, and in this case, Ssource=0 by default.

[0190] In one embodiment of this application, the formula for calculating the schema integrity score Sschema is as follows:

[0191] Sschema = PassedCheckCount / TotalCheckCount

[0192] Here, PassedCheckCount represents the number of validation items that passed the schema integrity check. These validation items include required field integrity checks, field type correctness checks, and field dependency validity checks. TotalCheckCount represents the total number of all schema integrity validation items. When all validation items pass, Sschema = 1.0. TotalCheckCount is a positive integer. When TotalCheckCount = 0, it indicates that there are no validation items required for schema integrity checking, and in this case, Sschema = 0 by default.

[0193] In one embodiment of this application, the formula for calculating the conflict check score Sconflict is as follows:

[0194] Sconflict = 1 − (BlockingConflictCount + α × WarningConflictCount) / TotalPairCount

[0195] Wherein, BlockingConflictCount represents the number of detected blocking conflicts, including mutually exclusive rules and duplicate rules; WarningConflictCount represents the number of detected warning conflicts, including overriding rules; TotalPairCount represents the total number of rule comparisons within the same group; α represents the reduction factor for warning conflicts, 0 < α < 1; when there are no conflicts, Sconflict = 1.0. TotalPairCount is an integer greater than 0. When TotalPairCount = 0, it means that the total number of rule comparisons within the same group in the conflict matrix verification is 0, and Sconflict = 0 by default.

[0196] In one embodiment of this application, the formula for calculating the regression probe score Sprobe is as follows:

[0197] Sprobe = ProbePassRate × (1 − BlockerPenalty)

[0198] Wherein, ProbePassRate represents the probe pass rate, which is the ratio of the number of sample wages that passed the trial calculation to the total number of sample wages in the preset sample wages; BlockerPenalty represents the blocking failure penalty, and the calculation formula for the blocking failure penalty is as follows:

[0199] BlockerPenalty = min(BlockerCount / TotalProbeCount, 1.0)

[0200] Wherein, BlockerCount represents the number of blocking failures, that is, the number of failed sample wages that caused the calculation process to terminate; TotalProbeCount represents the total number of probes; when all probes pass and there are no blocking failures, Sprobe=1.0. TotalProbeCount is an integer value greater than 0. When TotalProbeCount=0, it means that there are no probes in the input vector of the preset sample wage, and Sprobe=0 by default.

[0201] In one embodiment of this application, the formula for calculating the version difference reasonableness score Sdiff is as follows:

[0202] Sdiff = ReasonableDiffFieldCount / TotalDiffFieldCount

[0203] Wherein, ReasonableDiffFieldCount represents the number of fields among the key field differences that conform to the range of changes described in the source terms, and TotalDiffFieldCount represents the total number of key fields that differ between the candidate salary standard object and the previously published candidate salary standard object; when the candidate salary standard object is published for the first time and has no historical versions, Sdiff defaults to 1.0. TotalDiffFieldCount is an integer value greater than 0. When TotalDiffFieldCount = 0, it means that there are no key fields that differ between the candidate salary standard object and the previously published candidate salary standard object, and in this case, Sdiff defaults to 0.

[0204] In one embodiment of this application, the formula for calculating the historical operational stability score Sruntime is as follows:

[0205] Sruntime = 1 − (RecentDeviationCount + β × RecentRollbackCount) / RecentExecutionCount

[0206] Wherein, RecentDeviationCount represents the number of actual execution deviations that occurred within the recent payroll period, RecentRollbackCount represents the number of times automatic rollback was triggered within the recent payroll period, RecentExecutionCount represents the total number of executions within the recent payroll period, and β represents the weighting coefficient of the rollback event, β≥1. RecentExecutionCount is an integer value greater than 0. When RecentExecutionCount = 0, it indicates that the candidate payroll standard object is being released for the first time and has no historical running data. In this case, Sruntime takes a preset initial value.

[0207] In one embodiment of this application, the process of determining the status of the candidate salary standard object based on the confidence score, the probe pass rate, and the number of blocking failures, and obtaining the verified candidate salary standard object includes the following steps S2072 to S2076.

[0208] Step S2072: If the number of blocking failures is greater than 0, then mark the candidate salary standard object as a verification failure state.

[0209] Step S2073: If the confidence score is greater than or equal to the first confidence threshold and the probe pass rate is greater than or equal to the preset release pass rate threshold, then the candidate salary standard object is marked as released.

[0210] Step S2074: If the confidence score is less than the first confidence threshold and greater than or equal to the second confidence threshold, then the candidate salary standard object is marked as a test state.

[0211] Step S2075: If the confidence score is less than the second confidence threshold, then the candidate salary standard object is marked as a draft.

[0212] Step S2076: The candidate salary standard object in the published state is taken as the candidate salary standard object that has passed the verification.

[0213] In some embodiments, this application utilizes a publishing decision-making agent to calculate a comprehensive confidence level based on source credibility, structural integrity, conflict verification results, regression probe results, version difference rationality, and historical operational stability. For example:

[0214] C = 0.15×Ssource + 0.20×Sschema + 0.20×Sconflict + 0.25×Sprobe +0.10×Sdiff + 0.10×Sruntime.

[0215] When C ≥ 0.90, ProbePassRate ≥ 0.95, and BlockerCount = 0, the candidate rule enters the release state; when 0.75 ≤ C < 0.90 and BlockerCount = 0, the candidate rule enters the testing state; when C < 0.75, the candidate rule enters the draft state; when BlockerCount > 0, the candidate rule enters the verification failure state.

[0216] Wherein, ProbePassRate represents the probe pass rate, and BlockerCount represents the number of blocking failures.

[0217] In one embodiment of this application, the process of calling the corresponding salary calculation standard based on the verified candidate salary standard object to perform salary calculation includes the following steps S2081 to S2083.

[0218] Step S2081: Call the corresponding salary calculation standard based on the verified candidate salary standard object.

[0219] Step S2082: Calculate the salary data to be processed based on the salary calculation standard to obtain the actual salary data; the actual salary data includes at least pre-tax salary, taxable salary, individual income tax, employee social security, employer social security, after-tax salary and / or cumulative value from the beginning of the year to date.

[0220] Step S2083: Based on the verified candidate salary standard object, perform hash processing to generate the corresponding rule snapshot hash, and save the verified candidate salary standard object, the rule snapshot hash and the actual salary data.

[0221] In some embodiments, this application utilizes a deterministic computing engine to invoke the corresponding salary calculation standard based on the verified candidate salary standard object; performs salary calculation on the salary calculation data to be processed based on the salary calculation standard to obtain actual salary data; the actual salary data includes at least pre-tax salary, taxable salary, individual income tax, employee social security, employer social security, after-tax salary and / or year-to-date cumulative value; performs hash processing on the verified candidate salary standard object to generate a corresponding rule snapshot hash, and saves the verified candidate salary standard object, the rule snapshot hash and the actual salary data.

[0222] In some embodiments, this application utilizes a deterministic gross-to-net computing engine to perform actual salary calculations using only release status rules. The execution flow is as follows: load the release status rules for the corresponding jurisdiction and period; calculate pre-tax salary based on salary input data; apply pre-tax deduction rules to obtain taxable salary; apply individual income tax rules and social security rules to obtain individual income tax, employee social security, and employer social security; calculate after-tax salary; update year-to-date cumulative values; generate rule snapshot hashes; and save execution audit records.

[0223] The pseudocode for execution is as follows:

[0224] Input: payrollInput, activeRuleSet

[0225] Output: payrollResult, auditRecord

[0226] 1. gross = computeGross(payrollInput)

[0227] 2. taxable = applyPreTaxRules(gross, activeRuleSet)

[0228] 3. tax = applyTaxRules(taxable, activeRuleSet)

[0229] 4. socialEmployee = applyEmployeeSocialRules(gross, activeRuleSet)

[0230] 5. socialEmployer = applyEmployerSocialRules(gross, activeRuleSet)

[0231] 6. net = gross - preTaxDeduction - tax - socialEmployee -postTaxDeduction

[0232] 7. ytd = updateYTD(payrollInput.employeeId, gross, taxable, tax,socialEmployee, net)

[0233] 8. snapshotHash = hash(activeRuleSet, payrollInput)

[0234] 9. saveAudit(snapshotHash, ytd, payrollResult)

[0235] 10. return payrollResult, auditRecord

[0236] The functions of each line in the pseudocode for the aforementioned deterministic computation engine are explained below:

[0237] The Input line defines the input parameters for the execution process, including payrollInput (salary input data, including employee base salary, allowances, bonuses, pre-tax deductions, social security base, payment frequency and identity parameters, etc.) and activeRuleSet (the set of currently effective published salary calculation standards).

[0238] The Output line defines the output results of the execution process, including payrollResult (salary calculation result) and auditRecord (audit record).

[0239] The first line calls the computeGross function to calculate the pre-tax gross salary based on income items such as base salary, allowances, and bonuses in the salary input data;

[0240] The second line calls the applyPreTaxRules function to calculate the taxable salary based on the pre-tax salary and the pre-tax deduction rules in the published salary calculation standards. The pre-tax deduction rules include the individual's contribution to social insurance and housing provident fund, special additional deductions, and other statutory pre-tax deductions.

[0241] Line 3 calls the applyTaxRules function to calculate individual income tax based on taxable wages and the individual income tax rules in the published salary calculation standards. The individual income tax rules include tax rate ranges, quick calculation deductions, and cumulative tax calculation methods.

[0242] Line 4 calls the applyEmployeeSocialRules function to calculate the employee's social security contribution amount socialEmployee based on the pre-tax salary and the employee social security rules in the published salary calculation standard. The employee social security rules include the contribution ratio and the upper and lower limits of the social security base.

[0243] Line 5 calls the applyEmployerSocialRules function to calculate the employer's social security contribution amount, socialEmployer, based on pre-tax wages and the employer's social security rules in the published salary calculation standards;

[0244] Line 6 calculates the after-tax salary (net) based on the pre-tax salary minus pre-tax deductions, individual income tax, employee social security contributions, and after-tax deductions.

[0245] Line 7 calls the updateYTD function to update the year-to-date cumulative value ytd of the employee based on the employee identifier, including cumulative pre-tax salary, cumulative taxable salary, cumulative individual income tax, cumulative employee social security contributions, and cumulative after-tax salary;

[0246] Line 8 calls the hash function to hash the currently used set of published salary calculation standards and salary input data, generating a rule snapshot hash (snapshotHash) to ensure the traceability and auditability of salary calculation results.

[0247] Line 9 calls the saveAudit function to save the rule snapshot hash, year-to-date cumulative value, and salary calculation results as an audit log;

[0248] Line 10 returns the payroll result (payrollResult) and the audit record (auditRecord).

[0249] In some embodiments, this application uses a deterministic calculation engine to load only the release status rules for salary calculation and outputs at least the following calculation results: pre-tax salary, taxable salary, individual income tax, employee social security, employer social security, post-tax salary, cumulative pre-tax salary since the beginning of the year, cumulative taxable salary since the beginning of the year, cumulative individual income tax since the beginning of the year, cumulative employee social security since the beginning of the year, and cumulative post-tax salary since the beginning of the year.

[0250] In one embodiment of this application, the preset trigger rollback condition includes:

[0251] DeviationRate>D_max or CriticalSlipMismatchCount ≥ N_max

[0252] Where DeviationRate represents the actual execution deviation rate; D_max represents the maximum allowable deviation threshold; CriticalSlipMismatchCount represents the number of critical payroll mismatches; and N_max represents the threshold for the number of critical payroll mismatches.

[0253] Figure 5 The flowchart shown is a runtime monitoring, automatic rollback, and feedback closed-loop process as described in the embodiments of this application. Figure 5As shown, this application utilizes a runtime monitoring feedback agent to continuously collect: the deviation between the actual execution result and the expected result, manual correction records (i.e., correction records in the above embodiments), abnormal pay slip alarms, correction values ​​after user confirmation, and the impact range of version switching.

[0254] Automatic rollback is triggered when either of the following conditions is met: DeviationRate > D_max; CriticalSlipMismatchCount ≥ N_max.

[0255] Where DeviationRate is the actual execution deviation rate; D_max is the maximum allowable deviation threshold; CriticalSlipMismatchCount is the number of critical payroll mismatches; and N_max is the threshold for the number of critical payroll mismatches.

[0256] After a rollback is triggered, the system performs the following operations: takes the currently released rule offline; restores the previous released version; records the rollback reason, rollback time, affected employee set, affected salary cycle, and related salary slip identifier; and inputs the rollback result as feedback data into the candidate rule generation agent and the release decision agent for the next round of rule generation, threshold update, or probe set expansion.

[0257] In some embodiments, taking the adjustment of individual income tax rates and social security bases in a certain jurisdiction in a certain year as an example: the regulatory acquisition agent obtains the official tax rate adjustment announcement and social security base update notification; the clause structuring agent extracts the new tax rate range, applicable objects, and effective time from the announcement; the candidate rule generation agent generates new individual income tax candidate salary standard objects and social security candidate salary standard objects based on the unified salary standard model; the deterministic verification agent verifies whether there are effective range conflicts and parameter conflicts between the new candidate salary standard objects and the previous version; the regression probe agent performs trial calculations through regular employee probes, high-income boundary probes, and social security capping probes; the release decision agent calculates the comprehensive confidence level based on the probe results and verification results; when the comprehensive confidence level meets the release threshold, the new rule is marked as released and written into the executable rule base; during the actual salary cycle, the gross-to-net calculation engine performs salary calculations based on the new rule; if an abnormal deviation is found in a specific income range after going live, the runtime monitoring feedback agent automatically reverts to the previous version and includes the abnormal sample in the new probe set.

[0258] This application uses a set of exemplary implementation data to further illustrate the implementability of this application.

[0259] In this implementation, the target jurisdiction J1 is selected, and the rule effective date is January 1, 2026. The key parameters of the candidate salary standard objects are as follows: In the individual income tax rules, the tax rate is 5% for income range of 0 to 10,000, 10% for income range greater than 10,000 but not exceeding 16,000, and 18% for income range greater than 16,000; the employee social security contribution rate is 7%; the employer social security contribution rate is 10%; the upper limit of the social security base is 16,000; pre-tax deductions are directly deducted according to the input value; the rounding method is rounding to the nearest cent.

[0260] It should be noted that the implementation data in the above embodiments are used to illustrate the technical process and technical effects of this application, but this application is not limited thereto. In actual submission, the data can be replaced by the user's real test data, real regression data or formal acceptance data.

[0261] In some embodiments, the regression probe agent in this application selects three sets of sample wage input vectors, corresponding to the regular employee probe, the high-income boundary probe, and the social security capping probe, as shown in the following example:

[0262] Probe P1 (Regular Employee Probe): Base salary 12000, allowance 500, bonus 0, pre-tax deduction 300, social security base 12000, payment frequency monthly. Based on the above candidate salary standard objects, the following calculations are obtained: pre-tax salary 12500.00, employee social security 840.00, taxable salary 11360.00, individual income tax 636.00, employer social security 1200.00, after-tax salary 10724.00.

[0263] Probe P2 (High Income Boundary Probe): Base salary 18000, allowance 1000, bonus 3000, pre-tax deductions 500, social security base 16000, payment frequency monthly. Based on the above candidate salary standard objects, the following calculations are obtained: pre-tax salary 22000.00, employee social security 1120.00, taxable salary 20380.00, individual income tax 1888.40, employer social security 1600.00, after-tax salary 18491.60.

[0264] Probe P3 (Social Security Cap Probe): Base salary 9000, allowances 0, bonus 500, pre-tax deductions 200, social security base 9000, payment frequency monthly. Based on the above candidate salary standard objects, the following calculations are obtained: pre-tax salary 9500.00, employee social security 630.00, taxable salary 8670.00, individual income tax 433.50, employer social security 900.00, after-tax salary 8236.50.

[0265] In this embodiment, all three sets of probes met the expected results, the probe pass rate was 100%, the number of blocking failures was 0, and the candidate salary standard object was marked as published by the publishing decision agent.

[0266] To illustrate the technical effectiveness of this application compared to the traditional manual expert maintenance process, a comparative experiment was conducted within the same test scope. The control group used a process of "manual expert interpretation of regulations + static template maintenance + manual review," while the experimental group used the process of this application: "multi-agent collaborative generation + deterministic verification + regression probe feedback."

[0267] In this embodiment, the test scope includes: 12 legal domains, 48 ​​regulatory update events, 576 sets of regression probe samples, 96 sets of historical version difference samples, and 24 sets of manually corrected return samples. The specific comparison structure is as shown in Table 2 below.

[0268] Table 2

[0269] index control group experimental group Candidate rule structured accuracy 82.4% 96.8% Blocking rule conflict detection rate 61.5% 94.2% First pass rate of regression probe 78.6% 96.1% Average time to go live on rules 5.8 working days 1.7 working days Key payroll mismatch rate 3.4% 0.6% Average Discovery Cycle for Version Rollback 2.0 salary cycles 0.3 salary cycles

[0270] The above results show that by combining multi-agent collaboration, deterministic verification, and regression probe feedback, this application can improve the rule structure accuracy, conflict detection rate, and probe first-pass rate, while shortening the rule deployment time, reducing the mismatch rate of key salary slips and the duration of erroneous versions, thereby achieving more stable technical results.

[0271] It should be noted that in this application, multilingual regulatory texts can be machine translated and bilingually aligned before clause structuring; the candidate rule generation agent can be combined with the vector retrieval module to enhance the recall of source clauses; the confidence weights w1 to w6 can be dynamically adjusted based on manual correction records; different legal jurisdictions can use different probe sets and different publication thresholds; different payment frequencies, different contract types, and different entity types can maintain rule subsets separately; the runtime monitoring feedback agent can also use the manual approval results for subsequent threshold optimization.

[0272] The scope of protection of the multi-domain salary calculation standard generation and verification method based on a large model described in this application is not limited to the execution order of the steps listed in this embodiment. Any solution implemented by adding, subtracting, or replacing steps in the prior art based on the principles of this application is included within the scope of protection of this application.

[0273] This application also provides a system for generating and verifying multi-domain salary calculation standards based on a large model. The system can implement the method for generating and verifying multi-domain salary calculation standards based on a large model described in this application. However, the implementation apparatus for the method for generating and verifying multi-domain salary calculation standards based on a large model described in this application includes, but is not limited to, the structure of the system for generating and verifying multi-domain salary calculation standards based on a large model listed in this embodiment. All structural modifications and substitutions of the prior art made in accordance with the principles of this application are included within the protection scope of this application.

[0274] Figure 6 The diagram shown is a structural schematic of the multi-domain salary calculation standard generation and verification system based on a large model, as described in an embodiment of this application. Figure 6 As shown in the figure, this embodiment provides a multi-domain salary calculation standard generation and verification system based on a large model. The system includes: a regulatory data acquisition module 701, a preprocessing module 702, a candidate rule generation module 703, a deterministic verification module 704, a trial calculation module 705, a feedback optimization module 706, a confidence calculation and state judgment module 707, a deterministic execution module 708, and an automatic rollback module 709.

[0275] The regulatory data acquisition module 701 is configured to acquire salary regulatory data of the target legal domain; the salary regulatory data includes regulatory text data, regulatory source data, effective date data and / or version identifier data;

[0276] The preprocessing module 702 is configured to preprocess the salary regulation data to obtain unified structured salary regulation data; the unified structured salary regulation data is the clause structured data of the unified salary standard model.

[0277] The candidate rule generation module 703 is configured to generate candidate salary standard objects that conform to the unified salary standard pattern based on the unified structured salary regulations data and preset output constraints using a large model; the preset output constraints can constrain the candidate salary standard objects to trace back to the original source clauses;

[0278] The deterministic verification module 704 is configured to perform deterministic verification based on the candidate salary standard object and obtain the deterministic verification result; the deterministic verification includes schema integrity verification, source index verification, effective interval overlap verification, conflict matrix verification and / or historical version difference verification;

[0279] The trial calculation module 705 is configured to perform a trial calculation on the candidate salary standard object based on a preset sample salary to obtain the probe pass rate and the number of blocking failures.

[0280] The feedback optimization module 706 is configured to generate feedback data based on the deterministic verification result, the probe pass rate, and the actual execution deviation and correction records of historically published salary standard objects, and return the feedback data to the candidate salary standard object generation step for subsequent candidate salary standard object generation.

[0281] The confidence calculation and status judgment module 707 is configured to perform confidence calculation based on the deterministic verification result, the trial calculation result and the feedback data, obtain the confidence score of the candidate salary standard object, and perform status judgment on the candidate salary standard object according to the confidence score, the probe pass rate and the number of blocking failures, and obtain the candidate salary standard object that has passed the verification.

[0282] The deterministic execution module 708 is configured to call the corresponding salary calculation standard to perform salary calculation based on the verified candidate salary standard object;

[0283] The automatic rollback module 709 is configured to collect actual execution deviations and correction records in real time when performing salary calculations. When the actual execution deviations meet the preset rollback trigger conditions, the module rolls back to the previous published version of the salary standard object, records the rollback results, and uses them as feedback data for the generation of the next round of candidate salary standard objects. The rollback results include the rollback reason, rollback time, scope of impact, and related salary slip identifiers.

[0284] It should be noted that the functions or operations of the regulatory data acquisition module 701, preprocessing module 702, candidate rule generation module 703, deterministic verification module 704, trial calculation module 705, feedback optimization module 706, confidence calculation and state judgment module 707, deterministic execution module 708, and automatic rollback module 709 described in the embodiments of this application correspond one-to-one with the steps in the above-mentioned method for generating and verifying multi-domain salary calculation standards based on large models, and therefore will not be repeated here.

[0285] In the embodiments provided in this application, it should be understood that the disclosed systems, apparatuses, or methods can be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative. For instance, the division of modules / units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple modules or units may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be through some interfaces; the indirect coupling or communication connection of apparatuses or modules or units may be electrical, mechanical, or other forms.

[0286] The modules / units described as separate components may or may not be physically separate. The components shown as modules / units may or may not be physical modules; that is, they may be located in one place or distributed across multiple network units. Some or all of the modules / units can be selected to achieve the objectives of the embodiments of this application, depending on actual needs. For example, the functional modules / units in the various embodiments of this application may be integrated into one processing module, or each module / unit may exist physically separately, or two or more modules / units may be integrated into one module / unit.

[0287] Those skilled in the art will further recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, computer software, or a combination of both. To clearly illustrate the interchangeability of hardware and software, the components and steps of the various examples have been generally described in terms of functionality in the foregoing description. 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.

[0288] Figure 7 The diagram shown is a structural schematic of the electronic device described in an embodiment of this application. Figure 7 As shown, this embodiment provides an electronic device, the electronic device 800 including: a memory 801 and a processor 802.

[0289] The memory 801 stores a computer program.

[0290] The processor 802 is communicatively connected to the memory and executes the above-described method for generating and verifying multi-domain salary calculation standards based on a large model when calling the computer program.

[0291] This application also provides a computer-readable storage medium. Those skilled in the art will understand that all or part of the steps in the methods of the above embodiments can be implemented by a program instructing a processor. The program can be stored in a computer-readable storage medium, which is a non-transitory medium, such as random access memory, read-only memory, flash memory, hard disk, solid-state drive, magnetic tape, floppy disk, optical disk, and any combination thereof. The storage medium can be any available medium accessible to a computer or a data storage device such as a server or data center that integrates one or more available media. The available medium can be a magnetic medium (e.g., floppy disk, hard disk, magnetic tape), an optical medium (e.g., digital video disc (DVD)), or a semiconductor medium (e.g., solid-state drive (SSD)).

[0292] This application embodiment may also provide a computer program product comprising one or more computer instructions. When the computer instructions are loaded and executed on a computing device, all or part of the processes or functions described in this application embodiment are generated. The computer instructions may be stored in a computer-readable storage medium or transmitted from one computer-readable storage medium to another. For example, the computer instructions may be transmitted from one website, computer, or data center to another via wired (e.g., coaxial cable, fiber optic, digital subscriber line (DSL)) or wireless (e.g., infrared, wireless, microwave, etc.) means.

[0293] When the computer program product is executed by a computer, the computer performs the method described in the foregoing method embodiments. The computer program product can be a software installation package; when the foregoing method is required, the computer program product can be downloaded and executed on the computer.

[0294] As described above, the method and system for generating and verifying multi-domain salary calculation standards based on a large model, as described in this application, have the following beneficial effects:

[0295] This application obtains unified structured salary regulation data by preprocessing salary regulation data from the target jurisdiction, and then constrains this unified structured salary regulation data using preset output constraints and a large model. This enables the original regulatory text to be stably converted into candidate salary standard objects that conform to a unified pattern. These candidate salary standard objects can be traced back to their original source clauses, reducing reliance on the experience of a single expert. This is particularly suitable for salary rule processing scenarios involving multiple jurisdictions, currencies, payment frequencies, and frequent regulatory updates, alleviating the inefficiency caused by the uneven distribution of salary expert capabilities across multiple jurisdictions. Furthermore, this application automatically verifies effective periods, rule conflicts, and historical version differences, enabling the detection of potential conflicts before rules go live. This application addresses structural anomalies; by performing sample salary calculations on candidate rules, it can detect salary calculation deviations that cannot be detected at the text level before actual payroll; by issuing candidate rules in a tiered manner, it avoids rules that have not passed verification from directly entering the actual execution process; by collecting execution deviations and automatically rolling back, it can form a closed-loop feedback mechanism for rule generation, verification, execution, and rollback; by saving rule versions, rule snapshot hashes, input summaries, output summaries, and cumulative values ​​from the beginning of the year to date, it can improve the audit traceability of the system; and it solves the problems of existing technologies such as reliance on manual interpretation of regulations, inconsistent rule deployment standards, delayed detection of execution deviations, and insufficient feedback capabilities.

[0296] The descriptions of the processes or structures corresponding to the above figures each have their own emphasis. For parts of a process or structure that are not described in detail, please refer to the relevant descriptions of other processes or structures.

[0297] The above embodiments are merely illustrative of the principles and effects of this application and are not intended to limit this application. Any person skilled in the art can modify or alter the above embodiments without departing from the spirit and scope of this application. Therefore, all equivalent modifications or alterations made by those skilled in the art without departing from the spirit and technical concept disclosed in this application should still be covered by the claims of this application.

Claims

1. A method for generating and validating multi-domain salary calculation standards based on a large model, characterized in that, include: Obtain salary regulations data for the target jurisdiction; The salary regulation data includes regulation text data, regulation source data, effective date data, and version identifier data; Preprocessing is performed on the aforementioned salary regulations data to obtain unified structured salary regulations data; the unified structured salary regulations data is the clause structured data of a unified salary standard model; The unified salary standard model includes at least the following: jurisdiction identifier, rule category, applicable objects, income items, deduction items, tax rate items, social security items, effective start and end time, calculation base, currency, rounding method, priority field, region identifier, source reference, parameter object, rule status, rule version, and rule confidence. Based on the unified structured salary regulations data and preset output constraints, a large model is used to generate candidate salary standard objects that conform to the unified salary standard pattern. The preset output constraints can ensure that the candidate salary standard object can be traced back to the original source clause; the preset output constraints include fixed field templates, field type constraints, field mandatory constraints, field dependency constraints, source reference constraints, numerical range constraints, and parameter template constraints for specific rule categories; the preset output constraints ensure that each candidate salary standard object output by the large model has the following capabilities: it can be parsed by the machine; it can be mapped to a unified salary standard pattern; it can trace the source clause; and it can be directly processed by the subsequent verification and execution modules; Deterministic verification is performed based on the candidate salary standard object to obtain the deterministic verification result; the deterministic verification includes schema integrity verification, source index verification, effective interval overlap verification, conflict matrix verification, and historical version difference verification. The candidate salary standard object is calculated based on the preset sample salary to obtain the calculation results, which include the probe pass rate and the number of blocking failures. The number of blocking failures refers to the number of failed sample wages that caused the calculation process to terminate. Feedback data is generated based on the deterministic verification results, the probe pass rate, and the actual execution deviations and correction records of historically published salary standard objects. The feedback data is then returned to the candidate salary standard object generation step for subsequent candidate salary standard object generation. Based on the deterministic verification results, the trial calculation results, and the feedback data, a confidence score is calculated to obtain the confidence score of the candidate salary standard object. The candidate salary standard object is then assessed for its status based on the confidence score, the probe pass rate, and the number of blocking failures to obtain the verified candidate salary standard objects. Specifically, the confidence score of the candidate salary standard object is calculated based on the scores of each verification item in the deterministic verification results, the regression probe score in the trial calculation results, and the historical operational stability score in the feedback data. The formula for calculating the regression probe score (Sprobe) in the trial calculation results is as follows: Sprobe = ProbePassRate × (1 − BlockerPenalty) Wherein, ProbePassRate represents the probe pass rate, which is the ratio of the number of sample wages that passed the trial calculation to the total number of sample wages in the preset sample wages; BlockerPenalty represents the blocking failure penalty, and the calculation formula for the blocking failure penalty is as follows: BlockerPenalty = min(BlockerCount / TotalProbeCount, 1.0) Wherein, BlockerCount represents the number of blocking failures, that is, the number of failed sample wages that caused the calculation process to terminate; TotalProbeCount represents the total number of probes; Based on the verified candidate salary standard object, the corresponding salary calculation standard is invoked to perform salary calculation; During salary calculation, actual execution deviations and correction records are collected in real time. When the actual execution deviation meets the preset trigger rollback conditions, the calculation is rolled back to the previous published version of the salary standard object. The rollback result is recorded and used as feedback data for the generation of the next round of candidate salary standard objects. The rollback result includes the rollback reason, rollback time, scope of impact, and related salary slip identifiers. The preset trigger rollback conditions include: DeviationRate>D_max or CriticalSlipMismatchCount ≥ N_max Where DeviationRate represents the actual execution deviation rate; D_max represents the maximum allowable deviation threshold; CriticalSlipMismatchCount represents the number of critical payroll mismatches; and N_max represents the threshold for the number of critical payroll mismatches.

2. The method for generating and validating multi-domain salary calculation standards based on a large model according to claim 1, characterized in that, Preprocessing the aforementioned salary regulations data to obtain unified structured salary regulations data includes: Based on the aforementioned salary regulations data, clause segmentation, field extraction, and semantic normalization are performed to generate structured clause data corresponding to the unified salary standard model. The unified structured salary regulations data includes at least clause number, clause category, variable name, scope of application, effective conditions, source index, original text fragment, and semantic tags.

3. The method for generating and validating multi-domain salary calculation standards based on a large model according to claim 1, characterized in that, The pattern integrity check is used to verify whether the candidate salary standard object conforms to the field integrity, field type compliance and logical constraints between fields defined by the unified salary standard pattern; The source index verification is used to verify whether the source reference of the candidate salary standard object that has passed the schema integrity verification can be traced back to the original regulatory clause; wherein the source reference field in the candidate salary standard object that has passed the schema integrity verification has passed the field existence and format correctness verification; The overlap check of effective periods is used to detect overlap in the effective start and end times of multiple candidate salary standard objects with the same legal domain identifier, rule category, and applicable object, based on the candidate salary standard objects that have passed the pattern integrity check; wherein the legal domain identifier, rule category, applicable object, and effective start and end time fields in the candidate salary standard objects that have passed the pattern integrity check have passed the format verification; The conflict matrix verification is used to further compare the parameter ranges and priorities of each candidate salary standard object in the same group based on the overlapping rule pairs output by the effective interval overlap verification, so as to identify mutually exclusive rules, duplicate rules and coverage rules. The historical version difference verification is used to verify the differences in key fields between the candidate salary standard object and the previously published candidate salary standard object based on the candidate salary standard object that has passed the pattern integrity verification, and to determine whether the difference conforms to the range of change described in the source terms. The mutual exclusion rule refers to candidate salary standard objects with the same priority but conflicting rule logic within the same effective interval and parameter interval. The duplication rule refers to candidate salary standard objects with completely identical effective intervals, parameter intervals, and priorities. The coverage rule refers to candidate salary standard objects with an inclusion relationship in their effective intervals and different priorities.

4. The method for generating and validating multi-domain salary calculation standards based on a large model according to claim 1, characterized in that, The preset sample salary includes at least basic salary, allowances, bonuses, pre-tax deductions, social security base, currency, payment frequency, and identity parameters. Based on the preset sample salary, trial calculations are performed on the candidate salary standard objects to obtain the probe pass rate and the number of blocking failures, including: The candidate salary standard object is calculated based on the preset sample salary to obtain the calculation result; The probe pass rate and the number of blocking failures are calculated and obtained by comparing the trial results and preset results item by item; The probe pass rate is the ratio of the number of sample wages that have passed the trial calculation in the preset sample wages to the total number of sample wages.

5. The method for generating and validating multi-domain salary calculation standards based on a large model according to claim 1, characterized in that, The formula for calculating the confidence score is as follows: C = w1×Ssource + w2×Sschema + w3×Sconflict + w4×Sprobe + w5×Sdiff +w6×Sruntime; Where C represents the confidence score, Ssource represents the source credibility score, Sschema represents the schema integrity score, Sconflict represents the conflict verification score, Sprobe represents the regression probe score, Sdiff represents the version difference rationality score, Sruntime represents the historical running stability score, and w1-w6 represent the corresponding weights, and the sum of w1 to w6 is 1 or normalized.

6. The method for generating and validating multi-domain salary calculation standards based on a large model according to claim 1, characterized in that, The candidate salary standard objects are evaluated for status based on the confidence score, probe pass rate, and number of blocking failures. The candidate salary standard objects that pass the verification include: If the number of blocking failures is greater than 0, the candidate salary standard object is marked as a verification failure. If the confidence score is greater than or equal to the first confidence threshold and the probe pass rate is greater than or equal to the preset release pass rate threshold, then the candidate salary standard object is marked as released. If the confidence score is less than the first confidence threshold and greater than or equal to the second confidence threshold, then the candidate salary standard object is marked as a test state. If the confidence score is less than the second confidence threshold, the candidate salary standard object is marked as a draft. The candidate salary standard object in the published state is used as the verified candidate salary standard object.

7. The method for generating and validating multi-domain salary calculation standards based on a large model according to claim 1, characterized in that, The salary calculation based on the verified candidate salary standard object includes calling the corresponding salary calculation standard to perform salary calculation, which includes: The corresponding salary calculation standard is invoked based on the verified candidate salary standard object; Salary calculations are performed on the salary calculation data to be processed based on the aforementioned salary calculation standards to obtain actual salary data; the actual salary data includes at least pre-tax salary, taxable salary, individual income tax, employee social security, employer social security, after-tax salary, and cumulative value from the beginning of the year to date; Based on the verified candidate salary standard object, a corresponding rule snapshot hash is generated through hash processing. The verified candidate salary standard object, the rule snapshot hash, and the actual salary data are then saved.

8. A system for generating and validating multi-domain salary calculation standards based on a large model, characterized in that, include: The regulatory data acquisition module is configured to acquire salary regulatory data for the target jurisdiction. The salary regulation data includes regulation text data, regulation source data, effective date data, and version identifier data; The preprocessing module is configured to preprocess the salary regulation data to obtain unified structured salary regulation data; the unified structured salary regulation data is the clause structured data of the unified salary standard model; The unified salary standard model includes at least the following: jurisdiction identifier, rule category, applicable objects, income items, deduction items, tax rate items, social security items, effective start and end time, calculation base, currency, rounding method, priority field, region identifier, source reference, parameter object, rule status, rule version, and rule confidence. The candidate rule generation module is configured to generate candidate salary standard objects that conform to the unified salary standard pattern based on the unified structured salary regulations data and preset output constraints using a large model. The preset output constraints can ensure that the candidate salary standard object can be traced back to the original source clause; the preset output constraints include fixed field templates, field type constraints, field mandatory constraints, field dependency constraints, source reference constraints, numerical range constraints, and parameter template constraints for specific rule categories; the preset output constraints ensure that each candidate salary standard object output by the large model has the following capabilities: it can be parsed by the machine; it can be mapped to a unified salary standard pattern; it can trace the source clause; and it can be directly processed by the subsequent verification and execution modules; The deterministic verification module is configured to perform deterministic verification based on the candidate salary standard object and obtain the deterministic verification result; the deterministic verification includes schema integrity verification, source index verification, effective interval overlap verification, conflict matrix verification, and historical version difference verification; The trial calculation module is configured to perform a trial calculation on the candidate salary standard object based on a preset sample salary, and obtain the trial calculation results, which include the probe pass rate and the number of blocking failures. The number of blocking failures refers to the number of failed sample wages that caused the calculation process to terminate. The feedback optimization module is configured to generate feedback data based on the deterministic verification result, the probe pass rate, and the actual execution deviation and correction records of historically published salary standard objects, and return the feedback data to the candidate salary standard object generation step for subsequent candidate salary standard object generation; The confidence score calculation and status determination module is configured to calculate the confidence score based on the deterministic verification result, the trial calculation result, and the feedback data, obtain the confidence score of the candidate salary standard object, and determine the status of the candidate salary standard object based on the confidence score, the probe pass rate, and the number of blocking failures, thereby obtaining the candidate salary standard object that has passed verification; wherein, the confidence score is calculated based on the scores of each verification item in the deterministic verification result, the regression probe score in the trial calculation result, and the historical operational stability score in the feedback data, to obtain the confidence score of the candidate salary standard object; the calculation formula for the regression probe score Sprobe in the trial calculation result is: Sprobe = ProbePassRate × (1 − BlockerPenalty) Wherein, ProbePassRate represents the probe pass rate, which is the ratio of the number of sample wages that passed the trial calculation to the total number of sample wages in the preset sample wages; BlockerPenalty represents the blocking failure penalty, and the calculation formula for the blocking failure penalty is as follows: BlockerPenalty = min(BlockerCount / TotalProbeCount, 1.0) Wherein, BlockerCount represents the number of blocking failures, that is, the number of failed sample wages that caused the calculation process to terminate; TotalProbeCount represents the total number of probes; The deterministic execution module is configured to perform salary calculation by calling the corresponding salary calculation standard based on the verified candidate salary standard object; The automatic rollback module is configured to collect actual execution deviations and correction records in real time during salary calculation. When the actual execution deviation meets preset rollback trigger conditions, it rolls back to the previous published version of the salary standard object, records the rollback result, and uses it as feedback data for the generation of the next round of candidate salary standard objects. The rollback result includes the rollback reason, rollback time, scope of impact, and related salary slip identifiers. The preset rollback trigger conditions include: DeviationRate>D_max or CriticalSlipMismatchCount ≥ N_max Where DeviationRate represents the actual execution deviation rate; D_max represents the maximum allowable deviation threshold; CriticalSlipMismatchCount represents the number of critical payroll mismatches; and N_max represents the threshold for the number of critical payroll mismatches.

9. An electronic device, characterized in that, include: A memory that stores a computer program; The processor, which is communicatively connected to the memory, executes the method for generating and verifying multi-domain salary calculation standards based on a large model, as described in any one of claims 1 to 7, when calling the computer program.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by the processor, it implements the method for generating and verifying multi-domain salary calculation standards based on a large model, as described in any one of claims 1 to 7.

Images