GENERATING CONTROL REGULATIONS FROM SCHEMATICIZED REGULATIONS

Description

[0001] The present invention relates to methods, devices, and systems for generating control instructions. The control instructions can be generated fully automatically from a textual formulation of a rule set and can bring a platform into a target state defined in the rule set.

[0002] The operation or functionality of platforms—for example, individual devices, machines, equipment, network-based systems, or controllable systems—is typically specified by rule sets, often summarized in schematized rule texts. These are provided to document the platform's operation and functionality, enabling a wider range of people to understand it. However, controlling the platform, especially during modifications or reconfigurations, often requires a technician to read and interpret the rule texts and translate them into control programs, which are then used to operate the platform. These processes are prone to errors, typically necessitating extensive quality assurance measures.

[0003] Furthermore, particularly with technically sophisticated platforms, incompleteness and inconsistencies can occur even in the formulation of rule texts, which may be difficult to identify and verify within the rule text itself. As a result, even with correct implementation of the rule texts in control and / or regulation programs, the platforms may be programmed in such a way that they are put into states that are undefined, faulty, or inconsistent, which can lead to malfunctions and, in the worst case, endanger the platform's environment.

[0004] US 2008 / 126080 A1 discloses an approach for converting plaintext into structured data. Parse trees for the plaintext are generated based on a natural language grammar. These parse trees are mapped to instance trees, which are generated based on an application-specific model. The best instance tree is then passed to an application for execution.

[0005] It is therefore an object of the present invention to provide a method and a device which automatically translates schematic rule sets or rule texts into control instructions for controlling platforms. Furthermore, an object of the present invention is to enable the verification of such translated rule sets or rule texts with regard to the controlled operation of the platform.

[0006] The aforementioned problem is solved by a method for generating control instructions, a device for generating control instructions, and a system with the features of the main claim and / or the further independent claims. Advantageous embodiments of the invention are defined in the dependent claims. According to the invention, a method for generating control instructions with the features of the main claim is specified.

[0007] The method is a computer-implemented method or a method that can be carried out on a computer, device or computing device which may have at least one processor or processing unit which executes instructions according to method steps of embodiments of the present invention.

[0008] The at least one piece of information can be a schematized statement, but it can be in the form of text. This text should preferably be in a readable form in natural language, so that it can be easily read and understood by humans. Accordingly, the document and / or the at least one piece of information can contain a schematized rule text that formulates the set of rules.

[0009] The at least one piece of information can be structured using a formal language to generate the multitude of syntactic blocks that are then used to construct the terms and symbols. Similarly, the construction can be performed using this formal language.

[0010] The semantic representation corresponds to a comprehensive logical-semantic representation that unambiguously depicts both the semantics of the rule set and its logical relationships. Accordingly, the present invention comprises a transformation of schematized rule texts based on a formal language into a comprehensive logical-semantic representation.

[0011] The semantic representation of the rule set can be checked for consistency and sufficiency. Alternatively or additionally, the check can include further semantic-logical and / or temporary and / or structural properties. This check can form the basis for the subsequent generation of at least one control rule.

[0012] Accordingly, it can only be generated if the check resulted in a positive or permissible outcome.

[0013] This allows a verifiable overall representation to be advantageously generated fully automatically from a readable yet structured specification of a rule set, thus ensuring that the subsequently generated control instructions result in error-free, consistent, and intended control of a target platform specified by the rule set. Preferably, the target platform is a technical system, a mechanical system (IoT), a cloud system, a client system, a SaaS system, a web interface, and the like, and / or control programs executed on the target platform.

[0014] Within the context of this description, the following terms may be defined as follows.

[0015] Mathematical terms or expressions use mathematical operators (e.g., the basic arithmetic operations of addition, subtraction, multiplication, and division) to formulate relationships in a compact, formula-based notation. For example, the relation "gross price = net price * VAT rate" can be expressed concisely and understood in the same way by many people. The linguistic implementation "The gross price corresponds to the product of the net price and the VAT rate" should have the same meaning if "corresponds to" is considered identical to "=" and the formulation "product of A and B" corresponds to the formula "A * B" on a semantic level.

[0016] In logic, logical statements that are not axioms (i.e., not presupposed for the definition of mathematics itself) are considered "true" or "false" if they can be derived from the axioms through equivalent transformations. The connection between logical statements is established through the basic operations "and" and "or." Similarly, "not," as the inverse of a logical statement, can be considered such a basic operation.

[0017] Symbolic logic formulates six logical connectives between statements. Accordingly, symbolic logic can be superior to "normal" logic.

[0018] When several logical statements are made about the same variables (or more generally about an "object"), these statements can be consistent or contradictory. The contradiction is generally expressed by the fact that two logical statements about the same object cannot be both true and false at the same time. The provability of logical statements can have limits.

[0019] Natural language refers to texts that are intuitively understood by people who are proficient in that language. Often, identical content can be expressed using different formulations; conversely, formulations can also be ambiguous. In contrast, formal languages ​​are designed so that statements are unambiguous. Mathematics and computer languages ​​are examples of formal languages ​​that aim to avoid ambiguity in statements.

[0020] In text analysis, various features are extracted from an existing text. These can be purely statistical statements on the formal side (e.g., the number of letters). On the other hand, extracting the coded intention, i.e., the semantic meaning, is also a form of text analysis. The processing of a natural language text by a computer for the purpose of text analysis can be called Natural Language Processing (NLP).

[0021] A statement can originate from a specific text passage used during the analysis. To allow complete traceability, e.g., for error analysis, preferably an entire chain can be generated, from a source in the text, e.g., one of the at least one statement, to a derived statement, e.g., a term of the semantic representation.

[0022] The meaning or intention contained in a text is referred to as semantics. An abstract, data-driven representation of this textual meaning aims to make an equivalent, i.e., synonymous, form of the content accessible to the computer for further processing. This is preferably represented by semantic representation.

[0023] Individual terms and statements often only acquire a concrete and unambiguous meaning within a specific context. All the rules governing the formulation of these relationships are referred to as grammar. Syntax serves to distinguish between multiple sentence components and to determine the permissible order within a sentence structure.

[0024] Variations in natural language (e.g., across geographical areas) are referred to as dialects. Several dialects can blend or diverge more sharply from one another. Preferably, alternative language definitions that arise from the exchange of punctuation, symbols, and syntax can be considered dialects of formal language.

[0025] Actuators can represent signals for controlling machines or actively intervening in existing processes. These signals can include both electromagnetic signals and changes in physical quantities. Furthermore, in the context of the Internet of Things (IoT), for example, command transmissions, such as HTTP requests or any protocol-based requests, or software-based triggering of events, such as XML messages or other structured messages in an enterprise service bus or microservice architecture, can also be referred to as actuators. This invention focuses on the general command transmission for controlling such software or hardware state changes.

[0026] Control can mean the directed influencing of the behavior of a technical system. Regulation can mean the directed influencing of the behavior of a technical system based on current parameters, properties, and characteristics of a technical system. Accordingly, embodiments of the present invention can, in generating control instructions, be located within a sequence control system, for example, a digital sequence control system, which may be capable of triggering actuators of the target platform or a technical system either directly or based on one or more system states, properties, characteristics, and / or sensor information and the control system.

[0027] A set of rules is complete when its statements define a situation without gaps in the definition. Such gaps might include, for example, missing statements about subsystems that are mentioned without corresponding rules. Missing statements can make it impossible to verify the overall fulfillment of the rules. Examining the semantic representation can provide insight into the completeness of the rule set.

[0028] A set of rules is satisfiable, and therefore consistent, if it is free of contradictions, meaning if there is at least one solution such that all its statements can be considered true. Since the statements of the rule set can formulate choices or ranges of values, or contain constraints, a rule set can have more than one solution.

