A method and system for constructing and reasoning on business entity relationships based on ontology modeling

Abstract

The application relates to a business entity relationship construction and reasoning method and system based on ontology modeling, and belongs to the field of artificial intelligence. In the method, an arrangement entity receives business demand description information from a business consumption entity; the arrangement entity triggers a forward reasoning agent to perform forward cause-effect reasoning operation on the business demand description information under the direction of a business entity relationship rule graph; a reverse reasoning agent performs verification on the forward cause-effect reasoning operation through reverse cause-effect reasoning under the direction of the business entity relationship rule graph, and obtains a reasoning result of the business demand description information when the verification is passed; the business entity relationship rule graph is constructed based on the business rule relationship of each business entity; and the arrangement entity sends the reasoning result to the business consumption entity.

Description

Technical Field

[0001] This invention belongs to the field of artificial intelligence and relates to a method and system for constructing and reasoning business entity relationships based on ontology modeling. Background Technology

[0002] In scenarios such as knowledge graph reasoning, intelligent customer service, and industrial diagnostics, intelligent agents are often used to perform multi-hop reasoning on knowledge graphs and business rule sets to complete tasks such as attribution analysis and decision generation. For example, in an e-commerce intelligent customer service system, the agent needs to infer the root cause of customer complaints and compensation solutions based on knowledge such as order status, logistics records, and compensation rules.

[0003] However, ensuring the accuracy and reliability of reasoning to match user needs remains a current research challenge. Summary of the Invention

[0004] In view of this, in order to solve the above problems, the present invention provides a method and system for constructing and reasoning business entity relationships based on ontology modeling.

[0005] To achieve the above objectives, the present invention provides the following technical solution:

[0006] Firstly, a method for constructing and reasoning business entity relationships based on ontology modeling is provided. This method is applied to an intelligent agent system, which includes an orchestration entity, a forward-reasoning agent, and a backward-reasoning agent. The method includes: the orchestration entity receiving business requirement description information from a business consumer entity; the orchestration entity triggering the forward-reasoning agent to perform forward causal reasoning on the business requirement description information under the guidance of a business entity relationship rule graph; and the backward-reasoning agent to perform verification of the forward causal reasoning operation through reverse causal reasoning under the guidance of the business entity relationship rule graph, and obtaining the reasoning result of the business requirement description information if the verification passes; the business entity relationship rule graph is constructed based on the business rule relationships of each business entity; and the orchestration entity sending the reasoning result to the business consumer entity.

[0007] Therefore, this method orchestrates entities to trigger forward-reasoning agents to perform forward causal reasoning, and simultaneously triggers backward-reasoning agents to perform reverse causal reasoning verification on the forward reasoning results. Only after successful verification is the reasoning result returned to the business consumer entity. This collaborative approach of forward reasoning and reverse verification transforms the reliability assurance of reasoning from traditional post-hoc verification or external evaluation into a necessary step within the reasoning task itself. Before outputting a conclusion, the system proactively performs a consistency check on its own reasoning logic, ensuring that the reasoning result is no longer a single conclusion from unidirectional reasoning, but a self-consistent conclusion verified by reverse logic. This enhances the accuracy and reliability of complex business reasoning, enabling it to better meet users' needs for accurate reasoning results.

[0008] Optionally, the orchestration entity triggers a forward-reasoning agent to perform forward causal reasoning operations on the business requirement description information under the guidance of the business entity relationship rule graph, and a reverse-reasoning agent to perform verification of the forward causal reasoning operations through reverse causal reasoning under the guidance of the business entity relationship rule graph. If the verification passes, the agent obtains the reasoning result of the business requirement description information. This includes: the orchestration entity sending the business requirement description information to the forward-reasoning agent and sending a reverse-reasoning start instruction to the reverse-reasoning agent; the forward-reasoning agent performing forward causal reasoning operations in M ​​stages according to the business requirement description information under the guidance of the business entity relationship rule graph, and the reverse-reasoning agent performing verification on the forward causal reasoning operations in M ​​stages respectively under the guidance of the business entity relationship rule graph; M is an integer greater than 1; in response to the verification passing, the forward-reasoning agent sends the reasoning result obtained from the Mth stage of the forward causal reasoning operation in the M stages to the orchestration entity.

[0009] Therefore, by breaking down the forward causal reasoning operation into M stages and having the reverse-reasoning agent perform verification on each stage separately, phased control of the entire reasoning process is achieved. Compared to the method of verifying only the final reasoning result once, this method disperses and advances the verification points to each reasoning stage, allowing reasoning errors in an intermediate stage to be detected immediately at the end of that stage. This avoids the propagation and amplification of errors in subsequent reasoning stages and reduces subsequent invalid computations caused by errors in the preceding stages.

[0010] Optionally, the forward-reasoning agent, guided by the business entity relationship rule graph, sequentially executes M stages of forward causal reasoning operations based on the business requirement description information. The reverse-reasoning agent, responding to the reverse-reasoning initiation instruction, performs verification on each of the M stages of forward causal reasoning operations, guided by the business entity relationship rule graph. This includes: for the i-th stage among the M stages, i=1,2,…,M: the forward-reasoning agent obtains the i-th input information and, guided by the business entity relationship rule graph, executes the i-th stage of forward causal reasoning operations based on the i-th input information, outputting the causal conclusion of the i-th stage; where i=1, the i-th input information is the business requirement description information; where i> In case 1, the i-th input information is the causal conclusion of the (i-1)-th stage; the reverse-reasoning agent responds to the reverse-reasoning initiation instruction, and under the guidance of the business entity relationship rule graph, performs reverse causal reasoning on the causal conclusion of the i-th stage to obtain the reverse causal conclusion of the i-th stage; if the reverse causal conclusion of the i-th stage indicates that the causal conclusion of the i-th stage is correct, the reverse-reasoning agent determines that the verification of the i-th stage has passed, thereby triggering the forward-reasoning agent to continue to execute the forward causal reasoning operation of the (i+1)-th stage, and i+1 is less than or equal to M; if i=M, and the verification of the M-th stage has also passed, the forward-reasoning agent sends the causal conclusion of the M-th stage as the reasoning result to the orchestration entity.

[0011] Therefore, the reasoning conclusion of the i-th stage serves as the input for the (i+1)-th stage, forming the inter-stage data transfer in the reasoning chain. Simultaneously, the reverse-reasoning agent performs inverse causal reasoning on the causal conclusions of each stage, allowing the forward-reasoning agent to proceed to the next stage only after successful verification. This combination of stage-by-stage advancement and stage-by-stage verification ensures that subsequent forward reasoning is built upon conclusions already verified by reverse reasoning. The confidence level of the final reasoning result gradually accumulates with each stage, avoiding the risk of unverified intermediate conclusions directly participating in downstream reasoning.

[0012] Optionally, the forward-reasoning agent acquires the i-th input information and, guided by the business entity relationship rule graph, performs the i-th stage of forward causal reasoning based on the i-th input information, outputting the causal conclusion of the i-th stage. This includes: the forward-reasoning agent acquiring the i-th input information; the forward-reasoning agent using the factual information in the i-th input information as the starting point of reasoning, determining the matching entity relationship in the business entity relationship rule graph and triggering at least one business rule corresponding to the entity relationship, so as to perform forward traversal from the reasoning starting point to the conclusion direction based on the entity relationship and at least one business rule, forming the i-th causal jump chain; the forward-reasoning agent generating the i-th conclusion information based on the i-th causal jump chain, and the causal conclusion of the i-th stage includes the i-th conclusion information and the i-th causal jump chain.

[0013] Therefore, the forward-reasoning agent takes the factual information in the i-th input information as the starting point for reasoning, performs a forward traversal along the entity relationships and business rules in the graph towards the conclusion, and outputs a stage causal conclusion containing the i-th conclusion information and the i-th causal jump chain. This i-th causal jump chain records the sequence of entity relationships and business rules traversed from the factual information to the conclusion information, making the internal logical link of forward reasoning explicitly output and recorded, providing a traceable verification basis for the downstream reverse-reasoning agent.

[0014] Optionally, guided by the business entity relationship rule graph, the reverse-reasoning agent performs inverse causal reasoning on the causal conclusion of the i-th stage to obtain the inverse causal conclusion of the i-th stage. This includes: the reverse-reasoning agent extracting the i-th conclusion information and the i-th causal jump chain from the causal conclusion of the i-th stage; the reverse-reasoning agent using the i-th conclusion information as the starting point of reasoning, and based on the entity relationships in the business entity relationship rule graph and at least one business rule, performing reverse-direction segment-by-segment reverse derivation on the i-th causal jump chain to verify whether the i-th conclusion information can be reverse-directed segment-by-segment to the factual information in the i-th input information; if the i-th conclusion information is reverse-directed segment-by-segment to the factual information in the i-th input information, the reverse-reasoning agent generates the inverse causal conclusion of the i-th stage indicating that the causal conclusion of the i-th stage is correct.

[0015] Therefore, the reverse-engineering agent does not freely search the graph for a path back to the facts from the conclusion. Instead, starting with the i-th conclusion information, it forcibly reverses the original path indicated by the i-th causal jump chain, performing reverse deduction segment by segment to verify whether this path can deduce the factual information in the i-th input information in reverse. This segment-by-segment reverse deduction method can test whether the sequence of business rules used in forward reasoning is logically consistent in reverse, thereby identifying possible rule misuses in the forward reasoning process. Even when multiple rules can lead to the same conclusion, attribution errors can be discovered by verifying the bidirectional reversibility of the specific rule chain used in the forward reasoning.

[0016] Optionally, the method further includes: if the inverse causal conclusion of the i-th stage indicates that the causal conclusion of the i-th stage is incorrect, the reverse agent generates task update information based on the interruption position of the reverse inference segment by segment, and sends a verification failure indication carrying the task update information to the orchestration entity. The task update information is used to instruct the forward agent to re-execute the i-th stage of forward causal reasoning operation, which is different from the historical reasoning, from the interruption position.

[0017] Therefore, when the backward reasoning is interrupted at a certain point, the backward agent generates task update information based on that interruption point, carries it to the orchestration entity via a verification failure indication, and then the orchestration entity triggers the forward agent to re-execute a forward causal reasoning operation from that interruption point, different from the historical reasoning. This ensures that retries after verification failures are not simply repeated traversals of the previous erroneous path, but rather targeted re-reasoning with a clear starting point and guided by feedback information. This reduces invalid computations during retrying and improves the efficiency of the inference system in recovering from errors.

