Data Tree Structure for Rule-Based Decision Processing
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing rule-based processing systems face inefficiencies when handling large numbers of rules, leading to prolonged loading times and resource monopolization due to memory requirements, making it challenging to generate decisions quickly and efficiently.
Innovation Solution
A data tree structure is generated based on a rules file, where each rule includes conditions and actions, with condition frequency counts used to optimize the tree structure, allowing for faster processing by traversing only relevant branches, reducing memory usage and improving decision-making speed.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If a large number of rules are stored in a rules file for comprehensive decision-making, then the coverage and completeness of rule-based processing is improved, but the loading time and memory consumption increase significantly
Solution Approach 1:
The patent segments the large rules file into multiple smaller rule sets organized in a tree structure with root nodes, intermediate nodes, and leaf nodes. Each node contains a subset of rules, allowing the system to load only the necessary portions rather than the entire rules file at once. This segmentation enables comprehensive rule coverage while reducing memory consumption and loading time.
Solution Approach 2:
The patent performs preliminary indexing and organization of rules into a tree structure during system initialization or idle periods. The rules are pre-categorized and stored in an optimized format with metadata about rule frequencies and relationships. This preliminary action allows rapid retrieval during actual decision-making without requiring the system to process the entire rules file in real-time.
2Speed
If all rules are loaded into memory for fast access, then processing speed is improved, but memory consumption increases
Solution Approach 1:
The rules are divided into segments organized in a tree structure where only the necessary nodes are loaded into memory based on the specific decision-making context. The system loads root nodes and traverses down to relevant leaf nodes, loading intermediate nodes only when needed. This selective loading maintains fast processing speeds while significantly reducing memory usage compared to loading all rules simultaneously.
Solution Approach 2:
The patent implements a nested tree structure where rule sets are organized in hierarchical levels. Outer layers contain broader categorizations while inner layers contain specific rules. This nesting allows the system to load only the necessary depth of the tree structure required for a given decision, with each level containing only the rules relevant to that specific decision context, thereby optimizing memory usage.
3Reliability
If the rules engine processes all rules for each decision request, then accuracy is improved, but processing time increases
Solution Approach 1:
The tree structure segments the rule set into logical groups and subsets based on decision categories and frequencies. When a decision request arrives, the system identifies the relevant branch of the tree and processes only the rules within that branch rather than evaluating all rules. This segmentation maintains decision accuracy by ensuring all applicable rules are considered while dramatically reducing processing time by excluding irrelevant rules.
Solution Approach 2:
The patent applies local quality optimization by customizing the rule processing path based on the specific decision context. The system analyzes the decision request and traverses only the relevant portions of the tree structure, applying different processing strategies to different branches based on their characteristics. This allows the system to maintain high accuracy for each specific decision type while optimizing overall processing efficiency.
4Adaptability or versatility
If the rules file is updated frequently to reflect changing business requirements, then adaptability is improved, but system redeployment time increases
Solution Approach 1:
The rules file is segmented into independent modules or nodes within the tree structure, each representing a specific business rule or rule set. When business requirements change, employees can update only the specific rule or node that needs modification rather than redeploying the entire rules file. This segmentation enables frequent updates with minimal redeployment time while maintaining full adaptability to changing business needs.
Solution Approach 2:
The patent extracts and isolates individual rules or rule sets from the main rules file into separate, independently manageable units. These extracted rules can be modified, added, or removed without affecting the entire system. This extraction approach allows employees to make targeted updates to specific business rules while leaving the rest of the system unchanged, thereby improving adaptability while minimizing redeployment time.
Data Source
AI summary
A system includes one or more memory devices storing instructions, and one or more processors configured to execute the instructions to perform steps of a method for generating a data tree structure for expediting rule-based decision-making. The system may receive a rules file having a plurality of rules, where each rule has one or more conditions and one or more actions. The system may generate a plurality of condition frequency counts that represent the total number of rules having a condition of a particular unique condition type. The system may then generate a tree structure based on the plurality of rules and the plurality of condition frequency counts, where the tree structure includes a root node and one or more node branches, where each node branch includes a first-level node and zero or more second-level nodes that each include a node condition and zero or more node actions.