[0029] Contradictions in the statements can relate to parts (e.g., individual versions or subtrees of the logical hierarchy) of the complete rule set. Accordingly, control rules can also be generated for one or more parts of the rule set, which may be achievable.

[0030] If further specifications are made for some of the statements (e.g., during instantiation), the fulfillment of the remaining degrees of freedom may be restricted. Fulfillment is impossible if there is no combination of the remaining options such that all statements in the rule set remain true. Examining the semantic representation can provide information about the fulfillment of the rule set for one or more instances.

[0031] Embodiments of the invention can differ from purely procedural control. Procedural and object-oriented computer languages ​​divide processes, relationships, etc., into individual steps using the "divide and conquer" principle, in order to execute them sequentially and depending on if-then decisions. Control loops can be represented in this way and broken down into manageable parts. It is often not possible to prove the goal achievement and effectiveness of such algorithms as a complete set of rules. The set of rules defined in embodiments of the invention can describe a target situation, but does not necessarily require a sequence of program execution. Instead, it can describe relationships at a purely logical level, which may optionally occur in a temporal sequence. A rule-based control system can completely dispense with if-then structures.Instead, such relationships can be traced back to the feasibility of the overall rule set on a logical level: 1) If the rule set is not feasible, the statements involved in the contradiction can be extracted to generate control signals. This control allows the overall system to be guided back into a permissible control range at a given instance (a compilation of concrete states). On the other hand, 2) within the framework of feasibility, individual options may follow as a necessary consequence of the rules. This consequence can also lead to control instructions according to control sequences. In both cases, logically consistent steps can thus arise that must be taken in the execution of the controlled target system according to the generated control instructions in order to establish or logically develop a consistent state.

[0032] Embodiments of the present invention can differ from purely logic-based programming languages. Logic-based programming languages, such as Lisp or Prolog, define not only the knowledge itself but also how to handle that knowledge in a flexible way and with multiple language constructs. This limits the use of these languages ​​to experts who must formulate the effect of the logical investigation (e.g., inference) themselves within the logic-based programming language. Embodiments of the present invention can preferably go beyond symbolic logic in two respects: in the selection of "n to m out of k options" for OR statements and / or in the integration of temporal sequences, in any combination. Embodiments of the present invention can internally encapsulate inferences and provide the consequences of the determined results in the form of control instructions or open options.Use may be limited to defined purposes, but precisely because of this, it can be directly applied to a control task in the field of a platform or system to be controlled, without requiring in-depth knowledge of the platform or system. The method according to the invention thus advantageously closes the gap between the theoretical level of logic programming languages ​​and the concrete control of a technical system.

[0033] Embodiments of the present invention can differ from pure expert systems. Expert systems typically consist of two components: a knowledge base and a set of methods for drawing additional conclusions from this knowledge. This so-called inference is based on fuzzy reasoning. Heuristics are often used where a complete investigation of the solution space would be too costly. Thus, a sufficiently good solution is determined, but it is not known whether this solution actually represents the optimum. Embodiments of the present invention can differ. While these embodiments also represent knowledge in formal language, they forgo a fuzzy (e.g., fuzzy logic) representation and instead define the concrete interpretation of the formal language in a comprehensible logical-semantic rule.The solutions are calculated entirely within the implemented system, without the use of heuristics. Inference is not used in the invention to gain new knowledge. Conclusions are drawn exclusively within the rule system defined in the formal language.

[0034] Embodiments of the present invention can be distinguished from hybrid control systems. Event-driven control is technically implemented where system states are processed in an "if-then" scheme. The advantage of being able to react independently to specific states allows for a rapid response, e.g., in human-machine interfaces. Often, such systems impose contextual constraints to simplify user interaction and reduce queries / checks. Embodiments of the present invention are not dialog systems that interact directly with the user and represent natural written or spoken language without any restrictions. The invention is always bound to a specific context by the respective definition of how language symbols are represented at the formal language level.Within this context, the rule set undergoes unambiguous processing, formalizing ambiguities within the language symbols but not leaving them open to free interpretation. During or after rule set creation, formal errors, logical errors, and recommendations for simplifying the rule set are identified as part of multi-stage testing processes and can be reported back with reference to the user's "dialect"—both via an interface and in the form of control commands (e.g., triggering an event in the creation system: if the rule set is created in an integrated development environment and sent to embodiments of the present invention for testing, error messages can be returned directly as well as via control commands).Within the application of rules for instances with target states, an embodiment of the present invention generates specific actions to achieve the target in accordance with the rules.

[0035] Embodiments of the present invention can be distinguished from pure machine learning or the concept of artificial intelligence. Artificial intelligence refers to systems whose complex capabilities are similar to human capabilities in certain aspects. The goal is to approximate human performance (controlling autonomous vehicles) or to surpass it (e.g., in Go or chess). These systems operate, for example, using deep learning methods, in which the intermediate representations are not logically interpretable but evidently achieve good results heuristically. Embodiments of the present invention surpass human performance at the level of deriving logical consequences and verifying complex statements. However, this occurs "only" on the basis of mathematical propositional logic, which itself is not considered part of the invention.The invention need not be a system that falls within the field of artificial intelligence, since all statements remain mathematically unambiguous and logically answerable. Embodiments of the present invention react to inputs (rule sets and instantiation) deterministically, not heuristically or statistically.

[0036] Embodiments of the present invention can differ from pure controllers. Technical controllers implement a control loop with direct coupling of inputs and outputs. Systems theory describes a multitude of different models. Depending on the controller, the specifications are followed to a greater or lesser degree, so that, for example, oscillations in a technical system are dampened, which could otherwise lead to instabilities due to time latencies. Models and methods, for example from cybernetics, investigate how natural systems correspond exactly to one of the theoretical models and how these could be technically replicated (black-box approach). Embodiments of the present invention can be used as an implemented system based on a set of rules to control a plant. In this case, however, the control signal refers to the target states defined in the rules, and it is expected that, for example,The window is then controlled by a conventional controller or actuator. The invention only provides this actuator with the instruction to open a window (e.g., via HTTP POST commands), without controlling the actual window opening process. The implemented system derives only the logically necessary or feasible next step from the rule set and passes this on to the executing actuators via suitable control commands.

[0037] Embodiments of the present invention can be distinguished from pure metalanguages. Metalanguages ​​describe program concepts in an abstract way. For example, the Unified Modeling Language (UML) describes the relationships between objects and data structures as well as their flow through the transformation stages of a program. Analogously to how UML formulates objects and their relationships, the formal language formulated in embodiments of the present invention expresses the semantic and logical content of a rule set and structures the concepts / symbols contained therein into levels and relates them to one another. However, the invention goes beyond the definition of the necessary formal language by utilizing the consequences arising from the rule set and its instantiation for control purposes.

[0038] Embodiments of the present invention can differ from simple language translation. Language translations transfer the meaning of a text from one natural language (e.g., German) to another (e.g., English). Since the meaning, while context-dependent by the speaker's domain, can otherwise contain any words and expressions, the complete meaning-preserving translation of texts is a challenge for computational linguistics. Embodiments of the present invention do not need to be able to encode arbitrarily contained semantics of a text. Rather, the system interprets only those parts of a text that correspond to a previously agreed-upon syntax and contain the intended logical expressions of the formal language. Recognized expressions are transferred into the semantic representation.From there, the encoded intention can be transferred into other languages ​​defined by a predefined syntax. The meaning of the rules is fully preserved in this process. This transfer can be described, in the broadest sense, as translation, but is limited exclusively to the constructs contained in the formal language. For example, emotional differences between poems would not be subject to the formal language. Logical rules of belonging, choices, and temporal requirements, on the other hand, can be encoded in the formal language and thus transferred into any other similarly formalized language. This requires the appropriate configuration of the state transitions of the syntax parser and the dialectical symbols.