[0018] Optionally, the forward-pushing agent and the backward-pushing agent share logical resources to achieve cognitive load balancing.

[0019] The method further includes: the forward-pushing agent, based on a hash function, determines a target logical resource partition from the candidate logical resource partition set containing the entity relationships required by the i-th input information, according to the stage number of the i-th stage and the task context identifier corresponding to the business requirement description information, and sends the target logical resource partition to the reverse-pushing agent; wherein, the candidate logical resource partition set belongs to multiple logical resource partitions, and the multiple logical resource partitions are divided into business entity relationship rule graphs according to semantic dimensions, the same entity relationship is allowed to exist simultaneously in different logical resource partitions of multiple logical resource partitions, and multiple logical resource partitions correspond one-to-one with multiple semantic dimensions; accordingly, based on the entity relationship and at least one business rule... The process involves performing a forward traversal from the starting point of reasoning towards the conclusion to form the i-th causal jump chain. This includes: the forward-reasoning agent performing a forward traversal from the starting point of reasoning towards the conclusion based on entity relationships and at least one business rule, within the semantic dimension corresponding to the forward traversal pattern in the target logical resource partition, to form the i-th causal jump chain; correspondingly, the process involves performing a reverse segment-by-segment reverse derivation on the i-th causal jump based on entity relationships and at least one business rule in the business entity relationship rule graph, within the semantic dimension corresponding to the reverse traversal pattern in the target logical resource partition, to form the i-th causal jump chain.

[0020] Therefore, the forward-propagating agent uses a hash function to determine a target logical resource partition for each inference stage from logical resource partitions corresponding to multiple semantic dimensions, and sends this partition to the reverse-propagating agent. Under the same semantic dimension constraint of the target partition, the forward-propagating and reverse-propagating agents collaborate in forward and reverse traversal modes, respectively. On one hand, the hash function maps based on stage number and task context identifier, allowing different stages or task instances to be assigned to different semantic dimension partitions. This encourages the inference system to approach the problem from different semantic perspectives at different stages, avoiding the use of the same cognitive path for each inference, thus achieving cognitive load balancing. On the other hand, assigning the same partition to two agents in both forward and reverse modes ensures that reverse verification and forward inference are performed within the same semantic context and rule boundaries, guaranteeing the validity of the verification.

[0021] Optionally, the input parameters of the hash function include the stage number of the i-th stage and the task context identifier; the mapping logic of the hash function is configured as follows: for the same stage number and task context identifier, it is mapped to the same target logical resource partition; for different stage numbers or task context identifiers, it is mapped to different target logical resource partitions.

[0022] Therefore, the input parameters of the hash function are explicitly defined as the stage number and the task context identifier. Its mapping logic ensures that the same input will necessarily map to the same target logical resource partition, while different inputs will map to different target logical resource partitions. This deterministic mapping mechanism provides a precise control means for cognitive load balancing, making the switching of inference perspectives strictly bound to the characteristics and progress of the inference task. It can both break the cognitive inertia of inference by utilizing the discreteness of hashing and ensure the reproducibility of the same inference stage of the same task.

[0023] Secondly, an intelligent agent system is provided, comprising an orchestration entity, a forward inference agent, and a backward inference agent. The intelligent agent system is configured as follows: the orchestration entity receives business requirement description information from a business consumer entity; the orchestration entity triggers the forward inference agent to perform forward causal reasoning on the business requirement description information under the guidance of a business entity relationship rule graph; and the backward inference agent to perform verification of the forward causal reasoning operation through reverse causal reasoning under the guidance of the business entity relationship rule graph, and, if the verification passes, obtains the reasoning result of the business requirement description information; the business entity relationship rule graph is constructed based on the business rule relationships of each business entity; and the orchestration entity sends the reasoning result to the business consumer entity.

[0024] Thirdly, a control terminal is provided, including a memory and a processor, wherein the memory is used to store computer programs and the processor is used to execute the computer programs to implement the method of the first aspect.

[0025] The objectives and other advantages of this invention can be realized and obtained through the following description. Attached Figure Description

[0026] To make the objectives, technical solutions, and advantages of the present invention clearer, the preferred embodiments of the present invention will be described in detail below with reference to the accompanying drawings, wherein:

[0027] Figure 1 A schematic diagram of the architecture of an intelligent agent system provided by the present invention;

[0028] Figure 2 A flowchart illustrating a method for constructing and reasoning business entity relationships based on ontology modeling, provided by this invention;

[0029] Figure 3 This is a schematic diagram of the structure of a control terminal provided by the present invention. Detailed Implementation

[0030] The following specific examples illustrate the implementation of the present invention. Those skilled in the art can easily understand other advantages and effects of the present invention from the content disclosed in this specification. The present invention can also be implemented or applied through other different specific embodiments, and various details in this specification can be modified or changed based on different viewpoints and applications without departing from the spirit of the present invention. It should be noted that the illustrations provided in the following embodiments are only schematic representations of the basic concept of the present invention. In the absence of conflict, the following embodiments and features in the embodiments can be combined with each other. The accompanying drawings are for illustrative purposes only, representing only schematic diagrams and not actual physical objects, and should not be construed as limiting the present invention. To better illustrate the embodiments of the present invention, some parts in the drawings may be omitted, enlarged, or reduced, and do not represent the actual product form.

[0031] like Figure 1 The diagram shown is an architectural representation of an intelligent agent system provided in this application. The system includes an orchestration entity, a forward-pushing agent, and a backward-pushing agent.

[0032] like Figure 1 As shown in the figure, this application provides an architecture diagram of an intelligent agent system. The system includes an orchestration entity, a forward-pushing intelligent agent, and a backward-pushing intelligent agent.

[0033] An orchestration entity is the system's scheduling unit, responsible for unified scheduling, process management, and external interaction. In terms of form, an orchestration entity can be an independent software service, a microservice instance, a containerized component, or embedded as a function library in a business application. In terms of deployment, orchestration entities can run on physical servers, virtual machines, cloud hosts, or edge computing nodes. In distributed scenarios, multiple instances of an orchestration entity can be deployed, communicating with forward and backward inference agents via remote procedure calls (RPC) or message queues, and employing master-slave or clustered approaches to improve system availability and fault tolerance. Functionally, the orchestration entity provides a unified business interface to receive business requirement descriptions from business consumer entities. The orchestration entity triggers the forward inference agent to perform forward causal reasoning operations and triggers the backward inference agent to perform reverse causal reasoning verification of the forward inference operations. The orchestration entity manages the cyclical flow of reasoning and verification: when verification passes, the forward inference agent is allowed to continue to the next stage of reasoning; when verification fails, the forward inference agent is triggered to re-execute the reasoning based on the verification failure indication returned by the backward inference agent. Finally, the orchestration entity obtains the inference results from the forward agent and returns them to the business consumer entity.

[0034] The forward reasoning agent is the system's forward reasoning execution unit, responsible for performing multi-hop forward traversal along entity relationships and rules, guided by the business entity relationship rule graph, starting from known facts, and gradually deriving causal conclusions. It should be noted that the specific implementation of the forward reasoning agent can utilize existing agent technologies, and this application does not impose any restrictions on this. For example, the forward reasoning agent can adopt an agent architecture based on a large language model, guiding the large language model according to the staged reasoning process defined in this application through prompt word engineering, performing forward traversal and rule triggering operations under the guidance of the business entity relationship rule graph. The forward reasoning agent can also adopt an agent architecture based on reinforcement learning, treating the business entity relationship rule graph as part of the environment state space, and the forward traversal of entity relationships and the triggering of business rules as the action space, outputting the causal jump chains and causal conclusions of each reasoning stage through a policy network. The forward reasoning agent can also adopt an agent architecture based on symbolic reasoning, performing deterministic forward multi-hop reasoning on the graph data through a predefined reasoning rule engine and pattern matching algorithm. This application does not limit the internal architecture and training method of the forward-propagating agent. Its focus is on the phased forward causal reasoning operation performed by the forward-propagating agent, the formation and output of the causal jump chain, and the process of phase advancement and retry based on the scheduling of orchestrated entities and the verification feedback of the backward-propagating agent. For details, please refer to the following method embodiments.

[0035] The reverse-engineering agent is the system's reverse verification execution unit. Guided by the business entity relationship rule graph, it performs reverse deduction from the causal conclusions output by the forward-engineering agent, following the reverse direction of the causal jump chain used in forward reasoning, to verify the logical consistency of the forward reasoning. It should be noted that the specific implementation of the reverse-engineering agent can also utilize existing agent technologies, and this application does not impose any restrictions on this. For example, the reverse-engineering agent can adopt the same or different agent architecture as the forward-engineering agent. When using an agent architecture based on a large language model, prompt word engineering can guide the large language model to perform a segment-by-segment reverse deduction process according to the method defined in this application, starting from the conclusion information and verifying segment by segment along the causal jump chain to see if the antecedent facts of each business rule are consistent with the factual contract information. When using an agent architecture based on symbolic reasoning, a predefined reverse rule library and graph reverse traversal algorithm can be used to perform deterministic reverse verification on each reasoning step in the causal jump chain. This application does not limit the internal architecture and training method of the reverse-engineering agent. Its focus is on the reverse-direction, segment-by-segment reverse derivation operation performed by the reverse-engineering agent, the generation of reverse causal conclusions, and the process of generating task update information based on the interruption position when verification fails. See the following method embodiments for details. The reverse-engineering agent and the forward-engineering agent can be deployed on the same or different computing nodes and communicate with the orchestration entity via HTTP, RPC, or message queues.

[0036] It should be noted that the forward-pushing agent and the backward-pushing agent are logically two independent functional entities, but in physical implementation, they can be deployed as two independent processes or service instances, or as two different session instances or threads in the same intelligent agent runtime environment on the same computing node.

[0037] like Figure 2 As shown in the embodiments, this application provides a method for constructing and reasoning business entity relationships based on ontology modeling, which is applied to the system described in the above embodiments.

[0038] The specific process of this method is as follows:

[0039] like Figure 2 As shown, this application provides a method for constructing and reasoning business entity relationships based on ontology modeling, which is applied to the system described in the above embodiments. The specific flow of this method is as follows.

[0040] S201, the orchestration entity receives business requirement description information from the business consumer entity.

