Finite State Machine Governance Using a Graph Database
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing governance systems lack the ability to effectively coordinate and adapt to dynamic changes across multiple systems and environments, leading to inefficiencies in managing access, data validation, and compliance in enterprise governance.
Innovation Solution
Implementing governance as finite state machines, where state machine definitions are stored in a graph database, and events trigger transitions and actions to manage and coordinate control decisions across governed systems, using Resource Description Framework (RDF) for definition and communication between distributed instances.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If traditional governance systems are used to manage access and compliance across multiple systems, then implementation is straightforward with centralized control, but the systems lack the ability to effectively coordinate and adapt to dynamic changes across multiple systems and environments
Solution Approach 1:
The patent implements governance as finite state machines that can dynamically transition between states based on events and conditions. The state machine definitions are stored in a graph database, allowing the governance system to adapt its behavior dynamically without requiring complex reconfiguration. Each state machine instance can independently respond to events by transitioning between predefined states, enabling the system to adapt to dynamic changes while maintaining manageable complexity through formal state machine methodology.
Solution Approach 2:
The governance system is segmented into multiple independent state machine instances, each responsible for specific governance aspects. These instances can be distributed across different compute environments and can operate independently while coordinating through shared state machine definitions stored in the graph database. This segmentation allows the system to handle complex governance scenarios by dividing them into manageable, independent state machines that can be developed, deployed, and maintained separately.
2Productivity
If state machine definitions are stored in a graph database to enable distributed governance, then coordination and adaptability improve, but system complexity and query overhead increase
Solution Approach 1:
The graph database serves multiple functions: it stores state machine definitions, maintains the graph structure for efficient querying, and enables distributed access across multiple compute environments. By using a single graph database infrastructure for these diverse purposes, the system achieves improved coordination efficiency without proportionally increasing complexity. The graph data model naturally supports the hierarchical and relational structure of state machine definitions, making the storage and retrieval operations efficient.
Solution Approach 2:
The graph database acts as an intermediary between distributed state machine instances and the governance logic. Instead of having state machine instances directly communicate with each other, they query the graph database for state machine definitions and coordinate through this centralised yet distributed data store. This intermediary approach simplifies the architecture by providing a standardised interface for all interactions while enabling efficient coordination across distributed instances.
3Speed
If events are processed by state machine instances to trigger transitions and actions, then responsive governance is achieved, but event processing overhead and system resource usage increase
Solution Approach 1:
State machine definitions are pre-compiled and stored in the graph database in an optimised format before runtime. When state machine instances are created, they inherit these pre-prepared definitions, avoiding the need to parse and interpret governance logic during event processing. This preliminary preparation of state machine definitions enables rapid event response while minimising computational overhead during actual event handling, as the instances simply evaluate events against their pre-loaded state transitions.
Solution Approach 2:
Each state machine instance independently processes events against its own state and the state machine definitions from the graph database, making autonomous decisions without requiring continuous coordination with other instances. This self-service approach reduces the overall computational overhead by eliminating the need for complex inter-instance communication and coordination during event processing. Each instance efficiently handles events locally while maintaining consistency through shared definitions.
Data Source
AI summary
Systems and methods for providing governance as finite state machines are disclosed. A method may include: a computer program in a compute environment: (1) receiving state machine definitions for a plurality of state machines; (2) saving the state machine definitions in a graph database; (3) receiving an event from one of a plurality of governed systems or a peer computer program in a peer compute environment, an event; (4) querying the graph database for one of the state machine definitions for the event; (5) instantiating a state machine instance using the state machine definitions; (6) executing a transition based on a current state; (7) receiving an instruction from the state machine; and (8) sending the instruction to one or more of the governed systems; wherein the one or more governed systems implement the instruction.