[0039] Embodiments of the present invention can differ from mere language comprehension. The central task of natural language processing to achieve language comprehension is to resolve the syntactic ambiguities inherent in natural language and to understand the semantic relationships across multiple sentences. The goal is to recognize the pragmatics (intention of the linguistic utterance) and to derive inferences or actions from it. The goal of embodiments of the present invention need not be to generate an understanding of natural language or purely natural language texts. Embodiments of the present invention may require the use of a formal language that, due to its close resemblance to natural language, is easily understood by humans. The aim may be to formulate logical relationships unambiguously without appearing abstract like a programming language.The formal language is adapted to the natural language context of the user's domain using configurable grammar and symbols.

[0040] In one embodiment, the at least one specification includes a textual formulation of the rule set. This textual formulation can be natural language text. The textual formulation in the specification can be encoded and stored arbitrarily within the document, so that the document can be read by a computing device and made available as text, for example, via a user interface.

[0041] According to a further embodiment, the at least one control rule is a target system-dependent control rule. The at least one control rule can be defined via an instance of a target system or a platform, such that a desired target state can be achieved when the at least one control rule is executed on the target system or platform.

[0042] According to the invention, the method further comprises converting the at least one control instruction into a plurality of platform-specific commands for controlling a target platform. The at least one control instruction can be translated into platform-specific commands as shown in the figure. A control instruction can be translated into one or more platform-specific commands.

[0043] In one embodiment, the multitude of platform-specific instructions comprises a multitude of actuators that put the target platform into a target state. The actuators can selectively influence the states, properties, and / or parameters of the target platform and query inputs related to the target platform or its states, properties, and / or parameters.

[0044] In yet another embodiment, the plurality of actuators comprises one or more actuators: one for setting at least one parameter of the target platform, one for reading at least one parameter of a current system state of the target platform, and one for querying a choice. The actuator for setting at least one parameter of the target platform or system can be a command that, when executed by the target platform or system, sets the parameter in the target platform or system. This actuator can also be referred to as a set actuator. The actuator for reading at least one parameter of a current system state of the target platform or system can be a command that, when executed by the target platform or system, reads and provides a value of the parameter in the target platform or system. This actuator can also be referred to as a get actuator.The actuator for querying a choice for at least one parameter of the target platform or system can be an instruction that, when executed by the target platform or system, or any computing device, prompts for a decision regarding a parameter in the target platform or system. For example, a parameter value may be specified within a range, and the instruction can query a specific value (GET actuator). The plurality of actuators can also include an actuator that can supply the target system with control instructions. This actuator can also be referred to as a state actuator. Finally, if several instructions induced by actuators from the plurality of actuators are ranked as having equal priority, for example, through linearization rules, a user-based decision can be incorporated via the actuator for querying a choice.This actuator can also be called a NeedDecision actuator. Preferably, in a fully automatic control system, such a state can be avoided as long as the target system can be kept in a well-defined state.

[0045] According to one embodiment, the conversion involves sequencing the multitude of platform-specific instructions according to at least one linearization rule. The linearization rule can define a sequence of instructions for achieving a desired target state. This can be defined by mapping the control rules to the instructions for a target platform or target system.

[0046] According to the invention, checking the semantic representation includes an automatic check of the rule set for at least one of its criteria: completeness, consistency, and applicability to a specific case. The check can determine whether the rule set is complete or consistent. Furthermore, the check can be performed with regard to one or more instances. Additionally, a target state for the target platform or system can be defined and, if necessary, further specified by values ​​of the instance.

[0047] According to the invention, the semantic representation has at least one semantic tree, wherein the semantic tree has a plurality of terms and symbols.

[0048] Preferably, the at least one semantic tree has a plurality of elements, wherein one or more of the plurality of elements has at least one reference to another element of the plurality of elements.

[0049] The semantic tree can advantageously encode relationships between references or hash tables, thereby increasing the speed of access to the referenced components of the semantic representation. According to one embodiment, the at least one reference is implemented using hashed lists and access indexes.

[0050] According to the invention, the verification of the semantic representation comprises a recursive semantic tree analysis of the at least one semantic tree, wherein the recursive semantic tree analysis starts with terms that represent the roots of the at least one semantic tree. By mapping the semantic representation onto a forest and / or tree structure, verification can be performed by recursively applying test rules, thereby enabling particularly simple verification of the rule set. A forest structure can contain a plurality of semantic trees.

[0051] According to one embodiment, the semantic representation has at least one instantiation, wherein the at least one instantiation has one or more values ​​for symbols of the semantic representation. The instantiation or instance can define a state, target state, or desired state of the target platform or target system. Accordingly, the at least one control instruction can be designed to achieve the state when commands are executed by the target platform or target system. The semantic representation can have multiple instantiations. In each instance, instance-dependent control instructions can be generated. The instance-dependent control instructions can be sequentially dependent on one another, such that a first state is established by means of the control instructions, followed by one or more further states.

[0052] In one embodiment, the method further comprises transferring the semantic representation into a formal text according to the at least one specification in the document. This allows rule sets defined in one language and / or dialect to be converted into another language and / or dialect. This enables the method to be used for language-independent control of a target platform or system. Furthermore, easily understandable descriptions of the operation, process, and / or functionality, optionally also for one or more instantiations, can be formulated fully automatically for the target platform or system.

[0053] The invention further provides a device for generating control instructions, wherein the device is configured to execute a method according to one or more embodiments of the present invention. The device can access a document containing at least one statement that formulates a set of rules. The device can structure the at least one statement to generate a plurality of syntactic blocks. The device can construct terms and symbols from the syntactic blocks to generate a semantic representation. The semantic representation can be checked by the device. The device can generate at least one control instruction based on the checked semantic representation, wherein the at least one control instruction corresponds to the set of rules formulated by the at least one statement.

[0054] The device can be a device with a processor or a processing unit. The device can further comprise a memory that can store instructions which, when executed, configure the processor or the processing unit to carry out the method according to embodiments of the present invention.

[0055] The device can be configured according to preferred embodiments to carry out a method according to any embodiment of the present invention in any combination.

[0056] Furthermore, a system according to the invention is specified, comprising a controllable and / or regulating platform which can be placed into a system state by means of at least one control instruction, at least one storage medium or data carrier which stores at least one specification that formulates a set of rules for the platform, and at least one device which is configured to generate at least one control instruction for the platform from the set of rules formulated by the at least one specification, wherein the at least one device is configured to execute a method according to one or more embodiments of the present invention.

[0057] According to one embodiment, the at least one control instruction places the platform in a target state specified in the set of rules formulated by the at least one specification.

[0058] Embodiments of the method can include any components of the device or system in any combination. Furthermore, embodiments of the device or system can include functional components which can comprise process steps of the method according to embodiments of the present invention in any combination.

[0059] Further advantages of the device and method according to the invention will become apparent from the following description, in which the invention is explained in more detail with reference to exemplary embodiments and the accompanying drawings. These show: Figure 1 is a flowchart of a method for generating control instructions according to an embodiment of the present invention; Figure 2 is a schematic representation of a method for generating control instructions according to an embodiment of the present invention; Figure 3 is a schematic flowchart of a method for the syntactic structuring of textual formulations of a rule set, which is applicable in embodiments of the present invention; Figure 4 is a schematic flowchart of a method for converting syntactic blocks into a semantic representation, which is applicable in embodiments of the present invention; Figure 5 is a schematic representation of a data structure for implementing a semantic representation, which is applicable in embodiments of the present invention;Figure 6 shows a schematic flowchart of a method for generating target system-dependent control instructions, which is applicable in embodiments of the present invention; and Figure 7 shows a schematic representation of a recursive semantic tree analysis, which is applicable in embodiments of the present invention.