[0041] A business consumer entity is a functional entity that initiates business inference requests to the intelligent agent system. In terms of form, a business consumer entity can be a software module, a microservice, a user interface within a business system, or a caller from a third-party system accessing the system through an open interface. The orchestration entity provides a unified business interface to receive business requirement descriptions submitted by the business consumer entities. This business interface can be a Representational State Transfer (REST) ​​interface, an RPC interface, a message queue interface, or other forms of application programming interface (API). The orchestration entity establishes a communication connection with the business consumer entity through this interface.

[0042] Business requirement description information is a description of the business problem that needs to be solved by the business consuming entity. In terms of information format, business requirement description information can be natural language text, such as "Why hasn't my order O20231005 been shipped yet?" entered by a user in an intelligent customer service dialog box; it can also be structured data, such as key-value pairs like {"Order Number": "O20231005", "Problem Type": "Logistics Delay"}; or it can be semi-structured data, such as composite data structures in Extensible Markup Language (XML) or JavaScript Object Notation (JSON) formats. After receiving the business requirement description information, the orchestration entity can perform preprocessing operations on it. Preprocessing operations include, but are not limited to, text segmentation, entity recognition, intent classification, and field validation. The purpose of preprocessing is to convert the business requirement description information into an input format that the forward-reasoning agent can directly use, facilitating the extraction of factual information for reasoning.

[0043] As one triggering scenario, a business consumer entity can send business requirement description information to an orchestration entity in response to a business request from a user terminal. The user terminal can be an electronic device with human-computer interaction capabilities, such as a smartphone, tablet, personal computer, or smart customer service terminal. After the user inputs a business question through an application interface or web page on the user terminal, the business consumer entity encapsulates the user's input into a business requirement description and submits this description to the orchestration entity by calling its business interface. As another triggering scenario, the business consumer entity can also be an alarm module in a monitoring system. When a preset abnormal condition is detected, it automatically generates a business requirement description containing an anomaly description and sends it to the orchestration entity. For example, when an industrial equipment monitoring system detects that the temperature of a device exceeds a threshold, it automatically generates a business requirement description containing the device number, the abnormal indicator, and the current value to trigger the orchestration entity to perform fault attribution reasoning. After receiving the business requirement description, the orchestration entity uses it as the initial input for subsequent positive causal reasoning operations.

[0044] S202, the orchestration entity triggers the forward inference agent, which performs forward causal reasoning operations on the business requirement description information under the guidance of the business entity relationship rule graph, and the reverse inference agent, which performs verification on the forward causal reasoning operations through reverse causal reasoning under the guidance of the business entity relationship rule graph, and obtains the reasoning result of the business requirement description information if the verification passes; the business entity relationship rule graph is constructed based on the business rule relationships of each business entity.

[0045] Specifically, S202 includes the following steps:

[0046] Step 1: The orchestration entity sends business requirement description information to the forward-pushing agent and a reverse-pushing start instruction to the reverse-pushing agent.

[0047] Upon receiving the business requirement description information, the orchestration entity sends it as initial input to the forward inference agent. Simultaneously, the orchestration entity sends a reverse inference start instruction to the reverse inference agent. This instruction notifies the reverse inference agent to enter a standby verification state, preparing to perform reverse causal reasoning verification on the subsequent causal conclusions output by the forward inference agent. The reverse inference start instruction can carry a task context identifier for this inference task, allowing the reverse inference agent to associate forward and reverse verification of the same inference task in subsequent processing. The task context identifier can be a combination of key fields extracted from the business requirement description information (e.g., "order delay + VIP customer"), or a unique task identifier assigned to this inference task by the orchestration entity after receiving the business requirement description information. Furthermore, the orchestration entity can also send the task context identifier along with the business requirement description information to the forward inference agent.

[0048] Step 2: Under the guidance of the business entity relationship rule graph, the forward-reasoning agent sequentially executes M stages of forward causal reasoning operations based on the business requirement description information. In response to the reverse-reasoning start instruction, the reverse-reasoning agent performs verification on each of the M stages of forward causal reasoning operations under the guidance of the business entity relationship rule graph; M is an integer greater than 1.

[0049] The business entity relationship rule graph serves as the common basis for both forward-reasoning agents performing forward causal reasoning and backward-reasoning agents performing inverse causal reasoning in this method. The construction of this graph involves two stages: the first stage is domain ontology modeling, and the second stage is business rule function binding.

[0050] In the domain ontology modeling phase, entity types and entity relationships are defined for the target business domain. An entity type refers to an abstract object category with independent semantics within the business domain. Each entity type contains a set of attributes to describe the characteristics of that type of entity. Entity relationships refer to the semantic associations between entity types. Each entity relationship is directional, connecting two entity types. Taking an e-commerce intelligent customer service scenario as an example, the defined entity types include: customer, order, order line, product, warehouse, logistics record, and compensation rule. Specifically, the attributes of the customer entity include customer ID, name, and membership level; the attributes of the order entity include order number, order time, promised delivery time, and order status; the attributes of the product entity include product ID, product name, and product type; the attributes of the warehouse entity include warehouse ID, warehouse name, and warehouse address; the attributes of the logistics record entity include logistics tracking number, sorting record, transportation node, and receipt status; and the attributes of the compensation rule entity include rule number, applicable conditions, and compensation content. The defined entity relationships include: the "order placement" relationship between customers and orders (direction: customer → order), the "inclusion" relationship between orders and order lines (direction: order → order line), the "correspondence" relationship between order lines and products (direction: order line → product), the "storage" relationship between products and warehouses (direction: product → warehouse), the "association" relationship between orders and logistics records (direction: order → logistics record), the "handling" relationship between logistics records and warehouses (direction: logistics record → warehouse), and the "application" relationship between orders and compensation rules (direction: order → compensation rule).

[0051] During the business rule function binding phase, business rule functions are bound to the entity types and entity relationships defined above, forming a rule-based knowledge graph containing business logic deduction capabilities, namely, a business entity relationship rule graph. Business rule functions are formal encapsulations of the decision logic, calculation logic, and constraint logic in the business domain. Binding a business rule function to an entity relationship means that when a forward-looking agent traverses along an entity relationship from the starting entity to the ending entity, the business rule function bound to that entity relationship is triggered. Using the attribute values ​​and associated facts of the starting entity as input parameters, the function calculates the output result and passes it along the graph as a new reasoning fact. Multiple business rule functions can be bound to the same entity relationship, and the system selectively triggers one or more of them based on the conditional matching of the input parameters. Taking e-commerce intelligent customer service scenarios as an example, regarding the "association" between "orders" and "logistics records," a "delay level determination" business rule function is bound. Its determination logic is as follows: input the promised delivery time of the order and the actual arrival time of each transportation node in the logistics record; calculate the difference between the actual time and the promised delivery time; and output the delay level based on a preset delay threshold range. For example, a difference of less than 4 hours outputs "mild delay," a difference between 4 and 24 hours outputs "moderate delay," and a difference exceeding 24 hours outputs "extreme delay." Regarding the "handling" relationship between "logistics records" and "warehouses," a "responsibility attribution" business rule function is bound. Its determination logic is as follows: input the operation records of the sorting center and the inbound and outbound records of each warehouse in the logistics record; and determine the responsibility attribution based on the specific node where the anomaly occurred. For example, if the anomaly occurs in the missorting operation of the sorting center, it is attributed to "internal logistics missorting"; if the anomaly occurs in the third-party transportation link, it is attributed to "external transportation delay." Regarding the "applicability" relationship between "orders" and "compensation rules," a "compensation scheme calculation" business rule function is bound. Its calculation logic is as follows: input the delay level of the order, the customer's membership level, and the type of responsibility attribution, and output the corresponding compensation scheme according to the preset compensation mapping table. For example, "extreme delay + VIP customer + internal responsibility" corresponds to "refund of shipping fee of 50 yuan + compensation of 200 yuan voucher," and "minor delay + ordinary customer + external responsibility" corresponds to "compensation of 20 yuan voucher."

[0052] It should be noted that the business rule functions in the business entity relationship rule graph are not limited to decision and calculation functions, but can also include query functions and constraint functions. Query functions are used to obtain real-time information required for reasoning from external data sources, such as querying the real-time inventory of a product in the current warehouse from a warehouse management system; constraint functions are used to verify whether the preconditions on the reasoning path are met, such as verifying whether a customer's number of returns exceeds the return rights limit. The binding of business rule functions enables the business entity relationship rule graph to not only store the static structure of entities and relationships, but also internalize the business logic that can be automatically invoked and executed, allowing forward and backward reasoning agents to complete a complete reasoning loop from facts to conclusions and from conclusions back to facts under the guidance of the graph.

[0053] For ease of understanding, the following description uses the e-commerce intelligent customer service scenario as an example to provide an overall overview of the construction results of the business entity relationship rule graph. In this graph, there exists a complete reasoning chain starting from the "order" node, triggering the "delay level judgment" rule through the "order-association → logistics record" relationship, then triggering the "responsible party attribution" rule through the "logistics record-handling → warehouse" relationship, and finally triggering the "compensation scheme calculation" rule through the "order-applicable → compensation rule" relationship. When the forward-reasoning agent traverses forward from the fact of order delay, it triggers the above rules sequentially, forming a causal reasoning chain from "order delay" to "compensation scheme." When the reverse-reasoning agent performs reverse verification starting from the compensation scheme, it deduces segment by segment along the reverse direction of the same chain to verify whether the compensation scheme can uniquely trace back to the original fact of order delay.

[0054] For the i-th stage out of M stages, i=1,2,…,M:

[0055] The specific value of M is dynamically determined by the forward-propagating agent based on the complexity of the information described in the business requirements and the depth of the relationships between relevant entities and the rule links in the graph. For example, for a simple requirement that only needs to query the order status, M can be 2, with the first stage performing status query reasoning and the second stage performing result confirmation reasoning; for complex claims requirements involving delay determination, liability attribution, and compensation calculation, M can be 3 or a larger value, with each stage corresponding to one of the above reasoning steps.

[0056] For a forward-pushing agent, the following operations are performed:

[0057] The forward-propagating agent obtains the i-th input information and, guided by the business entity relationship rule graph, performs the i-th stage of forward causal reasoning based on the i-th input information, outputting the causal conclusion of the i-th stage; where, when i=1, the i-th input information is the business requirement description information; when i>1, the i-th input information is the causal conclusion of the (i-1)-th stage.