[0060] Figure 1Figure 1 shows a flowchart of a method for generating control instructions according to an embodiment of the present invention. The method generates control instructions for a platform. Starting with a rule set 10 containing at least one specification that at least partially formulates the rule set 10, the specification is structured in step 20 to generate a plurality of syntactic blocks. In step 30, terms and symbols are constructed from the syntactic blocks to generate a semantic representation of the rule set 10. The semantic representation is checked in step 40. This can include instantiating the rule set 10 for one or more instances, which may be specified in the rule set 10 itself or which may result from the platform's states. In step 50, at least one control instruction is generated based on the checked semantic representation.The control regulations correspond to the rule set formulated by at least one specification 10.

[0061] In step 60, the at least one control instruction is converted into a multitude of platform-specific commands for controlling a target platform. The control instruction may include a command for controlling the target platform derived from rule set 10.

[0062] Preferably, the platform is a technical system, a mechanical system, an Internet of Things (IoT) system, a cloud system, a client system, and / or at least one control and / or regulation program running on such a platform. The platform can be a technical system of any size. For example, the platform can be an industrial plant or an IoT device. Furthermore, the control instructions can configure any target system, such as a campus management system or a process plant control system. Other systems are conceivable and are also included in the invention.

[0063] The in Figure 1The described method allows a readable and understandable text (source text) to be used for defining rule set 10, whereby the text is automatically converted into a semantic representation to create the control instructions for a target platform. This enables a particularly intuitive use and definition of the control of target systems, which can be simultaneously verified and fully automatically translated into target platform-dependent commands.

[0064] Embodiments of the invention can thus involve the transformation of a formal, yet natural-language-like text into a semantic representation with logical statements, based on a defined formal language definition. This representation can then be used in technical implementation, for example, by a computer program, to control or regulate complex systems or other installations. An advantage of controlling or regulating systems based on this uniform semantic representation lies in the verifiability of consistency. The defined set of rules 10 ensures, both before and during control or regulation, that error states are avoided and that the path to a defined target state of the systems always remains deterministic.

[0065] Here, system components can be combined in a consistent logical model, which guarantees the provability of the rules of rule set 10. This can enable practical applicability in implementation, which may exhibit one or more of the following properties: Generation of control instructions, comprising commands or actuators, taking into account a target state of rule set 10, which can represent a hierarchically logical and temporal overall rule set; definition of a number of selectable options in an "OR set"; layering of semantic levels; expected values ​​that are only assigned upon instantiation of rule set 10 for a specific application; integration of logical and temporal statements; formalization of ambiguities, for example, through value ranges; nested versioning of rule sets; tracing rules of rule set 10 back to the source in the original text; evaluation of mathematical terms with reference to semantic levels; and / or use of a syntactic dialectic to extract the semantic representation from the original text in a user-dependent but unambiguous manner, and conversely, to generate a formal language text from the representation.

[0066] One implementation can combine a representation of a natural-language-like, symbolic logic, which allows for the automatic and unambiguous evaluation of rule sets, with an execution of the logical consequences derived from the rules. The formulation of ambiguities can be controlled, ensuring clear boundaries and maintaining the computability of the problem. The formal language underlying the source text can link temporal dependencies and logical relationships in such a way that deduction, rule compliance, and applicability to individual cases remain manageable. Simultaneously, the formulation of statements can be kept as close as possible to a specific domain and the linguistic terminology used by a user. This enables different users to formulate logical rule sets in a simple and readable way with regard to technical target systems and platforms.

[0067] In a particularly advantageous way, embodiments of the present invention can control or regulate real plants or other complex (computer) systems based on the semantic representation which reflects the rule set 10.

[0068] Figure 2 Figure 1 illustrates a schematic representation of a method for generating control instructions according to an embodiment of the present invention. Figure 2Figure 1 shows a schematic overview of the implementation process for generating control instructions from a rule set 101. The rule set 101 can be formulated as text, whereby a corresponding textual formulation of the rule set 101 can be transformed via syntactic blocks 105 into a semantic representation 110, including its validation 118 and its instantiated evaluation, to generate the control instructions 119, which can be used to control software and / or hardware systems. The transformation can include steps of transforming the syntactic structure 103, extracting semantics 107, decomposing into symbols 108, and generating the target-system-dependent control instructions 116.

[0069] The starting point for generating the semantic representation 110 can be the textual formulation of the rule set 101 in a formal text, taking into account configured dialectical rules from characters 102 and grammar 104. The formal text can contain both defined logical and temporal statements for the rule set 101 and value assignments from one or more instances for symbolic levels, as well as commands required for control, e.g., actuator commands. An instance can be a representation of a concrete situation for the rule set 101. For example, sensor values ​​of a system landscape under consideration or values ​​of an entity of a software system can be represented as a system state. The characters 102 and the grammar 104 can be used within a syntactic structure 103, which is subsequently described in relation to Figure 3As depicted in a preferred embodiment, the formal text can be converted into syntactic blocks 105 for unambiguous interpretation. Preferably, text passages not relevant to the rule mapping, but which may contain important additional explanations for humans, can be extracted, as well as the logical statements and their hierarchical structure.

[0070] After the generation of the structured syntactic blocks 105, the extraction of the semantics 107, which is described below according to a preferred embodiment in Figure 4 As shown, taking into account a semantic catalog 106, the defined (and permissible) logical and temporal statements as well as a version structure of the rule set 101 are transformed into a semantic tree 111, preferably into referencing terms and versions; see also Figure 5for a preferred embodiment. Furthermore, independent of a logical rule hierarchy of the terms, the freely definable symbols / expressions in the formal texts can be decomposed 108 using a symbol classification 109 and represented as symbolic levels 112 with recognized symbol notations as a symbolic dictionary 113 in the symbol structure. In the case of syntactic recognition of an instantiation 114, this additional value information of a symbol can be stored for the derivation of necessary control sequences for a rule evaluation.

[0071] This type of structuring allows the generated semantic representation 110 to be transferred back into a formal text. Since a different dialectic can be used during this reverse transformation, the resulting formal text can correspond to an expected dialectic of the respective user, thereby enabling the rule set 101 to be provided or displayed in a specific domain of the user.

[0072] After the semantic representation 110 has been built with the rule set 101, it can be checked independently of instantiation 118. An advantageous design of the check 118 is described below with regard to Figure 7As described, in step 118, logical inconsistencies in rule set 101 can be detected even before instantiation. This effectively prevents system malfunctions before rule set 101 is used. Since check 118 can be performed continuously, the user can be alerted to logical errors even during the formulation of rule set 101.

[0073] An instantiation 114 can set both current states and a target state to be achieved for any rule within the rule set 101. The rules that must be fulfilled to achieve the target state, as well as the rules pending a decision (e.g., the set of open OR combinations), can be determined, and the actuators identified as missing can be created 116. In a subsequent step, the actuators can be transformed into a linear sequence. This can take into account temporal sequences, version affiliations, and a position in a rule hierarchy according to a current configuration of linearization rules 115. The actuators and corresponding actuator commands defined in an output language 117 can thus be translated into the control rules 119. A definition of the output language 117 could, for example, be...The definition includes HTTP POST requests that can directly trigger the actuators of other software and / or hardware systems via web services. However, it should be understood that the definition may include other commands and other syntactic constructs suitable for defining the output language 117. In the aforementioned exemplary embodiment, for instance, the control of a smart home system can be implemented in the same way as the orchestration of cloud services from complex parallel computer systems.

[0074] If instantiations 114 are transferred to the semantic representation 110 based on control rules 119 (e.g., get actuators regarding sensor values), feedback from instance-dependent states 120 can update the semantic representation 110 of the instance 114. This can occur continuously, i.e., at any time, at selected intervals, or triggered, for example, when a state queried by the control rule 119 changes.

[0075] Figure 3 presents a schematic flowchart of a method for the syntactic structuring of textual formulations of a set of rules, which is applicable in embodiments of the present invention.