[0058] Specifically, the forward-propagating agent acquires the i-th input information. Using the factual information in the i-th input information as the starting point for reasoning, the agent determines matching entity relationships in the business entity relationship rule graph and triggers at least one business rule corresponding to each entity relationship. Based on the entity relationships and at least one business rule, it performs a forward traversal from the starting point towards the conclusion, forming the i-th causal jump chain. The forward-propagating agent generates the i-th conclusion information based on the i-th causal jump chain. The causal conclusion at the i-th stage includes the i-th conclusion information and the i-th causal jump chain.

[0059] To facilitate understanding, let's illustrate this with a specific reasoning task from an e-commerce intelligent customer service scenario. Assume the business requirement is described as follows: "VIP customer Li Si complains that order O20231005, promised delivery within 4 hours, has not arrived after 24 hours, and requests an explanation and compensation." Let M be 3.

[0060] In Phase 1 (i=1), the i-th input information is the description of the business requirement. The forward-propagating agent extracts factual information from this input, including: order number O20231005, customer Li Si, VIP membership level, promised delivery time of 4 hours, and current status "not arrived". Using this factual information as the starting point for reasoning, the forward-propagating agent locates the order entity node with order number O20231005 in the business entity relationship rule graph and matches the "association" between the order and the logistics record. The forward-propagating agent traverses this entity relationship in a forward direction, triggering the "delay level determination" business rule function bound to this relationship. This rule function takes the promised delivery time of 4 hours and the actual 24 hours shown in the logistics record as input, calculates 24-4=20 hours, determines that it falls within the threshold range of "extreme delay" (exceeding 24 hours), and outputs the delay level as "extreme delay". The forward-propagating agent takes "Order O20231005 → Association → Logistics Record → Trigger Delay Level Judgment Rule → Output Extreme Delay" as the first causal jump chain and "Order O20231005 is in an extremely delayed state" as the first conclusion information. The causal conclusion of the first stage includes the first conclusion information and the first causal jump chain.

[0061] In the second stage (i=2), the i-th input information is the causal conclusion of the first stage. The forward-reasoning agent inherits the factual information confirmed in the first stage (order O20231005 is extremely delayed) from this input information and uses it as the starting point for reasoning. It continues to perform a forward traversal along the "handling" relationship between the logistics record and the warehouse in the business entity relationship rule graph, triggering the "responsibility attribution" business rule function bound to this relationship. This rule function takes the mis-sorting operation record of the sorting center in the logistics record as input and determines that the responsibility is attributable to "internal logistics mis-sorting". The forward-reasoning agent takes "extremely delayed order → handling → warehouse → triggering responsibility attribution rule → outputting internal logistics mis-sorting" as the second causal jump chain and "responsibility is internal logistics mis-sorting" as the second conclusion information. The causal conclusion of the second stage includes this second conclusion information and this second causal jump chain.

[0062] In stage 3 (i=3), the i-th input information is the causal conclusion of stage 2. The forward-reasoning agent inherits the factual information confirmed in the first two stages (order O20231005 is extremely delayed, the responsible party is internal logistics misallocation) and the customer's VIP level information from this input information. Using this as the starting point for reasoning, it performs a forward traversal along the "applicability" relationship between the order and the compensation rule in the business entity relationship rule graph, triggering the "compensation plan calculation" business rule function bound to this relationship. This rule function takes "extreme delay", "VIP", and "internal responsibility" as inputs and matches the corresponding compensation plan in the preset compensation mapping table as "refund of 50 yuan shipping fee + compensation of 200 yuan voucher". The forward-pushing agent takes "extreme delay + VIP + internal responsibility → applicable → compensation rule → trigger compensation scheme calculation rule → output refund of 50 yuan + 200 yuan voucher" as the third causal jump chain, and "compensation scheme is refund of shipping fee of 50 yuan + compensation of 200 yuan voucher" as the third conclusion information. The causal conclusion of the third stage includes the third conclusion information and the third causal jump chain.

[0063] Optionally, the forward-pushing agent and the backward-pushing agent share logical resources to achieve cognitive load balancing, which will be described in detail below.

[0064] Logical resources refer to the set of cognitive elements that an agent can control and traverse within the business entity relationship rule graph when performing forward or backward causal reasoning. Unlike physical computing resources (such as CPU cores, memory, and network bandwidth), which are scheduled based on computing power allocation, logical resources are scheduled based on allocation from a cognitive perspective. The specific forms of logical resources include: reachable subsets of entity relationships in the graph, callable clusters of business rule functions, and accessible inference path regions. The partitioning of a logical resource is not based on the topology of the underlying physical server, but rather on the semantic structure of the business entity relationship rule graph itself.

[0065] Cognitive load balancing refers to scheduling the logical resources allocated to forward and backward reasoning agents in a single reasoning phase. This ensures that different reasoning phases or instances of reasoning tasks maintain differences in cognitive dimensions such as semantic entry points, rule hit order, and path exploration range, preventing agents from using fixed cognitive paths for extended periods across multiple inference attempts. The technical goal of cognitive load balancing differs from physical load balancing, which aims for a uniform distribution of computational tasks across multiple physical nodes. Instead, it seeks diversity at the cognitive level within the reasoning system, thereby reducing the risk of reasoning bias due to cognitive inertia and enhancing the system's adaptability to different types and characteristics of business problems.

[0066] For example, the business entity relationship rule graph can be divided into multiple logical resource partitions according to semantic dimensions. The same entity relationship is allowed to exist simultaneously in different logical resource partitions of multiple logical resource partitions, and multiple logical resource partitions correspond one-to-one with multiple semantic dimensions. Taking the e-commerce intelligent customer service scenario as an example, the business entity relationship rule graph can be divided into three logical resource partitions according to three semantic dimensions: "customer rights," "logistics responsibility," and "risk control compliance." In the "customer rights" partition, there are entity relationship subsets with customer → order (order placement relationship) and order → compensation rule (applicable relationship) as the core perspective of customer experience and rights protection, as well as business rule function clusters such as compensation scheme calculation rules and membership rights matching rules bound to it. In the "logistics responsibility" partition, there are entity relationship subsets with logistics link tracking and responsibility determination as the core perspective of order → logistics record (association relationship) and logistics record → warehouse (handling relationship), as well as business rule function clusters such as delay level judgment rules and responsible party attribution rules bound to it. The "Risk Control and Compliance" section includes a subset of entity relationships centered on risk identification and compliance auditing, such as customer → order (order placement relationship) and order → payment record, as well as a cluster of business rule functions bound to it, including fraud detection rules and abnormal transaction judgment rules. It is evident that the "customer → order" entity relationship exists in both the "customer rights" and "risk control and compliance" logical resource sections, but the associated business rule function clusters and corresponding reasoning directions differ in the different sections.

[0067] It should be noted that the logical resource partitioning can be pre-divided and stored by the orchestration entity based on the semantic structure of the graph during system initialization, or it can be dynamically partitioned and cached for reuse by the forward-propagating agent when it first executes the inference task, based on the task type and semantic clustering algorithm. This application does not impose specific limitations on this. The boundaries between the logical resource partitions are not physically isolated, but rather logically provide the agent with different cognitive entry points and rule cluster priorities.

[0068] The forward-pushing agent, based on a hash function, determines a target logical resource partition from the set of candidate logical resource partitions containing the entity relationships required by the i-th input information, according to the stage number of the i-th stage and the task context identifier corresponding to the business requirement description information. This target logical resource partition is then sent to the backward-pushing agent. The input parameters of the hash function include the stage number i and the task context identifier C. The task context identifier C can be a numerical value obtained by character encoding of a combination of key fields extracted from the business requirement description information. Each candidate logical resource partition in the set is pre-assigned a unique partition identifier, which can be a numeric number indicating which logical resource partition it is within the set.

[0069] The hash function's mapping logic is configured as follows: for the same stage number and task context identifier, it maps to the same target logical resource partition; for different stage numbers or task context identifiers, it maps to different target logical resource partitions. As an exemplary implementation, the hash function's calculation process can be represented as follows: First, the stage number i and the task context identifier C are concatenated into an intermediate string. This concatenation can be done by converting i to a string and then concatenating it with the string representation of C. Then, a preset hash operation is performed on this intermediate string to obtain a hash value. The hash operation can use a secure hash algorithm (such as SHA-256) to perform a digest calculation on the intermediate string, or it can use a non-encrypted hash algorithm (such as MurmurHash) to perform a hash calculation on the intermediate string. Finally, the hash value is moduloed by the total number of partitions K in the candidate logical resource partition set to obtain the modulo result, which is the partition identifier of the target logical resource partition. The hash function's calculation expression is: Partition identifier of target logical resource partition = H(i,C)modK. Where H represents the hash algorithm used, mod represents the modulo operation, and K is the total number of partitions in the candidate logical resource partition set.

[0070] The mapping logic of this hash function guarantees that: when both the stage number i and the task context identifier C are the same, the concatenated intermediate strings are the same, the hash values ​​calculated by the hash algorithm are the same, and the modulo result is also the same. Therefore, they are mapped to the same partition identifier, i.e., the same target logical resource partition, ensuring the reproducibility of the same inference stage of the same task. When the stage number i or the task context identifier C is different, the concatenated intermediate strings are different, and the hash values ​​calculated by the hash algorithm change accordingly. After modulo operation, they are mapped to different partition identifiers, thus allocating them to different target logical resource partitions, enabling inference in different stages or different tasks to be executed under differentiated semantic dimensions.

[0071] To facilitate understanding, a specific example from an e-commerce intelligent customer service scenario will be used for illustration. Assume the candidate logical resource partition set contains three logical resource partitions, corresponding to the semantic dimensions of "customer rights," "logistics responsibility," and "risk control compliance," with partition identifiers of 0, 1, and 2 respectively, i.e., K=3. The business requirement description is "VIP customer Li Si complained about order O20231005, which was promised delivery in 4 hours but actually failed to arrive in 24 hours." The key field combination extracted is "order delay + VIP," which, after ASCII character encoding conversion, yields the task context identifier C, let's assume C=20231005. In the first stage, i=1, and the concatenated intermediate string is "120231005." Performing a SHA-256 hash operation on this string yields a hash value. Taking the modulo 3 of this hash value, assuming the modulo result is 1, then the partition identifier of the target logical resource partition is 1, i.e., the "logistics responsibility" partition. In stage 2, i=2, and the concatenated intermediate string is "220231005". A hash operation is performed on this string, and the modulo operation is taken with 3. Assuming the modulo result is 0, the partition identifier of the target logical resource partition is 0, i.e., the "Customer Rights" partition. In stage 3, i=3, and the concatenated intermediate string is "320231005". A hash operation is performed on this string, and the modulo operation is taken with 3. Assuming the modulo result is 2, the partition identifier of the target logical resource partition is 2, i.e., the "Risk Control and Compliance" partition. It can be seen that the three different stages of the same inference task are assigned to three logical resource partitions with different semantic dimensions, achieving cognitive load balancing between stages.