[0076] The in Figure 3 The described procedure can be based on the in Figure 1 and 2 set up the procedure shown, for example in procedure step 103 from Figure 2 However, this is by no means necessary. Figure 3illustrates technical steps for translating a formal text into a recursive parser 201, for example the formal text defining the rule set 101 from Figure 2 or of rulebook 10 from Figure 1 , into syntactically structured blocks, which correspond to the syntactic blocks 105 from Figure 2 can correspond. Accordingly, the components from Figure 1 or 2 Reference is made to the following, which is to be understood as an example. For instance, the recursive parser 201 can, among other things, require the dialectical signs 102 and syntax definitions from the dialectical grammar 104 of the language to be analyzed and / or the rule set 101 as a configuration.

[0077] An analysis and transformation of semantic and mathematical expressions in the recursive parser 201 can be technically implemented as a configurable, recursively executed finite automaton. State transitions between all states 203 to 215 can represent the syntax definition as a dialectical grammar 104 of a source language. A state transition can be determined by the next fully recognized character string or its alternatives from the dialectical characters 102, for example, according to the following table. The area before a found character can be processed by an action block, preferably including the storage of a text source and corresponding semantic meanings, and the area after the last found character can be continued linearly or recursively in the subsequent state. A recursion level can therefore have a nesting depth of terms or...correspond to mathematical expressions.

[0078] In this context, the following tokens with the following meaning and encoding can be chosen according to an example, whereby the present invention is not limited to specific symbols, definitions and descriptions. Token name Characters of the first alternative in the default dialect Description SymTokenEqual := Assignment or definition SymTokenAndOpen [ Opening the members of a set of statements connected by logical "and". SymTokenAndClose ] Conclusion of the members of a set of statements connected by logical "and" SymTokenOrOpen { Beginning of the list of members of a set of statements connected by a logical "OR". SymTokenOrClose } End of the list of members of a set of statements connected by a logical "OR". SymTokenVersion # Distinguishing a version definition before the symbol from the subsequent rule statement SymTokenTimeBefore « Separator between a symbol that time before It should be represented by another symbol, or the end of the symbol list according to temporal statements. SymTokenTimeAfter » Separator between a symbol that after It should be represented by another symbol, or the end of the symbol list according to temporal statements. SymTokenAdvice ! Beginning of a recommendation that starts after this sign SymTokenCheck ? Beginning of a test statement that starts after this symbol SymTokenGroup ∼ Beginning or end of the list of members of a set of statements that are not logically connected, but are only possibly grouped under a new symbolic name. SymTokenFunctionOpen ( The beginning of a sequence of argument values ​​for a function. The function name is expected before the parentheses. SymTokenFunctionClose ) Conclusion of a sequence of argument values ​​for a function. SymTokenOpPlus + Infix operator for addition SymTokenOpMinus - Infix operator for subtraction SymTokenOpMultiply * Infix operator for multiplication SymTokenOpDivide / Infix operator for division SymTokenCompEqual == Comparison operator for equal values SymTokenCompLess < Comparison operator for a smaller value SymTokenCompLessEqual <= Comparison operator for a less than or equal value SymTokenCompGreater > Comparison operator for a larger value SymTokenCompGreaterEqual >= Comparison operator for a greater than or equal to value SymTokenGlobalMax +∞ symbolic replacement for the largest assumed value in intervals SymTokenGlobalMin -∞ symbolic replacement for the smallest assumed value in intervals SymTokenAnnounced % Substitute character for announced values ​​that will only be delivered during instantiation. SymTokenLimit L Suffix character for excluding the value from an interval SymTokenElement , Separators between arguments of functions or ranges of symbols SymTokenIDDivider . Separators between hierarchical levels of symbols for cascading meanings SymTokenInstance @ Separator between symbol and the name of a specific instance SymTokenInterval | Separator between the smaller and larger values ​​of an interval SymTokenEoS ; Signs indicating the end of rules. Subsequent text passages are implicit comments unless they explicitly state otherwise. SymTokenLineComment / / Characters used to start a comment within rule statements. The remaining characters until the end of the line are not interpreted as a rule or mathematical term. SymTokenCommentStart / * Character to start a multi-line comment, which may contain any characters and must be explicitly marked with the end of the comment. SymTokenCommentEnd * / End character of a multi-line comment that may contain any characters and was explicitly opened with the start of the comment. SymTokenSpace " " Characters that are overlooked and not considered part of the content of symbols SymTokenEOL \n Character which marks the end of the line and thus limits the single-line comment.

[0079] This allows arrows to be placed in Figure 3This corresponds to a recursive transition between states 203 to 215. The respective names of these transitions can correspond to the semantic constructs of the formal language. Exceptions include, for example, the state transitions required for cascading mathematical terms (function skipped) and other transitions that can be grouped together in state 203, as these might only involve distinguishing between comments or error states during parsing as non-functional blocks. Line breaks and spaces (etc.) can be skipped within rules. Additionally, a potential version indicator can start after each line break, which could be followed by a rule. If no rule follows, the interpretation remains an implicit comment 203.

[0080] The recursive parser 201 can revert to a previous state if a text segment being analyzed has finished and no further marker indicating a state transition has been detected. In the case of bracketed hierarchies or embedded comments, this can lead to the same text segment being analyzed multiple times, each time with a different interpretation of the current state.

[0081] The starting point of the recursive parser 201 for semantic expressions can be the implicit comment 203, since actual rules can be surrounded by any text. Within the semantic expressions, AND terms 204, OR terms 205, temporal statements 206, and groups 207 can be nested in almost any way. An exception is the nesting of temporal statements, as these should preferably not be contained in neutral groups. Remaining text segments within the semantic expressions are always symbols, which, as such, are stored in the syntactic blocks 105 without decomposition 108. Semantic rule statements themselves (with the exception of pure group statements) can potentially be encapsulated once as recommendations or check statements via statement 208.

[0082] Similarly, test statements and recommendations can use a definition 209 as a starting point for mathematical expressions 202 from one regulatory context to the respective other semantic context. Gradations of binding forces of mathematical operators in terms (the so-called operator precedence) can be structured in several state levels, from a list of values ​​210 through mathematical addition including subtraction 211 and multiplication including division 212 to function brackets 214. Function names themselves cannot yet be distinguished from symbols 215 at this level, as this can only be determined in a later analysis step. Skipping over further function hierarchies in step 213 can enable the grouping of coherent sentence structures if these are interrupted by parenthetical clauses, similar to a subordinate clause.

[0083] During the analysis in the recursive parser 201, as it progresses through the state transitions from states 203 to 215, the syntactic blocks 105 can be generated as annotations of the formal text of the rule set 101. These preferably document the original source of the read text passage and link the respective text passage to the meaning extracted by the dialectal signs 102 and syntax. At this level, an assignment of individual signs of the respective configured dialect to the semantic meaning in the sense of the formal language can thus be carried out.

[0084] For example, a configuration of the recursive parser 201 for individual state transitions might be as follows: Current starting state Transition state when finding the symbol Set of symbols Action for text before the found symbol Status transition in the case of recursion in the actions before the symbol Action for text after the found symbol Status transition in the case of recursion in the actions after the symbol Associated term type for generated syntax block Section-Implicit-Comment Section Definition Sym-Token-Equal Action-Cont, Action-Recurse Section Definition {} {} Term-Define Section-Implicit-Comment Section Group Sym Token Group Action-Cont, Action-Recurse Section Group {} {} Term Group Section-MathMul Section-SkipFuncDef SymToken-Function-Open Action-UpdCurrPos, Action-Recurse Section-SkipFunc-Def {} {} Term-Type-Undef Section Definition Section Definition SymTokenEoS Action-Reparse Section value Action-Cons, Action-Return Section Success Term value SectionValue SectionValue Sym token element Action-Reparse Section-MathAdd Action-Con Section value TermArg-Element Section symbol Section-FuncDef Sym-Token-Function-Open Action-Reparse, Action-Upd-CurrPos Section symbol Action-Recurse Section-FuncDef Term-Type-Undef