[0072] It should be noted that the above-described hash function calculation method is only an exemplary implementation. In specific implementations, other delimiters or encoding methods can be used for concatenation, and the hash algorithm can be replaced with other functions with hashing properties. The partition identifier can be a numeric sequence number or a string identifier. When the candidate logical resource partition set changes, the K value in the modulo operation is adjusted accordingly. All of the above changes fall within the protection scope of this application, and this application does not impose any specific limitations on them.

[0073] Therefore, the above-mentioned forward traversal from the starting point of reasoning to the conclusion, based on entity relationships and at least one business rule, to form the i-th causal jump chain, includes: the forward-propagating agent, based on entity relationships and at least one business rule, and in the semantic dimension corresponding to the forward traversal mode in the target logical resource partition, performs forward traversal from the starting point of reasoning to the conclusion to form the i-th causal jump chain.

[0074] For ease of understanding, we will continue to use the three-stage inference task in the aforementioned e-commerce intelligent customer service scenario as an example to illustrate the scheduling process of cognitive load balancing. Assume the candidate logical resource partition set contains three logical resource partitions: partition identifier 0 corresponds to the "Customer Rights" partition, partition identifier 1 corresponds to the "Logistics Responsibility" partition, and partition identifier 2 corresponds to the "Risk Control and Compliance" partition. The task context identifier C, after encoding, has a value of 20231005, and K=3.

[0075] The forward traversal mode refers to the working mode where the forward-thinking agent, under the constraints of the semantic dimension corresponding to the target logical resource partition, traverses along the natural direction of entity relationships (i.e., from the starting entity to the ending entity), and prioritizes calling the business rule function cluster bound within that partition for reasoning. Conversely, the reverse traversal mode refers to the working mode where the backward-thinking agent, under the same semantic dimension constraints of the same target logical resource partition, traverses along the reverse direction of entity relationships (i.e., from the ending entity to the starting entity), and calls the same business rule function cluster for verification in the reverse direction. The forward-thinking agent and the backward-thinking agent work collaboratively within the same target logical resource partition using the forward traversal mode and the reverse traversal mode respectively, ensuring that forward reasoning and reverse verification are performed within the same semantic context and rule boundaries.

[0076] In Phase 1 (i=1), the hash function calculates the target logical resource partition based on i=1 and C=20231005. The concatenated string "120231005" is hashed using SHA-256 and modulo 3. Assuming the modulo result is 1, the "Logistics Responsibility" partition with partition identifier 1 is selected as the target logical resource partition. The forward-thinking agent, based on entity relationships and at least one business rule, performs a forward traversal from the inference starting point to the conclusion within the semantic dimension corresponding to the forward traversal pattern of the target logical resource partition, forming the first causal jump chain. Within the semantic dimension of "Logistics Responsibility," the forward-thinking agent prioritizes entity relationships and business rules related to logistics link tracking and timeliness monitoring. For example, the forward-thinking agent prioritizes forward traversal along the entity relationship "Order → Association → Logistics Record," triggering the "Delay Level Judgment" rule bound to this relationship. This rule uses the promised delivery time of the order and the actual arrival time of each transportation node in the logistics record as input parameters to calculate the difference between the actual time taken and the promised delivery time, and determines the delay level as "Extreme Delay" based on a preset delay threshold range. The forward-thinking agent uses "Order O20231005 → Association → Logistics Record → Trigger Delay Level Judgment Rule → Output Extreme Delay" as the first causal jump chain. It should be noted that if the first stage is assigned to the "Customer Rights" partition, when the forward-thinking agent performs reasoning in the semantic dimension of this partition in a forward traversal mode, it will prioritize entity relationships and business rules related to customer experience and service commitments. For example, it will prioritize forward traversal along the entity relationship "Order → Association → Service Level Agreement," triggering the "Service Commitment Breach Judgment" rule bound to this relationship. This rule uses the promised delivery time of the order and the customer's historical waiting tolerance time as input parameters to determine the severity of the breach. It is evident that when reasoning is performed in a forward traversal mode under different semantic dimensions at the same reasoning stage, the entity relationships matched by the forward-reasoning agent and the business rules triggered are different, and the entry point of reasoning and the intermediate conclusions output also differ.

[0077] In Phase 2 (i=2), the hash function calculates the target logical resource partition based on i=2 and C=20231005. The concatenated string "220231005" is hashed and modulo 3. Assuming the modulo result is 0, the "Customer Rights" partition with partition identifier 0 is selected as the target logical resource partition. The forward-thinking agent, based on entity relationships and at least one business rule, performs a forward traversal from the reasoning starting point to the conclusion within the semantic dimension corresponding to the forward traversal pattern of the target logical resource partition, forming the second causal jump chain. Building upon the "extreme delay" fact confirmed in Phase 1, under the semantic dimension of "Customer Rights," the forward-thinking agent prioritizes entity relationships and business rules related to customer identity, rights level, and historical behavior. For example, the forward-thinking agent prioritizes a forward traversal along the entity relationship "order → order placement → customer," triggering the "customer profile analysis" and "VIP benefits matching" rules bound to this relationship. These rules take the customer's historical consumption records, membership level, complaint frequency, etc., as input parameters and output customer profile tags and benefits priorities. The forward-thinking agent uses "extremely delayed order → order placement → customer → triggering customer profile analysis rules and VIP benefits matching rules → outputting VIP high-value customers" as the second causal jump chain. It should be noted that if the second stage is assigned to the "logistics responsibility" partition, when the forward-thinking agent performs reasoning in the forward traversal mode under the semantic dimension of this partition, it will prioritize a forward traversal along the entity relationship "logistics record → handling → warehouse," triggering the "responsibility attribution" rule, which uses the sorting center operation records and warehouse inbound and outbound records as input parameters to determine the attribution of responsibility. It is evident that the causal jump chains formed by the forward traversal mode in the second stage are different in the "Customer Rights" and "Logistics Responsibility" sections. The former produces a customer profile conclusion, while the latter produces a responsibility attribution conclusion.

[0078] In stage 3 (i=3), the hash function calculates the target logical resource partition based on i=3 and C=20231005. The concatenated string "320231005" is hashed and modulo 3. Assuming the modulo result is 2, the "Risk Control and Compliance" partition with partition identifier 2 is selected as the target logical resource partition. The forward-thinking agent, based on entity relationships and at least one business rule, performs a forward traversal from the reasoning starting point to the conclusion within the semantic dimension corresponding to the forward traversal pattern of the target logical resource partition, forming the third causal jump chain. Building upon the "extreme delay" and "VIP high-value customer" facts confirmed in the first two stages, under the semantic dimension of "risk control and compliance," the forward-thinking agent prioritizes entity relationships and business rules related to risk assessment, compliance auditing, and anomaly detection. For example, the forward-thinking agent prioritizes forward traversal along entity relationships such as "order → association → payment record" and "customer → association → historical order," triggering the "compensation compliance verification" and "abnormal claim detection" rules bound to these relationships. The "Compensation Compliance Verification" rule uses the compensation plan and company compensation policy as input parameters to verify whether the current compensation plan meets internal audit requirements. The "Abnormal Claim Detection" rule uses the customer's historical return records, complaint frequency, and order amount as input parameters to assess whether there is a risk of abuse in this claim. After the verification is passed, the forward-pushing agent triggers the "Compensation Plan Calculation" rule to output the final compensation plan. The forward-pushing agent uses "Extreme Delay + VIP High-Value Customer → Association → Payment Record → Association → Historical Order → Trigger Compensation Compliance Verification Rule and Abnormal Claim Detection Rule → Verification Passed → Trigger Compensation Plan Calculation Rule → Output Refund of 50 Yuan Shipping Fee + 200 Yuan Compensation Voucher" as the third causal jump chain. It should be noted that if the third stage is assigned to the "Customer Rights" partition, when the forward-pushing agent performs reasoning in a forward traversal mode under the semantic dimension of this partition, it will skip the compensation compliance verification and abnormal claim detection steps and directly trigger the "Compensation Plan Calculation" rule and the "Member Rights Matching" rule to generate the compensation plan, lacking the verification step of the risk control compliance dimension.

[0079] In the three-stage reasoning process described above, the first stage is executed in the "Logistics Responsibility" partition using a forward traversal pattern corresponding to the semantic dimension; the second stage is executed in the "Customer Rights" partition using a forward traversal pattern corresponding to the semantic dimension; and the third stage is executed in the "Risk Control and Compliance" partition using a forward traversal pattern corresponding to the semantic dimension. Each stage has a different semantic perspective, and the entity relationships and triggered business rules prioritized by the forward-pushing agent change accordingly in each stage. This avoids the rigidity of the reasoning path and the uniformity of rule triggering caused by traversing the graph from the same semantic perspective in all stages, thus achieving cognitive load balancing. Similarly, the reverse-pushing agent, in each stage, executes a reverse traversal pattern within the corresponding target logic resource partition, deducing step-by-step in the reverse direction of the causal jump chain of each stage. Forward and reverse verification are completed within the same semantic dimension.

[0080] For the reverse agent, the following operations are performed:

[0081] In response to the reverse initiation instruction, the reverse agent performs reverse causal reasoning on the causal conclusion of the i-th stage under the guidance of the business entity relationship rule graph, and obtains the reverse causal conclusion of the i-th stage. If the reverse causal conclusion of the i-th stage indicates that the causal conclusion of the i-th stage is correct, the reverse agent determines that the verification of the i-th stage has passed, so as to trigger the forward agent to continue to execute the forward causal reasoning operation of the i+1-th stage, and i+1 is less than or equal to M.