[0085] Figure 4is a schematic flowchart of a method for converting syntactic blocks into a semantic representation, which is applicable in embodiments of the present invention.

[0086] The in Figure 4 The described procedure can be found in Figure 2 The procedure shown can be used as a basis, for example, on process steps 107 and / or 108. However, other variations are conceivable. In the procedure according to Figure 4 can rely on the components from Figure 2 Reference is made to the following, which is to be understood as an example. For instance, the processing could involve syntactic blocks 105 from the formal text. The processing can be done with a parser.

[0087] The procedure can begin in step 301 with a linear procedure (dashed arrows) for all syntactic blocks 105, uniformly consolidating the contained information.

[0088] Since recursion levels can have gaps, especially when parsing mathematical terms, these gaps can be reduced by ensuring that logically adjacent blocks are at most one level below their direct neighbors. This consolidation is performed in step 302. When starting groups, the parser does not distinguish whether the subsequent symbolic values ​​were used as dynamic groups via interval labels. Therefore, this information can be determined retrospectively based on the overall view of the syntax blocks, and the group type can be changed to dynamic groups if necessary, which are identified in step 303.

[0089] Furthermore, a distinction between individual values ​​and sets of values ​​can be used so that assigning a set of values ​​to a symbol is interpreted as specifying all valid values ​​(range). Sets of values ​​are identified in step 304. At all other points in rule set 101, the actual values ​​for a corresponding symbol can be restricted (in definitions and instantiations) at the respective hierarchical level, so that implausible values ​​can be reliably detected as early as the definition of rule set 101 or when an instance is passed.

[0090] Since rules 101 allow comments to be embedded anywhere (even within symbols), the corresponding syntactic blocks are grouped in step 305 so that the comments for a symbol can be processed separately from the actual symbol name. Based on a specific parent / child relationship in the level hierarchy of syntactic blocks 105, embedded comments are recognized, and corresponding clusters of syntactic blocks 105 and comments are recreated.

[0091] The content of syntactic blocks 105 can then be clearly distinguished into content and / or comments without any further overlap. The content can be extracted in step 306. The comments can be extracted in step 307. This intermediate form of summarized sections of the formal text can then serve as the basis for terms or symbolic extraction, or for identifying function names, which are processed in transformation step 308. Within transformation step 308, the terms, symbols, and functions can be generated recursively (solid arrows) using the types annotated in the syntactic blocks 105 during parsing in parser 201, which can also be referred to as term types.

[0092] For term types from the realm of symbolic and mathematical expressions, terms (or sub-terms) are formed and stored. Step 107 from Figure 4 This can be done by step 107. Figure 2 Before forming a term, a version specification can first be extracted as an interval value in step 311, provided the term has such a specification. For OR terms, a further interval specification may be present, which can be read in step 312 and stored with the term. Finally, all data can be combined in a new term object, and the corresponding term type can be set according to the parsed information of syntactic block 105 in step 313, as described below with regard to Figure 5 and a particularly preferred embodiment is shown.

[0093] Sub-terms can also be formed from predefined mathematical functions, which can include any mathematical functions, for example, one or more from min, max, count, and others, and which can be identified in step 314. The term object is created in step 313. The resulting term objects can be inserted into an existing term tree after recursion (310).

[0094] In step 108, symbolic identifiers can be derived and stored from syntactic blocks 105 that are not assigned to any term type (undefined). Step 108 from Figure 4 This can be done by step 108 Figure 2This corresponds to the following steps. First, in step 315, different components can be separated from each other. In step 316, a determined symbolic name without spaces can be stored as a case-insensitive representation, "compressed," and organized by level. References can be extracted in step 317, and a corresponding reference type can be separated from the levels and also added to the symbol. In the case of values ​​that are assigned to instances, these can be stored in step 318 in a memory structure assigned to a corresponding instance name, so that all values ​​of the instance are directly accessible. For a definition of an output language, for example, the definition of output language 117 from Figure 2These values ​​can be stored in a similar way to instances. The specification of which value triggers the activation of an actuator can be stored as an interval, so that the output can be performed uniformly for a defined range of values ​​(319).

[0095] It should be understood that in embodiments, individual steps and sections of the process described in Figure 4 The procedures shown do not necessarily have to be provided for and / or can be carried out in any combination in a different order than shown and at least partially in parallel.

[0096] The result of the processing according to Figure 4 can be converted into a semantic representation, for example the semantic representation 110 from Figure 2 be entered.

[0097] Figure 5Figure 1 shows a schematic representation of a data structure for implementing a semantic representation, which is applicable in embodiments of the present invention. Figure 5 shows a technical setup for storing a semantic representation, for example the semantic representation from Figure 1 or the semantic representation 110 from Figure 2 . In the structure according to Figure 5 can rely on the components from Figure 1 or 2 Reference is made to the above, which is to be understood as an example.

[0098] Logical statements can be represented by three structures, each containing a version (401), a symbol (406), and a term (407). Their source, in the sense of referencing their location in rule set 101 or 10, can be represented by a source structure (404). Logical statements can also be viewed as statements. Each statement can represent a graph without closed paths, for example, as an out-tree or a tree, where a term (407) can represent the root of the statement. The version (401) specified in a statement can refer to a version interval (402), which can contain one or two values ​​(403). The version (401) or a version object can additionally refer to all terms (407) and the resulting graphs or trees containing logical statements that correspond to the version interval (402).The term 407 or a corresponding term object can abstractly represent a statement that can contain or reference symbolic identifiers 405 as well as further implicit statements 409 and values. Since their order can be essential for processing, the references can be stored in a list of defining references (List of Def References) and a list of used references (List of Used References) 408. Preferably, all values ​​used in the terms (e.g., for mathematical functions) can be stored in the form of intervals 402 containing their value(s) of any type.

[0099] This allows for a check for consistency with a value range defined elsewhere; see also [reference to relevant information]. Figure 7An additional reference to the source underlying each object allows for direct tracing between an error or subsequent control command and the causative rule, leading to a significant increase in transparency. Recognized implicit comments can also be stored with the respective statement or directly with the symbolic identifier. The data structures used in the implementation are shown in the following table, which provides an overview of elementary structural content by way of example. Main structure Fields / Structure Description term UID Unique ID of the term for referencing MyType Semantic type (And, Or etc.) Value[] List of intervals ListofTermRefs[] List of references to hierarchically dependent terms ListofSymbolRefs[] List of references to the defining and used symbols MySource[] List of references to the source information of the term MyRootTerm Reference to the term root of the overall statement MyVersion Reference to the aforementioned version of the full statement ListofDefRefs[] Sorted list of references to Value, TermRef, and SymbolRef of the defining references ListoftUsedRefs[] Sorted list of references used, categorized by Value, TermRef, and SymbolRef. symbol name Unique semantic name of the symbol level (cleaned up to remove case variations, case distinctions, etc.) ListOfOtherNames[] List of alternative spellings used ListOfDefTerms[] List of references to terms that contain the symbol as a defining symbol MySources[] Reference list to the source information where the symbol is used version name Identifier of a version Range Validity interval for the dependent terms ListOfTerms[] List of references to all terms with the same version range Overlap Identification indicator showing whether the version range overlaps with another version. MySource[] Reference list to the source information of the version

[0100] The implementation of concrete instances can utilize the same procedures for structuring, extracting, and decomposing the symbolic identifiers 405 into individual symbols 406, as well as instance and reference information. Corresponding instance rules with assigned instance values ​​can be managed under a symbolic name in a hash table. Additional information (e.g., the time of transmission of the instance value) can be recorded, since, taking into account linearization requirements, a state update of the instance may need to be triggered; see also Block 116 in Figure 2 as well as step 501 in Figure 6 .