[0082] Specifically, the reverse-reasoning agent extracts the i-th conclusion information and the i-th causal jump chain from the causal conclusion of the i-th stage. Using the i-th conclusion information as the starting point for reasoning, the reverse-reasoning agent performs a segment-by-segment reverse derivation of the i-th causal jump chain based on the entity relationships in the business entity relationship rule graph and at least one business rule. This verifies whether the i-th conclusion information can be reverse-reasoned segment-by-segment to the factual information in the i-th input information. If the i-th conclusion information is reverse-reasoned segment-by-segment to the factual information in the i-th input information, the reverse-reasoning agent generates a reverse causal conclusion for the i-th stage indicating that the causal conclusion of the i-th stage is correct.

[0083] Reverse-direction segment-by-segment reverse derivation refers to the process where the reverse-derivation agent starts with the i-th conclusion information and proceeds in the reverse direction along the business rule and entity relationship traversal path indicated by the i-th causal jump chain, performing a segment-by-segment reverse traversal. At each segment of the reverse traversal, the reverse-derivation agent verifies whether the prerequisite facts required by the corresponding business rule in the reverse direction are satisfied by the fact information in the i-th input information. If the prerequisite facts for each segment are satisfied, and the process ultimately reaches the fact information in the i-th input information, then the reverse-direction derivation is considered successful. If the prerequisite facts at a certain position are not satisfied, then the reverse-direction derivation is considered to have failed; this position is the interruption point of the reverse-direction segment-by-segment reverse derivation.

[0084] To facilitate understanding, we will take the reasoning in the first stage of the above e-commerce intelligent customer service scenario as an example to explain the process of the reverse-engineering agent performing reverse derivation segment by segment and verifying the result.

[0085] In the first phase, the forward-reasoning agent outputs the first causal conclusion, which includes the first conclusion information "Order O20231005 is in a state of extreme delay" and the first causal jump chain "Order O20231005 → Association → Logistics Record → Trigger Delay Level Judgment Rule → Output Extreme Delay". The backward-reasoning agent extracts the first conclusion information "extreme delay" and the first causal jump chain from this causal conclusion. Using the first conclusion information "extreme delay" as the starting point, the backward-reasoning agent performs reverse reasoning segment by segment along the reverse direction indicated by the first causal jump chain.

[0086] The first reverse derivation: Starting from the conclusion "extreme delay," the reverse agent performs a reverse derivation of the "delay level determination" rule. The prerequisite for this rule in the reverse direction is that the difference between the actual delivery time of the order and the promised delivery time should fall within the threshold range corresponding to "extreme delay," i.e., the difference exceeds 24 hours. The reverse agent extracts the factual information from the first input information for verification: the promised delivery time for order O20231005 is 4 hours, and the logistics record shows that 24 hours have actually passed, resulting in a difference of 20 hours. The condition 20 hours > 24 hours is not met, and this prerequisite fact is not satisfied. Therefore, the reverse agent determines that the first reverse derivation is interrupted at the "delay level determination" rule; the interruption point is the "delay level determination" rule itself.

[0087] In the example above, the first conclusion information failed to be reversed segment by segment through the first causal jump chain to the factual information in the first input information, and the agent was forced to generate a reverse causal conclusion indicating that the causal conclusion of the first stage was incorrect.

[0088] To facilitate understanding of the process of the backward agent generating task update information and triggering the forward agent to retry, we will continue the explanation from the previous example. The backward agent generates task update information based on the interruption location, the "delay level determination rule," derived segment by segment in reverse direction. This task update information indicates that when the forward agent re-executes the first phase of forward causal reasoning, it should correct the selection of the threshold range in the delay level determination rule, revising the threshold range from the range corresponding to "extreme delay" to the range matching a difference of 20 hours. The backward agent sends a verification failure indication carrying this task update information to the orchestration entity. The orchestration entity transmits this task update information to the forward agent, triggering the forward agent to re-execute the first phase of forward causal reasoning from the "delay level determination" rule. During retrying, the forward-pushing agent, based on the task update information, invokes the "delay level determination" rule and inputs the corrected threshold range parameters. It calculates that a difference of 20 hours falls within the threshold range (4 to 24 hours) corresponding to "moderate delay," outputting the corrected first conclusion: "Order O20231005 is in a moderate delay state." This forms the corrected first causal jump chain: "Order O20231005 → Association → Logistics Record → Trigger Delay Level Determination Rule → Output Moderate Delay." The corrected causal conclusion of the first stage is then submitted to the backward-pushing agent for verification.

[0089] The reverse-engineering agent performs a reverse-direction, segment-by-segment derivation on the revised causal conclusion of the first stage. The first segment of reverse-direction derivation: Starting from the revised first conclusion information "moderate delay," the reverse-engineering agent performs a reverse-direction derivation on the "delay level judgment" rule. The prerequisite fact required for this rule in the reverse direction is that the difference between the actual time taken for the order and the promised delivery time should fall within the threshold range corresponding to "moderate delay," i.e., the difference is between 4 and 24 hours. The reverse-engineering agent verifies the fact information in the first input information: the promised delivery time for order O20231005 is 4 hours, and 24 hours have actually passed, resulting in a difference of 20 hours. 20 hours falls within the range of 4 to 24 hours, thus the prerequisite fact is satisfied. Since the first causal jump chain contains only one business rule, the first segment of reverse-direction derivation arrives at the fact information in the first input information (the order delay fact). The reverse-engineering agent determines that the first conclusion information is deduced segment by segment in reverse direction through the first causal jump chain to the factual information in the first input information, generating a reverse causal conclusion indicating that the causal conclusion of the first stage is correct, and the first stage verification passes. Based on this, the orchestration entity triggers the forward-engineering agent to continue executing the forward causal reasoning operation of the second stage.

[0090] To facilitate understanding of the process of step-by-step verification of the reverse-engineering agent in multi-stage reasoning, the following provides an overall explanation of the reverse verification results of each stage in the three-stage reasoning task of e-commerce intelligent customer service scenario.

[0091] After the first stage of verification passes, the forward-reasoning agent continues to execute the second stage of reasoning, outputting the causal conclusion of the second stage. Assume that the causal conclusion of the second stage includes the second conclusion information "the responsible party is internal logistics misclassification" and the second causal jump chain "extremely delayed order → handling → warehouse → triggering the responsible party attribution rule → outputting internal logistics misclassification". The backward-reasoning agent extracts information from this causal conclusion, starting with the second conclusion information "internal logistics misclassification", and performs segment-by-segment reverse derivation along the reverse direction of the second causal jump chain. The backward-reasoning agent first performs reverse derivation on the "responsible party attribution" rule, verifying the antecedent facts required for the reverse direction of this rule: whether there are operation records in the logistics records indicating internal misclassification, and whether other possible attributions such as external transportation delays have been excluded. The backward-reasoning agent finds that the logistics records clearly record the misclassification operation at the sorting center, and there are no external transportation anomaly records; the antecedent facts are satisfied. The reverse agent continues to verify the "extreme delay" fact confirmed in Phase 1. This fact has passed Phase 1 verification and has been incorporated into the fact contract information, thus satisfying the prerequisite fact. The reverse agent determines that the second conclusion information is derived from the fact information segment by segment in the reverse direction of the second causal jump chain, and the Phase 2 verification passes.

[0092] After the second stage verification passes, the forward-reasoning agent continues to execute the third stage reasoning, outputting the causal conclusion of the third stage. Assume the causal conclusion of the third stage includes the third conclusion information "the compensation plan is a refund of 50 yuan shipping fee + a 200 yuan voucher" and the third causal jump chain "extreme delay + VIP + internal responsibility → applicable → compensation rule → triggering the compensation plan calculation rule → outputting a refund of 50 yuan shipping fee + a 200 yuan voucher". The backward-reasoning agent starts with the third conclusion information "a refund of 50 yuan shipping fee + a 200 yuan voucher" and performs segment-by-segment reverse derivation along the reverse direction of the third causal jump chain. The backward-reasoning agent performs reverse derivation on the "compensation plan calculation" rule, verifying the prerequisite facts required for the reverse direction of this rule: whether the input parameters are a combination of "extreme delay", "VIP", and "internal responsibility", and whether the output corresponding to this combination in the compensation mapping table is indeed "a refund of 50 yuan shipping fee + a 200 yuan voucher". The agent verifies the confirmed delay level (extreme delay), customer level (VIP), and responsibility attribution (internal logistics misallocation) in the factual contract information. It confirms that the above three input parameters are consistent with the factual contract information, and the output corresponding to this combination in the compensation mapping table is consistent with the third conclusion information. The prerequisite facts are satisfied, and the third stage verification is passed.

[0093] If i=M (M=3) and the verification in the third stage also passes, the forward-thinking agent sends the causal conclusion of the third stage as the reasoning result to the orchestration entity.

[0094] Furthermore, if the inverse causal conclusion of stage i indicates that the causal conclusion of stage i is incorrect, the reverse agent generates task update information based on the interruption position derived segment by segment in the reverse direction and sends a verification failure indication carrying the task update information to the orchestration entity. The task update information is used to instruct the forward agent to re-execute the forward causal reasoning operation of stage i from the interruption position, different from the historical reasoning. For example, in the example of stage 1, the task update information generated by the reverse agent instructs the forward agent to re-execute the reasoning from the "delay level determination" rule and select a different threshold range parameter than the historical reasoning. As another example, suppose that in the forward reasoning of stage 2, the forward agent incorrectly invokes the attribution rule of "external transportation delay" along the "logistics record → handling → warehouse" relationship, while the logistics record in the factual information clearly records an internal sorting center missorting operation. When the reverse-engineering agent performs segment-by-segment reverse reasoning, it performs a reverse verification of the "external transportation delay" attribution rule. It finds that the prerequisite fact (the existence of third-party transportation anomaly records) required for the reverse direction of this rule is not met in the factual information, causing the reverse reasoning to interrupt at this point. Based on the interrupted "external transportation delay attribution rule," the reverse-engineering agent generates task update information, instructing the forward-engineering agent to exclude external attribution paths and select internal attribution paths for traversal when re-executing the second stage of reasoning. The forward-engineering agent then re-executes the reasoning, invoking the "internal logistics misclassification" attribution rule to form a corrected second causal jump chain.

[0095] Optionally, considering cognitive load balancing, the reverse-engineering agent, based on the entity relationships in the business entity relationship rule graph and at least one business rule, performs reverse-direction segment-by-segment reverse derivation on the i-th causal jump chain within the semantic dimension corresponding to the reverse traversal mode of the target logical resource partition. The reverse traversal mode refers to the working mode where the reverse-engineering agent, under the constraints of the semantic dimension corresponding to the target logical resource partition, traverses along the reverse direction of the entity relationships (i.e., from the endpoint entity to the starting entity), and calls the business rule function cluster bound within that partition to perform verification in the reverse direction. The reverse-engineering agent and the forward-engineering agent work collaboratively within the same target logical resource partition using the reverse traversal mode and the forward traversal mode respectively, ensuring that forward reasoning and reverse verification are executed within the same semantic context and rule boundaries, thereby ensuring the effectiveness of the verification.

[0096] To facilitate understanding, we will use the reverse step-by-step derivation within the "Risk Control and Compliance" partition in Phase 3 as an example. In Phase 3, the target logic resource partition is the "Risk Control and Compliance" partition. The forward-pushing agent forms the third causal jump chain in this partition using a forward traversal pattern. The reverse-pushing agent also performs a reverse step-by-step derivation of the third causal jump chain within the same "Risk Control and Compliance" partition using a reverse traversal pattern. Under the semantic dimension of "Risk Control and Compliance," the reverse-pushing agent prioritizes calling the reverse versions of the "Compensation Compliance Verification" and "Abnormal Claim Detection" rules bound within this partition during reverse traversal to verify whether the compensation scheme meets compliance audit requirements and whether there is a risk of claim abuse. Because the forward and reverse probing work together under the same semantic dimension, the effectiveness of the verification is guaranteed. If the third stage is assigned to the "Customer Rights" partition, when the reverse agent performs reverse segment-by-segment reverse derivation in the reverse traversal mode under the semantic dimension of this partition, it will prioritize verifying the reverse antecedent facts of the "Compensation Scheme Calculation" rule and the "Member Rights Matching" rule, and will not verify the antecedent conditions related to risk control and compliance. The focus of verification changes with the switching of semantic dimensions.

[0097] Step 3: In response to the successful verification, the forward agent sends the reasoning result obtained from the forward causal reasoning operation in the Mth stage of the M stages to the orchestration entity.

[0098] S203, the orchestration entity sends the inference result to the business consumer entity.

[0099] After receiving the inference result from the forward-propagating agent, the orchestration entity sends this inference result as the final output of the current inference task to the business consumer entity. This inference result is composed of the causal conclusion of the Mth stage after all M stages of inference have passed reverse verification. The orchestration entity can return the inference result to the business consumer entity through the same business interface as the one used to receive the business requirement description information in S201, or it can send it through a separate callback interface or asynchronous notification interface; this application does not specifically limit this.

[0100] The information format of the inference result corresponds to the format of the business requirement description information submitted by the business consumer entity in S201. When the business requirement description information is natural language text, the inference result can also be returned in the form of natural language text, such as "Upon verification, your order O20231005 was delayed due to internal missorting at the sorting center, which is an internal responsibility. Based on the delay level (extreme delay) and your VIP membership status, we will apply for a refund of 50 yuan for shipping fees and a 200 yuan voucher as compensation, which is expected to arrive within 3 business days." When the business requirement description information is structured data, the inference result can also be returned in the form of structured data, such as the key-value pair format {"Order Number": "O20231005", "Root Cause": "Internal Logistics Missorting", "Delay Level": "Extreme Delay", "Compensation Plan": {"Refund Shipping Fee": "50 yuan", "Voucher": "200 yuan"}, "Expected Arrival": "3 business days"}. When the business requirement description information is semi-structured data, the reasoning results can also be returned in JSON or XML format, including conclusion information and a summary of the key causal links supporting the conclusion.

[0101] It should be noted that the reasoning results not only include the final conclusion information, but also key intermediate conclusions and summaries of causal jump chains verified through back-reasoning at each stage of the reasoning process. This allows business entities or users to trace the entire reasoning process, enhancing the interpretability of the reasoning results. For example, in the reasoning results returned by the orchestration entity to the business entity, in addition to the final compensation plan, information on intermediate reasoning nodes such as the basis for determining the delay level (e.g., the difference between the actual time taken and the promised timeliness) and the basis for attributing responsibility (e.g., misclassification records in logistics records) can be added.

[0102] Furthermore, if, during the entire inference process, the orchestration entity triggers a re-inference by the forward inference agent based on the verification failure indication returned by the backward inference agent, and the number of retries or the total inference time exceeds a preset threshold without all verifications passing, the orchestration entity can return a response to the business consumption entity containing partial inference results and information on the failed verification stages, along with an inference status identifier (such as "partial verification failed"). This allows the business consumption entity to determine whether to initiate a new inference request or transfer the task to manual processing based on the status identifier. The preset threshold can be the maximum number of retries (e.g., a maximum of 3 retries per stage) or the maximum total inference time (e.g., the entire inference task does not exceed 30 seconds), and this application does not specifically limit this.

[0103] After receiving the inference results, the business consumption entity can execute subsequent business operations based on them. For example, in an e-commerce intelligent customer service scenario, the business consumption entity can automatically send the compensation plan from the inference results to the order system to execute refunds and voucher issuance operations, while recording the root cause analysis results in the logistics quality management system for subsequent logistics process improvement.

[0104] In summary, this method orchestrates entities to trigger forward-reasoning agents to perform forward causal reasoning, while simultaneously triggering backward-reasoning agents to perform reverse causal reasoning verification on the forward reasoning results. Only after successful verification is the reasoning result returned to the business consumer entity. This collaborative approach of forward reasoning and reverse verification transforms the reliability assurance of reasoning from traditional post-hoc verification or external evaluation into a necessary step within the reasoning task itself. Before outputting a conclusion, the system proactively performs a consistency check on its own reasoning logic, ensuring that the reasoning result is no longer a single conclusion from unidirectional reasoning, but a self-consistent conclusion verified by reverse logic. This enhances the accuracy and reliability of complex business reasoning, enabling it to better meet users' needs for accurate reasoning results.

[0105] Figure 3 This is a schematic diagram of the structure of a control terminal provided in an embodiment of this application. Exemplarily, the control terminal can be a terminal, or a chip (system) or other component or assembly that can be disposed on the terminal. Figure 3 As shown, the control terminal 200 may include a processor 201. Optionally, the control terminal 200 may also include a memory 202 and / or a transceiver 203. The processor 201 is coupled to the memory 202 and the transceiver 203, for example, via a communication bus.

[0106] The following is combined with Figure 3 A detailed description of each component of the control terminal 200 is provided below:

[0107] The processor 201 is the control center of the control terminal 200. It can be a single processor or a collective term for multiple processing elements. For example, the processor 201 can be one or more central processing units (CPUs), application-specific integrated circuits (ASICs), or one or more integrated circuits configured to implement the embodiments of this application, such as one or more digital signal processors (DSPs), or one or more field-programmable gate arrays (FPGAs).

[0108] Optionally, the processor 201 can perform various functions of the control terminal 200 by running or executing software programs stored in the memory 202 and calling data stored in the memory 202, such as performing the aforementioned functions. Figure 2 The method shown.

[0109] In a specific implementation, as one example, the processor 201 may include one or more CPUs, for example... Figure 3 CPU0 and CPU1 are shown in the diagram.

[0110] In a specific implementation, as one example, the control terminal 200 may also include multiple processors, for example... Figure 3 The processor 201 shown is an example. Each of the processors 201 can be a single-core processor or a multi-core processor. Here, "processor" can refer to one or more devices, circuits, and / or processing cores used to process data (e.g., computer program instructions).

[0111] The memory 202 is used to store the software program that executes the solution of this application, and the processor 201 controls its execution. The specific implementation method can be referred to the above method embodiment, and will not be repeated here.

[0112] Optionally, the memory 202 may be a read-only memory (ROM) or other type of static storage device capable of storing static information and instructions, random access memory (RAM) or other type of dynamic storage device capable of storing information and instructions, or electrically erasable programmable read-only memory (EEPROM), compact disc read-only memory (CD-ROM) or other optical disc storage, optical disc storage (including compressed optical discs, laser discs, optical discs, digital universal optical discs, Blu-ray discs, etc.), magnetic disk storage media or other magnetic storage devices, or any other medium capable of carrying or storing desired program code in the form of instructions or data structures and accessible by a computer, but not limited thereto. The memory 202 may be integrated with the processor 201 or exist independently, and may be connected via the interface circuit of the control terminal 200. Figure 3 (Not shown in the image) is coupled to processor 201, but this embodiment does not specifically limit this.

[0113] Transceiver 203 is used for communication with other control terminals. For example, if control terminal 200 is a terminal, transceiver 203 can be used to communicate with a network device or with another terminal device. Alternatively, if control terminal 200 is a network device, transceiver 203 can be used to communicate with a terminal or with another network device.

[0114] Optionally, transceiver 203 may include a receiver and a transmitter. Figure 3 (Not shown separately). The receiver is used to implement the receiving function, and the transmitter is used to implement the transmitting function.

[0115] Optionally, the transceiver 203 can be integrated with the processor 201, or it can exist independently and be controlled via the interface circuit of the terminal 200. Figure 3 (Not shown in the image) is coupled to processor 201, but this embodiment does not specifically limit this.

[0116] Understandable Figure 3 The structure of the control terminal 200 shown does not constitute a limitation on the control terminal. The actual control terminal may include more or fewer components than shown, or combine certain components, or have different component arrangements.

[0117] Furthermore, the technical effects of the control terminal 200 can be referred to the technical effects of the methods described in the above method embodiments, and will not be repeated here.

[0118] It should be understood that the processor in the embodiments of this application can be a central processing unit (CPU), or it can be other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. The general-purpose processor can be a microprocessor or any conventional processor, etc.

[0119] It should also be understood that the memory in the embodiments of this application can be volatile memory or non-volatile memory, or may include both volatile and non-volatile memory. The non-volatile memory can be read-only memory (ROM), programmable read-only memory (PROM), erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM), or flash memory. The volatile memory can be random access memory (RAM), which is used as an external cache. By way of example, but not limitation, many forms of random access memory (RAM) are available, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), double data rate synchronous DRAM (DDR SDRAM), enhanced synchronous DRAM (ESDRAM), synchronous linked DRAM (SLDRAM), and direct rambus RAM (DR RAM).