[0101] A special feature of data modeling according to Figure 5The advantage lies in the redundant form of managing the semantic representation. Based on term structures that contain direct references to the symbols, (sub)terms, and intervals, all main structures can mutually reference each other via hashed lists. Furthermore, higher-level access indexes can be placed over the entire mutually referencing graph and / or tree structure, allowing direct hash table access despite variable version intervals and term tree structures. Thus, in one embodiment of the present invention, knowledge is managed both hierarchically according to the meaning of the rules of rule set 101 and in a direct, linear, database-like form, enabling effective parallel and efficient evaluation and storage.

[0102] The data structure presented provides an efficient basis for rule checks, instantiation checks, and the derivation of the resulting control rules, as is the case, for example, in Figure 2 is shown.

[0103] Figure 6 Figure 1 shows a schematic flowchart of a method for generating target system-dependent control instructions, which is applicable in embodiments of the present invention.

[0104] The in Figure 6 The described procedure can be found in Figure 1 or 2 set up the demonstrated procedure as an example, for instance in procedure step 50 from Figure 1 or process step 116 from Figure 2 Accordingly, the components can be made from Figure 1 or 2 Reference is made to the above, although this too is to be understood as an example. Figure 6 illustrates how target system-dependent control rules, e.g., control rule 119 from Figure 2 , can be formed. The rule set 10 or 101 definable by the semantic representation 110 can have a significantly larger range of functions than other commonly used descriptive means of control algorithms (e.g. truth tables, logic diagrams, relay circuits). The scope of logical statements, taking into account versions, extended OR sets, and temporal statements, can enable the formulation of complex yet manageable rule sets. As in Figure 6 As shown, one or more target states can be defined from a complete set of rules in the form of the semantic representation 110 by instantiation, in order to ultimately derive control instructions from it.

[0105] A hierarchical rule set check of the respective instantiation in step 502 can form the basis for generating control instructions, taking into account the achievement of target states. The resulting check results are structured in step 503, after which, based on an action to be performed, the check results can be assigned to one of the different actuators or, in the case of dependency statements, added to a linearization. If symbolic identifiers must assume exactly one value to achieve the target state, the states can be brought about by executing set actuators 505. If choice options from extended OR conditions cannot be fully resolved to achieve the target, an embodiment of the present invention requires further decisions before the target state can be reached. In this case, these are need-decision actuators 506.Furthermore, temporal dependencies of the rule set and system-specific linearization requirements for forming serial and / or parallel actuator sequences can be taken into account. This can be done according to the linearization requirements of section 115. Figure 2 This occurs when a state is reached explicitly or through a semantic necessity, a State Actuator 510 can generate the corresponding control instructions.

[0106] If a system requirement necessitates an instance update 501, Get actors 504 can be created for all queryable states to allow system states to be re-determined in the target systems and to incorporate the instance-dependent feedback from the target system into the instance states in order to update the further steps and corresponding control instructions for achieving the target state.

[0107] Finally, the generated actuator commands 504, 505, 506, and 510 can be arranged into a unique sequence according to the linearization rules in step 507. This can correspond to a command sequence for a controlled system. The resulting sequence of actuator commands 504, 505, 506, and 510 for symbol levels can be converted in step 508 into target system-specific instructions, which can be understood as the definition of an output language (see block 117 in [reference missing]). Figure 2 , which may be stored in the symbols for triggering the actuators. In step 509, control can be achieved in the target systems using the corresponding converted actuator commands.

[0108] Figure 7 is a schematic representation of a recursive semantic tree analysis which is used in embodiments of the present invention. Figure 7describes how an embodiment of the present invention can perform the analysis to identify inconsistencies, contradictions and potential optimizations in a set of rules, for example rule 101 from Figure 2 to find. Furthermore, the same process structure can be used to execute calculations defined by the rule set. At the same time, the decisions already implicitly made regarding rules can be extracted, or the open options for a future implementation of a specific instance can be derived.

[0109] The in Figure 7 The described procedure can be found in Figure 2 The procedures shown can be set up as examples, for instance in procedure step 118. However, this is by no means mandatory. Figure 7 can be exemplified by components from Figure 2 To refer to.

[0110] One embodiment of the present invention evaluates the semantic representation in several successive phases and considers in particular semantic trees which are depicted in the semantic representation, e.g. the semantic tree 111 from Figure 2 The evaluation follows the same scheme as semantic recursive tree analysis 118, which is also called backtracking in the literature. The general procedure for detecting first-order errors 601, second-order errors 607, and calculating results 615 can therefore be identical. Functions that are applied equally in all areas are in the Figure 7 Therefore, they are drawn across the entire width of the diagram, e.g., steps 605 and 606. In some process steps, e.g., 603, these basic functionalities can be supplemented or replaced by specific additional checks or processes, e.g., in step 610.

[0111] A semantic representation, for example semantic representation 110 from Figure 2, can contain errors of various orders, which may be grouped into two classes solely due to their similarity in processing. Errors can only occur because logical expressions, while adhering to grammar (syntax and punctuation), can otherwise be meaningless or contradictory.

[0112] The detection of first-order error 601 can exhibit one or more of the following cases, in any order and combination: Self-references in symbolic statements or mathematical terms. With regard to terms, it is forbidden to require or prove a statement by itself. Put simply, symbols may not be defined using themselves. Such cyclic references in arbitrary sub-statements render statements unprovable or indeterminable. The definition of recursive formulas, however, is permitted, since the redefinition of a variable in a subsequent generation is based on the known generation (the step after n+1 is based on n). Identical symbols in different positions must refer to the same units. The assignment of a school grade in the number range 1 to 6 cannot be directly related to the verbal form "very good" to "unsatisfactory" without "translation." Symbols must lie within the defined range of values. In the case of school grades, for example...In primary school, whole numbers in the range of 1 to 6 are often used, whereas in upper secondary school, the point scale 0 to 15 is used. Therefore, any grade assigned as the basis for calculating a grade point average must fall within the correct (i.e., agreed-upon) range of values.

[0113] According to the invention, the analysis of these types of errors directly determines the faultiness of a term (without further analysis of the rest of the rule set) based on the stored data. It is therefore referred to as a "first-order error".

[0114] For a complete examination of the rule set for these errors, all true root terms in 601 can be subjected to a recursively designed partial analysis. True roots are those rule statements that define a symbol which is not used in any other term as a symbol to define other terms. The detection of loops in a recursive process may initially require a comparison of the currently examined term with all terms already considered from the root 602. The following steps can be reduced based on the version interval used in the term 603. If no explicit version is used, the general version (-∞ to +∞ → always corresponds) can be considered the basic assumption. Versions can be nested in their effect by specifying intervals and thus further restrict this general basic assumption.In extreme cases, restricting the version to a specific version name as an interval of a value is the most specific form of a version.

[0115] A selection of the relevant symbols 604 resolves the grouping intended in the semantic representation. Logical statements (AND, OR, and temporal relations) do not refer to a defined group symbol, but to all members of the group equally. An OR selection of symbols B, C, D from group A should be equivalent to a selection from B, C, D and not include group A as a symbol. The latter would correspond to an AND conjunction of the aforementioned symbols under the name A, which a group does not perform. Since groups (and also dynamic groups) can themselves directly contain other groups, the determination of relevant symbols must be carried out recursively.

[0116] A recursion from the root to the leaves in the semantic tree is performed when sub-terms exist or rules further specify the symbols used. To enable structured evaluation after the recursions, the recursion options are first determined (605). According to a rule versioning system, corresponding recursions may be scheduled and executed multiple times for different version intervals (606). In the case of first-order errors, the identified errors are compiled in a structured manner, but no further calculations are performed based on the terms. This changes in the other implementations of recursive semantic tree analysis (118).

[0117] Second-order error detection (607) can analyze one or more of the following cases, in any order and combination: Logical contradictions arise between required AND conditions and exclusively OR conditions. For example, the necessary selection of exactly one option from A or B contradicts the requirement that both A and B must be fulfilled simultaneously. This type of error has many variations, since in one embodiment of the present invention, the OR sets can be defined by "n to m from k options". Equivalent to the AND / OR conflict, potential contradictions exist in mathematical terms involving opposing greater-than / less-than relations or other equal / inequal constellations. Similarly, such contradictions are conceivable through temporal sequences, but these are logically identical to first-order errors, since the symbols involved already lead to circular reasoning.

[0118] According to the invention, the analysis of this type of error identifies the error only through a logical evaluation 608 of the actual terms by combinatorics or symbolic transformation. One embodiment of the present invention implements the test based on the combinatorics of critical symbols that are involved multiple times—i.e., in different terms—in the definition of statements within a version interval. For all identified potential sources of logical errors, solution hypotheses are generated 616 and also recursively tested for corresponding subtrees 609. Restricting the combinatorics to the necessary cases of partial versions 610 and subsets of critical symbols 611 represents an advantage over the otherwise theoretical brute-force methods, in which the rule set must be tested for all mathematically constructible combinations of the symbols and their values.

[0119] The mathematical satisfiability of the subterms 612 can be carried out by evaluating terms without making assumptions about the state of the "non-critical" symbols. If a state of a tested hypothesis is not satisfiable, even though no assumptions are made about the other symbols, the corresponding subterm is considered impossible. In the summative combination of the existing solution options 613, impossible and possible options can be evaluated according to the logical rules and aggregated via the semantic tree back to the root (or partial evaluation).

[0120] The recursive evaluation of the semantic tree for instances in step 614 uses the same process structures, but instead of simply determining the satisfiability of statements, it can calculate the values ​​of the sub-terms based on the mathematical formulas and instantiated values ​​(615). Sub-terms that necessarily have a concrete value assigned to an instance in the computational recursion based on the rules are included in a list of necessary consequences for that instance in order to derive corresponding control rules and commands (see also step 502 in [reference missing]). Figure 6 Open choice options for a future configuration of a specific instance remain as a restriction of the options originally defined in the rules, thus allowing for more effective further processing of the instance (reduction of combinatorics) and corresponding communication of the remaining decision options to the user or another system; see step 506 in [reference to step 506]. Figure 6 .

[0121] In one or more preferred embodiments of the present invention, the following aspects and / or advantages may be particularly relevant: One embodiment may relate to an implementation of a logic-based control of other plants and systems (including other computer systems) with intertwined versions, which enable a definition of target states and full transparency between generated system logic and the source information of all logical statements and instance values.

[0122] A number of basic terms consisting of AND and / or OR statements can be significantly reduced and thus made accessible to control by the concept of n out of m of k options of a flexible OR operator. A single statement in a basic logic can potentially require thousands of statements, which are practically impossible to process as combinatorics. Thus, the concept of n out of m of k options of a flexible OR operator makes control accessible by using only those symbols of the semantic representations that depend on the currently considered logical rule for the concrete testing of a control, while all other symbols are considered merely as sets.

[0123] Furthermore, a combination of all language elements can be used to create a consistent control logic a) without executing error states, b) to determine remaining choice options for any instance hypotheses, and / or c) to effectively reduce the technically unprocessable (memory space) or ungenerable (time length) full combination tree to relevant sub-statements.

[0124] The use of dialectical language flexibility can occur at the level of punctuation, the syntax of rules, as well as in the output of control instructions and corresponding commands, allowing a naturally sounding text to be understood as a set of rules by both humans and machines equally and unambiguously.

[0125] Furthermore, the implementation of logic-based control of other plants and systems (including other computer systems) with intertwined versions, the possibility of defining target states and full transparency between generated system logic and the source information of all logical statements and instance values ​​can be provided.

[0126] An implementation can preferably use all language elements in a consistent, technically usable control logic in order to a) determine logical error states before a rule set is used to control plants or systems, b) determine the remaining choice options for any instance hypotheses, which can correspond to a concrete compilation of selected states of the plants and systems relevant in the rule set, and / or c) generate a technically editable combination tree reduced to the relevant sub-statements and enable time-based system control.

[0127] Preferably, an implementation can enable users to create a logical set of rules without having to carry out a concrete implementation in a procedural, object-oriented or logical programming language, since the use of dialects allows for a natural-looking text at both the level of punctuation and the syntax of rules.

[0128] It should be clear that the present invention does not relate to a specific embodiment of the invention described in the Figures 1 to 7The invention is not limited to the methods, devices, and systems shown. For example, other schemes for textual rule sets and other control instructions or commands can be used. Furthermore, the rule sets can be transformed into the respective control instructions according to modifications of the implementation methods shown. The present invention is not limited to a specific syntax or semantics of the rule sets, the semantic representation, or the target-system-dependent control instructions shown. Moreover, the features disclosed in the foregoing description, the claims, and the figures can be important for the realization of the invention in its various embodiments, both individually and in any combination.

Claims

1. A computer-implemented method for generating control commands, comprising the steps of: providing (10) a document that includes at least one declaration that formulates a rule set; parsing (20) the at least one declaration to generate a plurality of syntactical blocks; constructing (30) terms and symbols from the syntactical blocks, to generate a semantic representation, the semantic representation including at least one semantic tree, the semantic tree including a plurality of terms and symbols that unambiguously represent both the semantics of the rule set and its logical connections; validating (40) the semantic representation, wherein validating (40) the semantic representation includes automatically validating the rule set in terms of completeness, and automatically validating the rule set in terms of consistency and application to an individual case, by a recursive semantic tree analysis of the at least one semantic tree, to detect first order errors (601) and second order errors (607) in the semantic representation, wherein a first order error is determined from the stored data without further analysis of the remaining rule set, and a second order error is determined by combinatorics or symbolic reshaping of the terms and their logical evaluation; generating (50) at least one control command based on the validated semantic representation, wherein the at least one control command corresponding to the rule set formulated by the at least one declaration; and converting (60) the at least one control command into a plurality of platform-specific instructions for driving a target platform.

2. The computer-implemented method of claim 1, wherein the at least one declaration includes a textual formulation of the rule set.

3. The computer-implemented method of claim 1 or 2, wherein the at least one control command is a target-system-dependent control command.

4. The computer-implemented method of claim 1, wherein the plurality of platform-specific instructions include a plurality of actors that translate the target platform in a target state.

5. The computer-implemented method of claim 4, wherein the plurality of actors include one or more of an actor for setting at least one parameter of the target platform, an actor for reading out at least one parameter of a current system state of the target platform, and an actor for querying an option for at least one parameter of the target platform.

6. The computer-implemented method of any one of the preceding claims, wherein the converting (60) includes sequencing of the plurality of platform-specific instructions according to at least one linearization command.

7. The computer-implemented method of any one of the preceding claims, wherein the at least one semantic tree includes a plurality of elements, wherein one or more of the plurality of elements includes at least one reference to a further element from the plurality of elements, wherein the at least one reference is implemented by hashed lists and access indices.

8. The computer-implemented method of any one of the preceding claims, wherein the recursive semantic tree analysis starts with terms that constitute the roots of the at least one semantic tree.

9. The computer-implemented method of any one of the preceding claims, wherein the semantic representation includes at least one instantiation, wherein the at least one instantiation includes one or more values for symbols of the semantic representation.

10. The computer-implemented method of any one of the preceding claims, further comprising transferring the semantic representation into a formal text corresponding to the at least one declaration in the document.

11. A device for generating control commands, the device being configured to perform a method according to any one of the preceding claims.

12. A system, comprising: an open- and / or closed-loop platform that can be translated into a system state by at least one control command; at least one storage medium that stores at least one declaration that formulates a rule set for the platform; and at least one device according to claim 11.