[0120] The above embodiments can be implemented, in whole or in part, by software, hardware (such as circuits), firmware, or any other combination thereof. When implemented using software, the above embodiments can be implemented, in whole or in part, as a computer program product. The computer program product includes one or more computer instructions or computer programs. When the computer instructions or computer programs are loaded or executed on a computer, all or part of the processes or functions described in the embodiments of this application are generated. The computer can be a general-purpose computer, a special-purpose computer, a computer network, or other programmable device. The computer instructions can be stored in a computer-readable storage medium or transmitted from one computer-readable storage medium to another. For example, the computer instructions can be transmitted from one website, computer, server, or data center to another website, computer, server, or data center via wired (e.g., infrared, wireless, microwave, etc.) means. The computer-readable storage medium can be any available medium that a computer can access or a data storage device such as a server or data center that includes one or more sets of available media. The available medium can be a magnetic medium (e.g., floppy disk, hard disk, magnetic tape), an optical medium (e.g., DVD), or a semiconductor medium. A semiconductor medium can be a solid-state drive.

[0121] It should be understood that the term "and / or" in this article is merely a description of the relationship between related objects, indicating that three relationships can exist. For example, A and / or B can represent: A existing alone, A and B existing simultaneously, or B existing alone. A and B can be singular or plural. Additionally, the character " / " in this article generally indicates an "or" relationship between the preceding and following related objects, but it can also represent an "and / or" relationship. Please refer to the context for a more accurate understanding.

[0122] In this application, "at least one" means one or more, and "more than one" means two or more. "At least one of the following" or similar expressions refer to any combination of these items, including any combination of single or multiple items. For example, at least one of a, b, or c can mean: a, b, c, ab, ac, bc, or abc, where a, b, and c can be single or multiple.

[0123] It should be understood that in the various embodiments of this application, the order of the above-mentioned processes does not imply the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of this application.

[0124] Those skilled in the art will 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, or a combination of computer software and electronic hardware. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this application.

[0125] Those skilled in the art will understand that, for the sake of convenience and brevity, the specific working processes of the systems, devices, and units described above can be referred to the corresponding processes in the foregoing method embodiments, and will not be repeated here.

[0126] In the several embodiments provided in this application, it should be understood that the disclosed systems, apparatuses, and methods can be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative; for instance, the division of units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components 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 between apparatuses or units may be electrical, mechanical, or other forms.

[0127] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0128] In addition, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit.

[0129] If the aforementioned functions are implemented as software functional units and sold or used as independent products, they can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or a portion of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0130] The above description is merely a specific embodiment of this application, but the scope of protection of this application is not limited thereto. Any changes or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in this application should be included within the scope of protection of this application.

Claims

1. A method for constructing and reasoning business entity relationships based on ontology modeling, characterized in that, The method is applied to an intelligent agent system, the intelligent agent system including orchestration entities, forward-pushing agents, and backward-pushing agents, the method comprising: The orchestration entity receives business requirement description information from the business consumption entity; The orchestration entity triggers the forward-reasoning agent to perform forward causal reasoning on the business requirement description information under the guidance of the business entity relationship rule graph. The reverse-reasoning agent, under the guidance of the business entity relationship rule graph, performs verification on the forward causal reasoning operation through reverse causal reasoning, and obtains the reasoning result of the business requirement description information if the verification passes. The business entity relationship rule graph is constructed based on the business rule relationships of each business entity. The orchestration entity sends the inference result to the business consumption entity.

2. The method according to claim 1, characterized in that, The orchestration entity triggers the forward-reasoning agent to perform forward causal reasoning on the business requirement description information, guided by the business entity relationship rule graph. The reverse-reasoning agent, guided by the business entity relationship rule graph, performs reverse causal reasoning to verify the forward causal reasoning operation. If the verification passes, the inference result of the business requirement description information is obtained, including: The orchestration entity sends the service requirement description information to the forward push agent and a reverse push start instruction to the reverse push agent; The forward-reasoning agent, guided by the business entity relationship rule graph, sequentially executes M stages of forward causal reasoning operations based on the business requirement description information. The reverse-reasoning agent, responding to the reverse-reasoning initiation instruction, performs verification on each of the M stages of forward causal reasoning operations, guided by the business entity relationship rule graph; M is an integer greater than 1. In response to the successful verification, the forward-propagating agent sends the reasoning result obtained from the forward causal reasoning operation of the Mth stage out of the M stages to the orchestration entity.

3. The method according to claim 2, characterized in that, The forward-reasoning agent, guided by the business entity relationship rule graph, sequentially executes M stages of forward causal reasoning operations based on the business requirement description information. The reverse-reasoning agent, responding to the reverse-reasoning initiation instruction, performs verification on each of the M stages of forward causal reasoning operations, guided by the business entity relationship rule graph, including: For the i-th stage among the M stages, i=1,2,…,M: The forward-propagating agent acquires the i-th input information and, guided by the business entity relationship rule graph, performs the i-th stage of forward causal reasoning based on the i-th input information, outputting the causal conclusion of the i-th stage; wherein, when i=1, the i-th input information is the business requirement description information; when i>1, the i-th input information is the causal conclusion of the (i-1)-th stage. In response to the reverse initiation instruction, the reverse inference agent, guided by the business entity relationship rule graph, performs reverse causal reasoning on the causal conclusion of the i-th stage to obtain the reverse causal conclusion of the i-th stage. If the reverse causal conclusion of the i-th stage indicates that the causal conclusion of the i-th stage is correct, the reverse inference agent determines that the verification of the i-th stage has passed, thereby triggering the forward inference agent to continue to execute the forward causal reasoning operation of the (i+1)-th stage, where i+1 is less than or equal to M. If i=M and the verification of the Mth stage is also passed, the forward-propagating agent sends the causal conclusion of the Mth stage as the reasoning result to the orchestration entity.

4. The method according to claim 3, characterized in that, The forward-reasoning agent acquires the i-th input information and, guided by the business entity relationship rule graph, performs the i-th stage of forward causal reasoning based on the i-th input information, outputting the causal conclusion of the i-th stage, including: The forward-propagating agent acquires the i-th input information; The forward-reasoning agent takes the factual information in the i-th input information as the starting point of reasoning, determines the matching entity relationship in the business entity relationship rule graph, and triggers at least one business rule corresponding to the entity relationship. Based on the entity relationship and the at least one business rule, it performs a forward traversal from the starting point of reasoning to the conclusion direction to form the i-th causal jump chain. The forward-propagating agent generates the i-th conclusion information based on the i-th causal jump chain, and the causal conclusion of the i-th stage includes the i-th conclusion information and the i-th causal jump chain.

5. The method according to claim 4, characterized in that, The reverse-reasoning agent, guided by the business entity relationship rule graph, performs inverse causal reasoning on the causal conclusion of the i-th stage to obtain the inverse causal conclusion of the i-th stage, including: The reverse-engineering agent extracts the i-th conclusion information and the i-th causal jump chain from the causal conclusion of the i-th stage; The reverse-engineering agent takes the i-th conclusion information as the starting point of reasoning, and performs reverse segment-by-segment reverse deduction on the i-th causal jump according to the entity relationship in the business entity relationship rule graph and the at least one business rule, thereby verifying whether the i-th conclusion information can be reverse segment-by-segment deduced to the fact information in the i-th input information through the i-th causal jump chain. When the i-th conclusion information is deduced segment by segment in reverse direction through the i-th causal jump chain to the factual information in the i-th input information, the reverse-reasoning agent generates the inverse causal conclusion of the i-th stage indicating that the causal conclusion of the i-th stage is correct.

6. The method according to claim 5, characterized in that, The method further includes: If the inverse causal conclusion of the i-th stage indicates that the causal conclusion of the i-th stage is incorrect, the reverse-reasoning agent generates task update information based on the interruption position of the reverse inference segment by segment, and sends a verification failure indication carrying the task update information to the orchestration entity. The task update information is used to instruct the forward-reasoning agent to re-execute the i-th stage of forward causal reasoning operation from the interruption position, which is different from the historical reasoning.

7. The method according to any one of claims 4-6, characterized in that, The forward-pushing agent and the backward-pushing agent share logical resources to achieve cognitive load balancing.

8. The method according to claim 7, characterized in that, The method further includes: The forward-pushing agent, based on a hash function, determines a target logical resource partition from a set of candidate logical resource partitions containing the entity relationships required by the i-th input information, according to the stage number of the i-th stage and the task context identifier corresponding to the business requirement description information, and sends the target logical resource partition to the reverse-pushing agent; wherein, the set of candidate logical resource partitions belongs to multiple logical resource partitions, and the multiple logical resource partitions are divided according to the semantic dimension of the business entity relationship rule graph. The same entity relationship is allowed to exist simultaneously in different logical resource partitions of the multiple logical resource partitions, and the multiple logical resource partitions correspond one-to-one with multiple semantic dimensions; Accordingly, the step of performing a forward traversal from the starting point of reasoning towards the conclusion, based on the entity relationship and the at least one business rule, to form the i-th causal jump chain, includes: The forward-inductive agent, based on the entity relationship and the at least one business rule, and in the semantic dimension corresponding to the forward traversal mode in the target logical resource partition, performs a forward traversal from the reasoning starting point to the conclusion direction, forming the i-th causal jump chain; Accordingly, the step of performing reverse segment-by-segment reverse derivation on the i-th causal jump based on the entity relationships in the business entity relationship rule graph and the at least one business rule includes: The reverse-engineering agent performs reverse segment-by-segment reverse derivation on the i-th causal jump based on the entity relationships in the business entity relationship rule graph and the at least one business rule, and under the semantic dimension corresponding to the reverse traversal mode of the target logical resource partition.

9. The method according to claim 8, characterized in that, The input parameters of the hash function include the stage number of the i-th stage and the task context identifier; The mapping logic of the hash function is configured such that: for the same stage number and task context identifier, it is mapped to the same target logical resource partition; for different stage numbers or task context identifiers, it is mapped to different target logical resource partitions.

10. An intelligent agent system, characterized in that, The agent system includes an orchestration entity, a forward agent, and a backward agent, and the agent system is configured as follows: The orchestration entity receives business requirement description information from the business consumption entity; The orchestration entity triggers the forward-reasoning agent to perform forward causal reasoning on the business requirement description information under the guidance of the business entity relationship rule graph. The reverse-reasoning agent, under the guidance of the business entity relationship rule graph, performs verification on the forward causal reasoning operation through reverse causal reasoning, and obtains the reasoning result of the business requirement description information if the verification passes. The business entity relationship rule graph is constructed based on the business rule relationships of each business entity. The orchestration entity sends the inference result to the business consumption entity.

Images