System and method for generating warranted cases

Abstract

A system, method, and procedure for generating a self-consistent warrant case using one or more computer models, the computer models structured to receive a query from a user, process the query and determine the nature of the warrant case to be generated, determine and retrieve evidence from a normalized, curated database supporting the warrant case assertions, and populate a warrant case candidate therewith. A reviewer can then evaluate the warrant case candidate against one or more constraints, and either return it to the computer models for resynthesis, or forward it to a translator for conversion to a human-readable format.

Description

Federal Government Funded Research Statement

[0001] This invention was developed with government support under contract number FA8750-20-C-0203 awarded by the Defense Advanced Research Projects Agency (DARPA). The government holds certain rights to this invention. Technical Field

[0002] The aspects described in this article mainly involve guaranteed cases and computational models that can generate guaranteed cases. Background Technology

[0003] In certain industries, such as aerospace, healthcare, automotive, and cybersecurity, it is important to demonstrate that systems (such as various aircraft-based or aircraft-related systems) meet a given level of safety or reliability confidence, from both a development and regulatory compliance perspective. As technology advances and systems become increasingly complex, the need for a structured and transparent approach to demonstrating safety or reliability through assurance cases is also growing. Attached Figure Description

[0004] The aspects illustrated in the accompanying drawings are illustrative and exemplary in nature and are not intended to limit the subject matter defined by the claims. The following detailed description of the illustrative aspects will be understood when read in conjunction with the following drawings, in which similar structures are indicated by similar reference numerals, and wherein:

[0005] Figure 1 An exemplary system for generating guarantee cases based on the disclosure herein is shown;

[0006] Figure 2 An exemplary system for generating guarantee cases based on the disclosure herein is shown;

[0007] Figure 3 An exemplary query for generating a guarantee case is shown, based on the disclosure herein;

[0008] Figure 4 An exemplary method for generating guarantee cases based on the disclosure herein is shown;

[0009] Figure 5 An exemplary system for generating guarantee cases based on the disclosure herein is shown;

[0010] Figure 6 An exemplary guarantee case is illustrated schematically in the target structure notation (GSN) format; and

[0011] Figure 7 An exemplary method for generating guarantee cases based on the disclosure herein is shown.

[0012] These and additional features provided herein will be more fully understood in conjunction with the accompanying drawings and the following detailed description. Detailed Implementation

[0013] The aspects of the disclosure described and illustrated herein provide systems and methods for generating self-consistent assurance cases that conform to standards, regulations, and / or style guidelines by leveraging artificial intelligence (AI) systems, large language models (LLMs), and / or other computational models. These models can be constructed to: process and respond to user input; retrieve evidence from a database supporting or refuting arguments and / or claims that support or refute assurance cases consistent with the user input; place the evidence in an appropriate, structured form consistent with the user input; and examine the correctness, completeness, and / or compliance with appropriate metrics of the generated assurance cases.

[0014] An assurance case is a carefully constructed framework used to demonstrate whether a system meets safety and / or reliability criteria. Essentially, an assurance case presents a claim about the system's trustworthiness and then supports or refutes that claim by linking arguments and evidence in a connected logical chain. Assurance cases do not rely on simple assertions but systematically organize data, analysis, and reasoning to demonstrate that the system can reliably and correctly operate under expected conditions.

[0015] The importance of assurance cases extends beyond regulatory compliance. While many regulatory bodies, such as the Federal Aviation Administration, the Food and Drug Administration, and the International Electrotechnical Commission, use assurance cases as part of their certification processes, their value is far greater. Assurance cases provide a structured approach to demonstrating why a system is compliant and / or reliable, making it easier for engineers, regulators, and stakeholders to assess its credibility. By increasing transparency, assurance cases help ensure that all considerations are taken into account and that potential risks are identified and addressed.

[0016] Furthermore, assurance cases play a crucial role in risk assessment and lifecycle management. Because assurance cases involve a detailed examination of potential hazards and failure modes of the system, they help organizations proactively identify weaknesses before they become problems. Assurance cases are not static documents but evolve as the system develops, ensuring that various considerations are fully documented and reassessed as software updates, hardware changes, or operating conditions change. This adaptability makes assurance cases a valuable tool in industries where systems continue to meet stringent standards even after standards have been revised.

[0017] Beyond technical and regulatory functions, assurance cases can also enhance trust and confidence in the system. When an entity can present a well-structured, evidence-based argument explaining why its products meet various standards, it strengthens the confidence of users, regulators, and investors.

[0018] As artificial intelligence, autonomous vehicles, and cyber-physical systems become increasingly integrated into daily life, assurance cases remain a cornerstone of responsible systems development. By providing a rigorous framework for demonstrating compliance, ensuring transparency, and managing risk, assurance cases serve as a mechanism to ensure that complex systems can be trusted to operate appropriately and effectively.

[0019] However, creating assurance cases can be a complex test, largely due to the nature of modern systems, the difficulty of gathering evidence (and even identifying what evidence to use), and the need for rigorous logical reasoning to support claims. Many systems involve complex software, hardware, and human-computer interactions, all of which are considered when assessing reliability, security, and compliance. As these systems become more interconnected, the number of potential failure modes grows exponentially. Capturing and proving interactions in a structured manner, conforming to different rules, cannot be effectively accomplished manually (e.g., without the use of the specific algorithms described in this paper on complex computer systems).

[0020] Another significant challenge is providing high-quality evidence to support assurance cases. Evidence can take many forms, including test results, formal verification, hazard analysis, operational data, and expert judgment. However, obtaining comprehensive and reliable evidence can be difficult, especially when dealing with urgent actions in complex systems. This is because some risks may become apparent after extensive real-world operation, making it difficult to fully demonstrate compliance in advance. Furthermore, assurance cases account for uncertainties such as unpredictable human interactions, environmental factors, or software errors that may occur under specific conditions. Ensuring that existing evidence is both complete and relevant to the asserted claims requires considerable effort and expertise.

[0021] Furthermore, even with evidence, constructing a convincing argument remains a challenge. Ensuring that the case connects the evidence to the claim in a logical and coherent manner is crucial. This typically involves using structured methods, such as the GSN or the Claim-Argument-Evidence (CAE) model, to ensure that all reasoning is clearly articulated and free of logical fallacies. However, developing such arguments is not straightforward, as different stakeholders—regulatory bodies, engineers, and independent evaluators—may have varying understandings of what constitutes a strong or convincing argument. Moreover, the reasoning must be robust enough to withstand the test of time, even as new risks emerge or technology evolves.

[0022] Another layer of difficulty stems from the dynamic nature of modern systems. Assurance cases are not one-off documents, but are maintained throughout the entire system lifecycle. Assurance cases are reviewed and updated accordingly with software updates, hardware changes, or new regulatory rules. This leads to continuous monitoring and verification, making assurance case management a continuously resource-intensive task. In rapidly innovating industries, ensuring that assurance cases keep pace with development and do not become a bottleneck is an ongoing challenge.

[0023] Finally, regulatory and organizational constraints can further complicate the process. Different industries and regulatory bodies have different rules for assurance cases, and demonstrating compliance with multiple (and sometimes changing) standards is both time-consuming and expensive. In some cases, assurance cases are developed in collaboration with external auditors or certification bodies, which further increases the complexity of the process. Organizations must strike a balance between thorough assurance and the practical limitations of cost, time, and available expertise.

[0024] Therefore, it is easy to understand that generating, proving, and maintaining a single assurance case can be a daunting or even impossible task when done by one person or a group of people working together. Today, with so much information and so many considerations at play, it is impossible for one person or a group to manage the generation of assurance cases without assistance.

[0025] For example, the Federal Aviation Administration (FAA) considers gas turbine engine blades to be "limited-life parts" and must have a manufacturer-defined lifespan. To certify an engine, the manufacturer must not only define this lifespan but also demonstrate that a given blade meets this lifespan requirement.

[0026] To demonstrate that a given blade meets its lifecycle requirements, various characteristics must be demonstrated one by one. These characteristics might include: whether the blade is suitable for the engine's current operating conditions; whether the blade is suitable for the type and frequency of cycles it will experience when installed on an aircraft; whether the blade is sufficiently resistant to creep, fatigue, and other mechanical stresses encountered in the engine; whether the blade's vibration modes are adequately removed from certain excitation frequencies; whether the blade is sufficiently resistant to the thermal effects it will experience in the engine; whether the blade is sufficiently resistant to the chemical effects (e.g., oxidation, corrosion) it will experience in the engine; whether the blade can withstand foreign object damage; whether the blade is adequately cooled at various points throughout its lifecycle; whether the blade has a coating, and if so, whether the coating will also survive under these conditions; whether these conditions are met within the established manufacturing tolerances; and / or, for any of these parameters, what value is considered "sufficient".

[0027] Typically, comprehensive testing of a given blade in its intended operating environment is only conducted late in its development lifecycle—if at all. Prior to this, testing tools such as computer simulations, scale models, empirical analysis, test benches, and retrofitting are alternatives. Each of these tools, in turn, has its own advantages, disadvantages, limitations, shortcomings, and assumptions—all of which must be considered when determining whether certain criteria are met. These tools, including their warnings, also change over time, further complicating the task of tracking what data can be used for what and under what conditions. Furthermore, due to practical constraints, there may be only a limited amount of test data available for a given blade, or different test datasets may be available for multiple blades.

[0028] To complicate matters further, the standards that must be met frequently change. FAA regulations are updated regularly, sometimes multiple times within a single engine's development cycle. Furthermore, manufacturers wishing to sell their engines internationally may need to comply not only with U.S. regulations but also with those of other countries. Different countries often have different requirements, and these specific differences may necessitate further analysis or verification, or a change in the nature of existing analyses or verifications.

[0029] Therefore, when designers begin to formulate assurance cases for this exemplary turbine blade (not to mention the entire engine, which may have 24 sets of blades or more), they are uncertain not only about whether a given blade meets the target criteria, but also about how to prove those criteria and what evidence is available to prove them. Certain evidentiary data, or the lack thereof, may exclude certain logical chains or require others. The designer may also lack the expertise to know whether a single piece of evidence can be used to support / refute an argument / claim, etc.

[0030] In other words, when constructing assurance cases, the amount of data that an individual (or even a group of people) needs to gather and the amount of claims / arguments that need to be linked to form evidence are too large. There is also no practical method to reliably or easily adapt to different stakeholders: creating an assurance case for the FAA, and for something like the Japanese Civil Aviation Authority, becomes their own independent and substantial drafting work. Similarly, there is no practical method to reliably or easily update existing assurance cases given updated regulations or requirements. Furthermore, even if an individual or group were capable of preparing and updating assurance cases, it would be impossible to do so while various regulations are constantly changing and / or new data is received. That is, the time required for an individual or group to prepare an assurance case far exceeds the various time periods for receiving new data and / or parameters to be considered. Therefore, a sophisticated system as described in this paper is needed that can accurately receive data and provide results before new data and regulations are provided, and can be quickly adapted to provide new results shortly after new data and regulations are provided.

[0031] Furthermore, due to these obstacles, creating assurance cases can often be a daunting task. While the structured framework employed by assurance cases may benefit designers early in the development of parts, components, or systems—for example by helping to inform which tests must be performed and / or which tests may be omitted—the effort and / or cost of generating or even prototyping assurance cases for these use cases is prohibitive.

[0032] The systems and methods disclosed in this paper address these problems and enable the use of assurance cases in a wider range of applications in a cost-effective manner. Users can quickly generate new assurance cases or update existing ones faster and more accurately than existing methods. These assurance cases can be dynamically adjusted to adapt to various stakeholders, regulators, and other stakeholders within a real-time timeframe—something that has been virtually impossible until now. The dynamic construction of the logic chain also allows designers to adapt to updated methodologies and evidence without having to strictly maintain established templates.

[0033] Now go to Figure 1 An exemplary system 1 for generating self-consistent guarantee cases is shown. System 1 includes a filtered and normalized database 10, a computational model 20, a constraint library 30, a critic 40, and a translator 50, which further generate human-readable guarantee cases 60 according to any of the methods described herein.

[0034] The normalized database 10 partially contains data entries 12 and relations 13, from which selection can be made when generating guarantee cases 60. The normalized database 10 is a computer-readable database, such that data entries 12 are stored in some form of computer memory and / or storage device for access by the computational model 20. The normalized database 10 may be stored on the same hardware that executes the computational model and / or may be stored on a remote, networked, and / or other removable / detachable storage system, but is not limited thereto.

[0035] While a computational model 20 trained and / or constructed to process raw data can be used to perform System 1 and / or the methods described herein using data stored in its raw form, it has been found that normalizing the data contained within the normalized database 10 according to a defined database ontology enables System 1 to operate with greater efficiency and accuracy, thereby reducing the need for subsequent corrections and / or iterations by the reviewer 40.

[0036] Data normalization is the process of structuring data within a normalized database to minimize redundancy and improve consistency, accuracy, and efficiency. This involves organizing data into well-defined tables and / or other data structures and ensuring that relationships between data entries are maintained. As an example, multiple studies, each dependent on a given dataset, may each include and / or list that given dataset in their respective reports. Therefore, the normalization of these multiple studies might involve separating the given dataset from the studies to store a copy, while preserving the relationship between that particular dataset and these multiple studies, and also storing it within the database. This reduces redundancy within the database, making it easier to identify those studies that depend on that particular dataset. Normalization may also include steps such as presenting the data in a consistent format, using a consistent language or scheme, to establish consistency and / or introduce a degree of homogeneity among data entries.

[0037] For example, data entry 12 within normalized database 10 can be decomposed into entity 14, activity 16, and subject 18. However, it is also conceivable that other organizational structures / ontologies can be used to construct normalized database 10.

[0038] Entity 14 can be used as a core data element stored within the normalized database 10, and can represent objects and / or concepts with attributes that exist independently of each other. Entity 14 may include, but is not limited to, raw or normalized data, software, specific tests and / or programs, identification information and / or metadata, etc.

[0039] Activity 16 can refer to actions and / or processes that interact with, modify, or otherwise alter entity 14 over time, and may include, but are not limited to, processes such as data input, research publication, dataset updates, dataset review, software development, and software review. Activity 16 within the context of the normalized database 10 can be used as an audit trail to track changes in data entry 12 over time.

[0040] Entity 18 may refer to authors, systems, individuals, organizations, and / or other similar actors who may influence and / or contribute to the data within the database. Entity 18 is typically responsible for creating, modifying, and / or managing the data and / or entity 14 within the normalized database 10. Entity 18 may include, but is not limited to, software, automated processes and / or workflows, workstations, sensor kits, laboratory equipment, testing machinery, test benches, engineers, scientists, data administrators, institutions, laboratories, reviewers, etc. Typically, entity 18 can use and / or modify entity 14; and entity 18 can perform and / or participate in activity 16.

[0041] Based on the parameters of the database ontology on which the normalized database 10 is constructed, the relationships 13 between entities 14, activities 16 and subjects can be preserved. These relationships 13 themselves can be used as data points and / or data entries 12 to generate guarantee cases 60.

[0042] The computational model 20 can be executed by one or more processors to perform software and / or computer code that performs functions related to system 1 and / or the methods discussed herein. As mentioned above, the hardware executing the computational model 20 can be the same as or separate from the hardware of the normalized database 10.

[0043] System 1 may also include an interface 22 through which a user submits a query 24 to the computational model 20. Interface 22 may include, but is not limited to, physical interfaces such as a keyboard and / or mouse or other similar hardware, a touchscreen, a microphone / voice interface, a gesture-based interface, etc. Interface 22 may also be a network interface or other communication interface, allowing a user to issue commands to the computational model from a remote and / or individual device, for example, via a network or other communication medium.

[0044] Computational model 20 is constructed to accept a query 24 from a user as input to perform functions related to generating the guaranteed case 60. Computational model 20 can be any suitable model for performing this task, including but not limited to algorithmic computational models, machine learning models, neural network models, symbolic models, etc. In some respects, computational model 20 is a large language model (LLM).

[0045] LLMs are advanced deep learning models trained on large amounts of text to understand and generate human-like language. LLMs are typically based on a transducer architecture and use billions of parameters to learn statistical relationships between words, phrases, and concepts. LLMs are usually pre-trained on large datasets, learning language patterns, facts, and context from a variety of sources. Once pre-trained, LLMs can be fine-tuned on domain-specific data. Therefore, while a general-purpose LLM can be used as the computational model 20 of the system and / or method described in this paper, computational model 20 can be fine-tuned based on the context and uniqueness of guaranteed cases, making the output of computational model 20 closer to the expected output, thereby reducing any error-correction steps and / or iterations relying on critics 40.

[0046] The user-submitted query 24 can be a discrete query and / or multiple queries. Query 24 may include natural language requests. Additionally or alternatively, query 24 may include a “dialogue” or communication between the user and the computational model 20 in natural language format and / or a series of multiple queries, or in the form of a “dialogue” or communication between the user and the computational model 20 in natural language format and / or a series of multiple queries, allowing the LLM to use and / or process at least a portion of the dialogue to perform the task of generating guarantee cases 60. This conversational interaction between the user and the computational model 20 can also allow the computational model 20 to search for defects and / or errors within a given query 24, and if any defects and / or errors are found, the computational model 20 can ask the user questions, request additional information, and / or otherwise obtain input from the user to resolve said defects and / or errors. By performing this error checking before generating guarantee cases 60, the entire process can be made more efficient in a user-friendly manner.

[0047] Furthermore, query 24 can incorporate or otherwise reference any previously submitted queries. For example, a user reviewing the generated guarantee case 60 might determine that a certain set of evidence X should not actually be used. To address this, the user could submit a subsequent query 24 to the computational model stating, "Generate a guarantee case without using evidence X." While this current query alone might not be sufficient to facilitate the generation of a guarantee case, the computational model can then reference previous queries for further context regarding the current query.

[0048] Briefly go to Figure 3Exemplary elements of the user-submitted query 24 may include, but are not limited to: one or more requests 25 to the computational model 20 (e.g., “Generate guarantee cases using…”); one or more sample guarantee cases 26 having the type, form, or any other identifiable metric that the computational model 20 is to follow when generating guarantee cases 60; and / or one or more formal or informal guarantee case objectives 27 that the guarantee cases are to prove or otherwise perform, etc. In those respects where the computational model 20 is an LLM or other suitable machine learning model, submitting one or more sample guarantee cases may trigger further fine-tuning of the computational model 20 to ensure compliance with the formats, regulations, rules, etc., contained therein. For example, the computational model 20 may be fine-tuned based on the sample guarantee cases 26 provided through query 24.

[0049] Query 24 can be submitted by the user in natural language format. That is, the user can make arbitrary or even conversational requests to computational model 20 to generate guarantee cases 60 according to the requested criteria. In other words, the user does not need to formulate query 24 according to a specific application programming interface (API), constructor format, function / method call, etc. This improves system usability. Additionally or alternatively, query 24 can also be submitted with or without conforming to any specific ontology and / or the database ontology of normalized database 10, thereby eliminating any need for the user to be familiar with said ontology. However, it is understood that structured queries can still be processed and / or may have inherent advantages over natural language requests.

[0050] Back Figure 1 Once the computational model 20 receives the query 24, the computational model will make a request to the normalized database 10 to obtain the data entry 12 corresponding to the requirements of the query 24.

[0051] For example, when processing the user-submitted sample guarantee case 26, the computational model can identify a test procedure that proves sample guarantee case 26. Therefore, the request may include identifiers seeking data entries 12 and / or relations 13 that correspond to the same or similar test procedures used to generate guarantee case 60. Additionally or alternatively, computational model 20 may retrieve historical guarantee cases from the normalized database 10 as part of data entry 12. The computational model can then analyze these historical guarantee cases to obtain appropriate test procedures and / or supporting evidence, as a supplement or alternative to processing sample guarantee case 26.

[0052] As another example, and / or in the absence of such a sample guarantee case 26, computational model 20 may submit requests for data entries 12 and / or relations 13 related to query 24 more broadly to normalized database 10. Computational model 20 may then further process those data entries 12 and / or relations 13 returned by normalized database 10 to determine which data entries 12 and / or relations 13 best fit the objective of the query used to generate guarantee case 60.

[0053] Computational model 20 can request data in a single request, or iteratively build and / or generate new requests for normalized database 10 while constructing guarantee case 60.

[0054] Computational model 20 can be one model or multiple models, such as Figure 2 As shown, the first computational model 20a can be constructed and / or specifically designed to generate requests to a normalized database, while the second computational model 20b can be constructed or specifically designed to generate guarantee case 60 based on the retrieved information.

[0055] In any configuration, computational model 20 may be configured to process and subsequently populate guarantee case 60 with information retrieved from the normalized database, and / or computational model 20 may synthesize new supplementary information based on information retrieved from the normalized database. For example, computational model 20 may synthesize reasoning based on data retrieved from the normalized database, such that the reasoning itself is not formally / specifically included in the normalized database 10.

[0056] Once a guarantee case 60 that clearly satisfies user query 24 has been assembled, the critic 40 will process the guarantee case as a guarantee case candidate 62 to verify its completeness, correctness, and / or compliance with the standard.

[0057] Depending on the type of computational model 20 used, it may have inherent flaws during operation, which can be corrected before the final guaranteed case 60 is output. For example, when using LLM or other probability models, "illusion" is a known risk, such that computational model 20 may generate false and / or potentially inaccurate information to populate the guaranteed case 60. Therefore, a reviewer 40 is provided to prevent these types of generation errors and ensure that the guaranteed case candidates 62 have acceptable quality to be output as the final guaranteed case 60 to users or stakeholders.

[0058] Critics 40 serves as a specialized component designed to evaluate, refine, and / or filter the output of computational model 20, acting as a post-processing and / or feedback mechanism to improve the accuracy, consistency, and adherence to desired standards of the response. Critics 40 can be configured to identify inconsistencies, factual errors, and / or logical flaws in the generated guarantee case candidates 62, eradicating any biases, illusions, and / or other inconsistencies. Critics 40 can be implemented as: a rule-based critic, enabling it to check for errors using predefined rules and / or heuristics; a neural evaluation model, such as another computational model that scores and / or refines the output of computational model 20; and / or any combination of both. Critics 40 can also request additional feedback and / or corrections from the user. Critics 40 can also be configured to submit requests to the normalization database 10 to verify that the data used in the guarantee case candidates 62 is consistent with those data entries 12 stored within the normalization database 10.

[0059] Commentator 40 can implement this using formal methods, such as through automated reasoning, Boolean satisfiability (SAT) solvers and / or satisfiability modular theory (SMT) solvers, and / or model checking. Automated reasoning includes algorithms constructed to reason about logical statements with or without human intervention and can be used to verify the properties of guaranteed case candidates 62 and / or the correctness of proofs. SAT solvers determine whether a given logical formula is satisfiable, and SMT solvers can be used to extend SAT solvers by incorporating arithmetic theory, abstraction theory, etc. Model checking techniques verify the system by exploring the possible states of the system or a subset thereof and ensuring that a given specification is satisfied.

[0060] Commentator 40 can be one or more commentators, and is implemented by computer code executed by one or more processors. As mentioned above, commentator 40 can be executed by hardware that is the same as or different from the hardware that executes the normalized database and / or computational model in any combination.

[0061] In some respects, when examining the assurance case candidate 62, the commentator 40 may utilize a constraint library 30 containing one or more constraints 32. Constraints are typically specific rules or conditions imposed on the assurance case to ensure that any argument for compliance, security, and / or reliability contained therein meets defined criteria and / or is logically sound. For example, the constraint library 30 may contain constraints 32 that: ensure the argument does not contain contradictions or circular reasoning; satisfy relevant aspects of a specific paradigm (e.g., no missing failure modes); ensure consistency with industry-specific standards; ensure consistency with any regulatory-specific standards; limit the types of evidence that can be used to prove a claim; limit the kinds of evidence that can be used to substantiate a claim; specify the specific relationships between evidence 14, activity 16, and / or subject 18 or their logical chains; specify acceptable levels of uncertainty; and so on.

[0062] In some respects, constraint library 30 can be written in a machine-readable or critic-readable format, thereby ensuring that any nuances are properly captured and are not affected by the same types of probabilistic and / or illusory flaws of the various computational models described above. Due to the importance of the role played by critic 40, constraint 32 is essentially formulaic to ensure effective dialogue between critic 40 and computational model 20.

[0063] If guarantee case candidate 62 fails one or more constraints, it is sent back to computational model 20 for regeneration and / or correction. Reviewer 40 may provide computational model 20 with further context indicating why guarantee case candidate 62 was rejected, so that the computational model can make appropriate corrections and / or formulate a corrected request to the normalized database. It is also conceivable that any satisfaction criteria can be set here. For example, reviewer 40 may reject guarantee case candidate 62 if it fails a specific and / or pre-defined number of constraints, or if it fails certain specific constraints, and / or any combination thereof.

[0064] In some examples, the user can specify the following as part of query 24: guarantee that candidate case 62 must satisfy a specific percentage of constraints 32, guarantee that candidate case 62 must satisfy a specific number of constraints 32, and / or guarantee that candidate case 62 must satisfy certain and / or specific constraints 32. In some examples, computational model 20 can derive and / or infer from sample guaranteed cases 62, and / or derive and / or infer from other criteria of query 24 the specific percentage of constraints 32, the specific number of constraints 32, or certain and / or specific constraints 32 that candidate case 62 must satisfy. In some examples, computational model 20 can derive and / or infer from data entries 12 and / or relations 13 returned by normalized database 10 the specific percentage of constraints 32, the specific number of constraints 32, or certain and / or specific constraints 32 that candidate case 62 must satisfy.

[0065] If the guarantee case candidate 62 satisfies the applicable constraints 32 and / or a predefined number of constraints 32, in addition to the above, the guarantee case candidate 62 is passed to the translator 50 to be converted into a guarantee case 60 in a predetermined format consistent with the user-submitted query 24. In some examples, the predetermined format of the guarantee case 60 may be a machine-readable format. In some examples, the predetermined format of the guarantee case 60 may be a human-readable format. In another example, if the user specifically requests that the guarantee case 60 be generated in GSN format, or if the sample guarantee case 26 is presented in GSN form, the translator 50 may convert the guarantee case candidate 62 generated by the computational model 20 into a guarantee case 60 in GSN format.

[0066] A machine-readable format may be beneficial where Guarantee Case 60 is used as part of or facilitates the development of certain established devices, systems, and / or processes, as discussed in more detail below. This format will facilitate easy input, reading, and / or processing of the logic of Guarantee Case 60 by another device, system, and / or process, thereby reducing the computational effort required. This, in turn, means that such devices, systems, and / or processes can reduce their size, power consumption, and / or other operational requirements while still being able to incorporate Guarantee Case 60 into their operation.

[0067] When stakeholders are individuals, regulatory bodies, etc., a human-readable format can be beneficial. Ensuring Case 60 can be quickly generated and transmitted to relevant stakeholders facilitates faster iteration and / or collaboration among stakeholders.

[0068] Now go to Figure 4 Continue to refer to Figure 1An exemplary method 400 for generating self-consistency guarantee cases is shown. It is understood that the steps listed herein are general, and certain steps may be combined and / or viewed in combination where appropriate. Additionally or alternatively, certain steps may be divided into sub-steps, reordered, and otherwise reorganized while achieving the same effect.

[0069] In addition to the above description, in step 410, data entry 12 is stored in normalized database 10. Normalized database 10 may be pre-populated and / or actively updated, maintained and / or otherwise modified before, during and / or after the execution of method 400 herein.

[0070] In step 420, the user can submit a query 24 to the computational model 20 through interface 22. This query contains instructions to generate guarantee cases based on certain requested criteria. In addition to the above, query 24 may include any number and / or combination of requests 25, sample guarantee cases 26, and / or guarantee case objectives 27, which can guide the computational model to generate guarantee cases 60.

[0071] In step 430, computational model 20 formulates requests to normalized database 10 based on user-submitted query 24 and populates them into guarantee case candidates 62. Through these requests, computational model 20 retrieves any number of data entries 12 and / or relationships 13 within normalized database 10. Retrieving entries from normalized database 10 can alternatively be conceptualized as a sub-step 432 of step 430.

[0072] Furthermore, computational model 20 can populate the guaranteed case candidate 62 with data retrieved from normalized database 10. Computational model 20 can also synthesize any supplementary information to populate the guaranteed case candidate 62, such that the supplementary information is not in the form or type stored in the normalized database. These population functions can alternatively be conceptualized as a sub-step 434 of step 430.

[0073] In step 440, independent of and / or together with any of the steps described above, one or more constraints 32 may be stored in constraint library 30 for use by one or more critics 40, computational model 20 and / or translator 50.

[0074] In step 450, once the guarantee case candidate 62 is generated, the critic 40 processes the guarantee case candidate 62 against one or more constraints 32 contained in the constraint library 30 to determine whether the guarantee case candidate 62 satisfies those constraints 32 and / or satisfies any other correctness, completeness, or compliance of the final guarantee case 60. The critic 40 may also request and / or otherwise consult information from the normalization database 10 to ensure that the entries populated into the guarantee case candidate 62 are consistent with the data stored in the normalization database 10.

[0075] If the predetermined number of constraints 32 are satisfied, in addition to the above discussion, in step 460, the critic 40 then passes the guarantee case candidate 62 to the translator 50 to generate the final guarantee case 60.

[0076] However, if one or more constraints 32 are not satisfied, or if a specific number and / or type of constraints 32 are not satisfied, the reviewer 40 may reject the guarantee case candidate 62 and return it to step 430 and the computational model 20 for resynthesis / regeneration. The reviewer 40 may optionally pass additional information to the computational model 20 regarding the nature, type, and / or unsatisfied constraints 32 to help the computational model 20 generate more correct guarantee case candidates 62 for further review. The reviewer 40 may optionally prompt the user for more information in a similar manner.

[0077] Once generated, Assurance Case 60 may be displayed to a user; stored in a computer-readable storage medium for later retrieval and / or display; and / or transmitted to one or more computing systems, display systems, mobile devices, etc., for viewing and / or review by one or more users, stakeholders, devices, and / or systems. Additionally or alternatively, in response to the generation of Assurance Case 60, a notification may be generated and / or otherwise transmitted to one or more users, stakeholders, devices, and / or systems.

[0078] In some examples, the existence of Guarantee Case 60 may serve as a prerequisite for the operation of the device and / or system. As used herein, Guarantee Case 60 "exists" if the controller of the device and / or system, etc., has access to Guarantee Case 60, certain representations thereof (e.g., hashes, decompositions, etc.), and / or other data / metadata related to Guarantee Case 60 (e.g., dates, results, proofs, conclusions, constraint accuracy, etc.). Guarantee Case 60 or its derivatives may be accessed directly and / or indirectly by the device and / or system, for example, by means of computer-readable storage within the device and / or system itself, by means of access via a network (e.g., a licensing server), etc.

[0079] In some examples, a computer system, engine, medical device, etc., or certain subcomponents / subsystems thereof, can serve as the subject of a given warranty case 60 and can be constructed to be inoperable unless a valid warranty case 60 or related information exists. In other words, the existence of warranty case 60 can be critical to unlocking or otherwise enabling the operability of the device and / or system described in at least part of this document.

[0080] In some examples, warranty case 60 may describe a specific process, procedure, function, etc., performed by a given device and / or system (or its sub-components and / or subsystems), and the existence of warranty case 60 or related information may serve as a prerequisite for performing said process, procedure, function, etc. Additionally or alternatively, warranty case 60 or related information may include operating parameters related to said process, procedure, function, etc. For example, warranty case 60 may include parameters such as power settings, input and / or flow settings, timing settings, sensor thresholds, etc., which can then be used for the operation of the device and / or system and / or the execution of said process, procedure, function, etc.

[0081] In some examples, warranty case 60 may include information related to the operational life of the equipment and / or system, such as maximum operating duration, maximum number of cycles, and / or any other similar life or maintenance-related metrics. Therefore, the equipment and / or system may be configured to operate only within any limits not exceeding the operational life metric described in warranty case 60 or related information.

[0082] Additionally or alternatively, Assurance Case 60 may be automatically generated in response to a triggering event. Triggering events may include: adding new reports, studies, evidence, etc., to the normalization database 10; establishing and / or revising data entries 12 and / or relationships 13 within the normalization database 10; the publication, announcement, or similar issuance of new regulatory norms, guidelines, best practices, standards, etc., that affect the logical content and / or results of Assurance Case 60; the publication, announcement, or similar issuance of revisions to existing regulatory norms, guidelines, best practices, standards, etc., that affect the logic, content, and / or results of Assurance Case 60; changes to equipment and / or systems that may depend at least in part on the operation of Assurance Case 60; and / or any other event that may affect the content, logic, results, and / or effectiveness of Assurance Case 60.

[0083] For example, the project manager may not be aware that a regulation has changed, but may still automatically receive updated Assurance Case 60 according to that regulation via email or other means. This eliminates the need for the project manager to review regulatory changes; determine which changes (if any) are needed to the existing Assurance Case 60; coordinate updates to these Assurance Cases 60 among relevant teams; and so on. It is also understood that transmitting Assurance Case 60 to the project manager may include both the new Assurance Case 60 and the previous Assurance Case, and may include highlighting, red lines, summaries, etc., explaining what has changed and / or why. Such summaries can also be generated by computational model 20.

[0084] This continuous automatic generation of guarantee case 60 may originate from a single query 24. For example, query 24 may include a request for computational model 20 to monitor specific triggering events, update guarantee case 60 in response to the occurrence of these specific triggering events, and execute specific procedures when generating guarantee case 60. In addition to the above, the specific procedures may also include transmitting guarantee case 60 to users, relevant stakeholders, devices, systems, and / or sub-parts that rely on guarantee case 60 for operation.

[0085] This disclosure includes a non-transitory computer-readable storage medium containing instructions that, when executed by at least one processor, cause the processor to perform any or other of the processes described in steps 400-460. This may include enabling one or more computers to function as an interface for receiving, processing, and outputting user queries.

[0086] Now go to Figure 5-6 This illustrates another exemplary system 500 for generating self-consistent guarantee cases consistent with the above disclosure. Although Figure 1 Those exemplary systems 1 address the issue that computational model 20 performs a large portion of the work to generate the construction of guaranteed case 60, but Figure 5 The exemplary systems 500 address the scenario where users 570 tend to use manual application methods more when generating guarantee cases 560.

[0087] Therefore, user 570 can use system 500 to help generate guarantee case 560 (such as...). Figure 6 (as shown) one or more parts. Figure 6In the exemplary GSN format warranty case 600 shown, user 570 may wish to generate the entire claim tree 610 or a sub-section of warranty case 600, or user 570 may be seeking to populate specific features 620 of warranty case 600. In either case, user 570 may not know which features 620 and / or claim tree 610 to incorporate into warranty case 600, and / or which evidence and / or data to populate specific features 620 to achieve the objectives of warranty case 600.

[0088] Figure 6 The feature 620 of the exemplary GSN format assurance case 600 shown may include an objective (e.g., a claim to be proven or guaranteed), a strategy (e.g., reasoning, logical testing, criteria), a solution (e.g., evidence and / or data), and context (e.g., clarification, assumptions) presented in a flowchart format, whereby one feature 620 feeds into the next feature to form a claim tree 610, making the structured logical reasoning visually apparent. For example, a strategy may originate from an objective, while the solution and / or context may originate from the strategy, thus making it easy to see which solutions and / or contexts are used with which strategies to support the objective.

[0089] To help user 570, Figure 5 System 500 may include the above Figure 1 The system 500 may also include a normalized database 510, wherein normalized data entries and correspondences 13 may be stored in a normalized and filtered manner. However, the system 500 may also be equipped with a raw database 515, such that the raw database 515 contains at least some of the data stored in the normalized database 510 as raw data entries, although in a raw, unprocessed, unnormalized and / or denormalized form.

[0090] System 500 may be equipped with a user interface 522. User interface 522 may be conceptualized as two different interfaces, specifically a computational model interface 524 and a guarantee case interface 526. The computational model interface 524 and the guarantee case interface 526 may be part of the same interface or may be separated among multiple different interfaces.

[0091] A computational model interface 524 is provided to receive queries 525 from user 570 related to the user's current task, such as questions related to features 620 or claim trees 610 that user 570 is attempting to generate and / or populate within guarantee case 560. Query 525 is a natural language request submitted by user 570, requesting instructions from computational model 520 regarding filling or how to fill guarantee case candidates. The computational model interface 524 then passes the user's query 525 to computational model 520 for processing. Query 525 here may have a similar form and content to query 24 described above.

[0092] Access to the original database 515 can be provided to the computational model 520, enabling the computational model 520 to identify potentially usable evidence within the normalized database 510 from the information contained within the original database 515, and / or to generate predictions about what evidence might be available within the normalized database 510 based on the information contained within the original database 515. The computational model can then provide these inferences as recommendations back to the user 570 through the computational model 520 interface 524. For example, the recommendations may include instructions from the user 570 to retrieve specific data entries, specific studies or reports, specific testing procedures, specific relationships between entries, etc., from the normalized database 510. Additionally or alternatively, the recommendations may include further details regarding where this information should be populated in the assurance case 560. Here, as described above, the computational model 520 can be any suitable computational model. Some aspects include a computational model 520 formed as an LLM.

[0093] A guarantee case interface 526 is provided so that user 570 can fill in guarantee case 560 and user 570 can submit one or more retrieval requests 527 to the normalization database 510 to retrieve information from the normalization database for filling in guarantee case 560.

[0094] The guarantee case interface 526 facilitates user 570 in inputting one or more search requests 527 into the normalized database 510 by providing a search interface, such as a search window, search input field, text input field, and / or other similar means of receiving input from user 570. As mentioned above, the interface may include, but is not limited to, audio / voice interfaces, etc.

[0095] The guarantee case interface 526 also facilitates users 570 to input information (such as information obtained from the normalized database 510 in response to one or more retrieval requests 527) into the guarantee case 560.

[0096] Although retrieval request 527 may have a similar form and content to query 24 described above, retrieval request 527 is more likely to contain a more targeted request, at least in part due to the feedback provided to user 570 by computational model 520. Therefore, once retrieved, user 570 can directly populate guarantee case 560 with the information, and / or can derive inferences / conclusions from the retrieved information and then populate guarantee case 560.

[0097] The assurance case interface 526 may optionally be configured to restrict user 570 to a predefined format when filling in assurance case 560, thereby ensuring the compliance of user 570 and / or potentially reducing user errors in data entry.

[0098] Additionally or alternatively, the case interface 526 is guaranteed to be configured to provide suggestions to user 570 regarding query 525, which user 570 can submit to computational model 520, or suggestions regarding retrieval request 527, which user 570 can submit to normalized database 510. If enforced, these suggestions may be derived from or built into a predefined format.

[0099] System 500 may also be equipped with a commentator 540, similar to the commentator 40 described above. The commentator 540 can interface with a constraint library 530 containing one or more constraints 532. When user 570 populates guarantee cases 560, the commentator 540 can automatically and / or respond to prompts from user 570 to check the guarantee cases 560 generated in the case interface against one or more constraints. As described above, the commentator 540 can be implemented using formal methods.

[0100] If the commentator 540 determines that the warranty case 560 meets the predetermined number of constraints, the user 570 may continue to finalize or otherwise complete the warranty case 560, and, in addition to the above, store and / or transmit the warranty case 560.

[0101] However, if the critic 540 determines that the warranty case 560 does not meet the predetermined number of constraints, in any combination other than those discussed above, the critic 540 may return the warranty case 560 to the user 570 for correction.

[0102] Additionally or alternatively, the critic 540 may be incorporated into steps beyond those described above. For example, before presenting the recommendations provided by the computational model 520 to the user 570, the critic 540 may evaluate these recommendations based on one or more constraints. Additionally or alternatively, before presenting or displaying the recommendations provided by the computational model 520 to the user 570, the critic 540 may assess the accuracy of these recommendations. As another example, the critic 540 may generate and send a critic query to the computational model 520 to provide the user 570 with additional context regarding which constraints failed and what changes can be made to resolve the errors.

[0103] Now combine Figure 5-6 Go to Figure 7 This shows the result of Figure 5 The exemplary methods 700 performed by the systems 500 shown are illustrated.

[0104] In step 710, the data may be stored in the normalized database 510 and the original database 515. As described above, the normalized database 510 and / or the original database 515 may be pre-populated and / or actively updated, maintained and / or otherwise modified before, during and / or after performing the method 700 herein.

[0105] In step 720, user 570 may submit a query 525 to computation model 520 through computation model interface 524, requesting assistance in completing at least a part of guarantee case 560, such as claim tree 610 or feature 620 of guarantee case 560.

[0106] In step 730, computational model 520 may utilize and / or consider information stored in the original database 515 to process query 525 in order to provide recommendations to user 570. Optionally, before displaying the recommendations to user 570, critic 540 may review the accuracy of the recommendations, for example by checking the recommendations against one or more constraints. If the recommendations are inaccurate, critic 540 may then re-query computational model 520 on behalf of user 570, may notify user 570 to resolve the issue, or both.

[0107] In step 740, user 570 may then submit one or more retrieval requests 527 to the normalization database 510 to retrieve information to be filled and / or information to form inferences and / or conclusions to be filled into guarantee case 560.

[0108] In step 750, the critic 540 may automatically or at the prompt of the user 570 check the guarantee case 560 against one or more constraints 532 stored in the constraint library 530 to determine whether the guarantee case 560 satisfies those constraints 532 and / or satisfies any other correctness, integrity or compliance conditions.

[0109] In step 760, if it is determined that guarantee case 560 does not meet a predetermined number of constraints, critic 540 may return guarantee case 560 to user 570. Optionally, critic 540 may further query computational model 520 and original database 515 to provide user 570 with additional feedback and / or context to address the defect.

[0110] This disclosure includes a non-transitory computer-readable storage medium containing instructions that, when executed by at least one processor, cause the processor to perform any or other processes described in steps 700-760. This may include enabling one or more computers to function as an interface for receiving and processing user queries.

[0111] Understandably, the systems and methods disclosed herein provide a significantly improved system for generating guarantee cases, enhancing users' ability to generate guarantee cases and the resulting utility. These systems and methods allow users to consider more information than before when developing guarantee cases and improve system usability by allowing users to use natural language and informal queries. These systems and methods also address issues related to different and / or evolving regulations and standards, allowing for faster generation of guarantee cases and / or other adaptations to specific stakeholders. The use of a reviewer module and constraints ensures that the generated guarantee cases are self-consistent and that the logical chains contained within them satisfy the overall objectives. These performance and capability improvements further facilitate the use of guarantee cases early in the design process, not just at its end, thereby accelerating the innovation and development of new ideas and concepts.

[0112] A range may be expressed herein as from “about” a particular value and / or to “about” another particular value. When such a range is expressed, another embodiment includes from one particular value and / or to another particular value. Similarly, when values ​​are expressed as approximate values, it can be understood, by using the antecedent “about,” that the particular value forms another embodiment. It will be further understood that the endpoints of each range are significant both relative to and independent of the other endpoint.

[0113] The directional terms used in this article, such as up, down, right, left, front, back, top, and bottom, are for reference only with reference to the accompanying drawings and do not imply absolute orientation.

[0114] The term “connection” as used in this article can refer to direct connection between components as well as indirect connection through one or more intermediate components.

[0115] Unless otherwise expressly stated, no method described herein implies a requirement that its steps be performed in a particular order, nor does it imply any specific orientation of the apparatus. Therefore, if a method claim does not explicitly specify the order in which its steps are followed, or any apparatus claim does not explicitly specify the order or orientation of any individual component, or if the claims or specification do not specifically state that the steps will be limited to a particular order, or do not explicitly specify a particular order or orientation of the apparatus components, then in no way is it implied that an order or orientation should be inferred. This applies to any possible non-express basis of interpretation, including: logical questions relating to the arrangement of steps, the flow of operations, the order of components, or the orientation of components; simple meanings derived from grammatical organization or punctuation; and the number or type of embodiments described in the specification.

[0116] As used herein, unless the context clearly indicates otherwise, the singular forms “a,” “a,” and “the” include plural references. Thus, for example, unless the context clearly indicates otherwise, a reference to a component “a” includes aspects having two or more such components.

[0117] As used herein, "processor" can refer to any computing device capable of executing instructions, performing logical operations, and / or processing data, and can include, but is not limited to, general-purpose central processing units (CPUs), field-programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), and other processing units such as graphics processing units (GPUs), neural processing units (NPUs), and / or digital signal processors (DSPs). Processors can be implemented as a single processing core, a multi-core architecture, and / or a distributed network of processing elements. Processors can be integrated within a system-on-a-chip (SoC) or as a discrete component that interfaces with other system elements.

[0118] Further aspects of the embodiments described herein are provided by the subject matter of the following items:

[0119] A system for generating self-consistent guaranteed cases. The system includes one or more normalized databases containing data entries, each data entry including evidence, one or more activities, one or more subjects, and one or more relationships between two or more of the evidence, activities, and subjects. The system includes a computational model interface configured to receive input from a user and pass that input as a query to a computational model configured to process the query to generate guaranteed case candidates. The system includes a constraint library containing one or more constraints stored in a commentator-readable format. The system includes a commentator module configured to process the guaranteed case candidates generated by the computational model to determine whether the guaranteed case candidates satisfy one or more constraints. The system includes a translator module configured to convert the guaranteed case candidates into a human-readable format.

[0120] According to any of the preceding clauses, in order to generate the guaranteed case candidates, the computational model is further configured to retrieve one or more data entries corresponding to the query from the normalized database.

[0121] According to any of the preceding clauses, the system wherein the computational model is further configured to populate the guarantee case candidates with the one or more data entries retrieved from the normalized database.

[0122] According to any of the preceding clauses, the system wherein the computational model is further configured to process the one or more data entries retrieved from the normalized database to generate supplementary information related to the one or more data entries.

[0123] According to any of the preceding clauses, the system wherein the computational model is further configured to populate the guarantee case candidates with the supplementary information.

[0124] According to any of the preceding clauses, the computational model is further configured to forward the one or more data entries retrieved from the normalized database to a second computational model, the second computational model being configured to populate the guarantee case candidates with the one or more data entries.

[0125] According to any of the preceding clauses, the second computational model is further configured to populate the guarantee case candidates with the supplementary information.

[0126] According to any of the preceding clauses, the normalized database is constructed based on a database ontology.

[0127] According to any of the preceding clauses, the system wherein the computational model is configured to process the at least one query in a manner consistent with the database ontology.

[0128] According to any of the preceding clauses, the system wherein the query includes the user's natural language request.

[0129] According to any of the preceding clauses, the system wherein the query includes the sample guarantee case provided by the user.

[0130] According to any of the preceding clauses, the system wherein the query includes the objective and / or objective conclusion that the guaranteed case is to satisfy.

[0131] According to any of the preceding clauses, the system in which the query is ontology is different from the database ontology.

[0132] According to any of the preceding clauses, in a system where, if the guaranteed case candidate fails to satisfy one or more constraints, the commentator is configured to return the guaranteed case candidate to the computational model for further generation.

[0133] A system for generating self-consistent guaranteed cases. The system includes one or more normalized databases containing data entries, each data entry including evidence, one or more activities, one or more subjects, and one or more relationships between two or more of the evidence, activities, and subjects. The system also includes one or more raw data databases containing raw data entries, such that one or more of the data entries in the normalized databases are based on one or more of the raw data entries. The system includes a computational model interface configured to receive input from a user and pass the input as a query to a computational model configured to process the query to generate guaranteed case candidates. The system further includes a guaranteed case interface configured to allow or facilitate the user to input one or more retrieval requests into the normalized database to retrieve one or more data entries stored therein. The guaranteed case interface is further configured to allow or facilitate the user to input one or more of the retrieved data entries into the guaranteed case candidates. Finally, the system includes a constraint library containing one or more constraints stored in a commentator-readable format. The system includes a critic module configured to process the guaranteed case candidates generated by the computational model to determine whether the guaranteed case candidates satisfy one or more constraints.

[0134] According to any of the preceding clauses, the system wherein the computational model is configured to process one or more queries to generate responsive recommendations based on information contained within the original data database.

[0135] According to any of the preceding clauses, the system wherein the inquiry is a natural language request from the user for instructions on how to populate at least a portion of the guaranteed case candidates.

[0136] According to any of the preceding clauses, at least a portion of the guarantee case candidates is a claim tree of the guarantee case candidates.

[0137] According to any of the preceding clauses, the at least a portion of the guaranteed case candidate is a characteristic of the guaranteed case candidate.

[0138] According to any of the preceding clauses, the at least one commentator is further configured to submit a commentator query to the computational model if the guaranteed case candidate fails one or more constraints.

[0139] According to any of the preceding clauses, the guarantee case interface is further configured to restrict the user to a predefined format of the guarantee case candidates.

[0140] According to any of the preceding clauses, the guaranteed case interface is further configured to generate suggestions based on the predefined format for retrieval requests or queries submitted by the user to the normalized database or the computational model.

[0141] According to any of the preceding clauses, the at least one reviewer is further configured to evaluate the accuracy of the recommendations before presenting the recommendations provided by the computational model to the user.

[0142] According to any of the preceding clauses, the at least one critic is further configured to evaluate the recommendation based on one or more constraints.

[0143] According to any of the preceding clauses, the existence of the guarantee case is used as a prerequisite for the operation of the device, system and / or its sub-parts.

[0144] According to any of the preceding clauses, the existence of the warranty case is critical to enabling the device, system and / or its sub-parts to operate.

[0145] According to any of the preceding clauses, the information derived from the warranty case is critical to enabling the device, system and / or its sub-parts to operate.

[0146] According to any of the preceding clauses, the information derived from the guarantee case is a hash or decomposition of the guarantee case.

[0147] According to any of the preceding clauses, the information derived from the guarantee case is a hash or decomposition of the claim tree of the guarantee case.

[0148] According to any of the preceding clauses, the information included in the warranty case is used to provide operating parameters for the processes, procedures, functions, etc. performed by the device, system, and / or its sub-parts.

[0149] According to any of the preceding clauses, the guarantee case is generated in response to a triggering event.

[0150] According to any of the preceding clauses, the triggering event is adding new information to the normalized database.

[0151] According to any of the systems described in the foregoing clauses, the triggering event is an update of regulations, guidelines, best practices, standards, etc., related to the warranty case.

[0152] According to any of the preceding clauses, the system is a device, system and / or its sub-parts being added to and / or modified, the operation of the device, system and / or its sub-parts depending at least in part on the existence of the warranty case.

[0153] A method for generating self-consistent guaranteed cases. The method includes storing multiple data entries in one or more normalized databases. The method includes submitting a query to a computational model via a computational model interface. The method includes storing at least one constraint in a constraint library in a commentator-readable format. The method includes generating guaranteed case candidates based on the query. The method includes having the guaranteed case candidates processed by a commentator module to determine whether the guaranteed case candidates satisfy one or more of the at least one constraint. The method includes translating the guaranteed case candidates into a human-readable format.

[0154] According to any of the methods described in the foregoing clauses, the data entry includes evidence, one or more activities, one or more subjects, and one or more relationships between two or more of the evidence, the activities, and the subjects.

[0155] According to any of the methods described in the foregoing clauses, the generation of the guaranteed case candidate includes retrieving one or more data entries corresponding to the query from the normalized database.

[0156] According to any of the methods described in the foregoing clauses, the generation of the guarantee case candidate further includes populating the guarantee case candidate with one or more data entries.

[0157] According to any of the methods described in the foregoing clauses, generating the guarantee case candidate further includes processing the one or more data entries with the computational model to generate supplementary information related to the one or more data entries.

[0158] According to any of the methods described in the foregoing clauses, generating the guarantee case further includes populating the guarantee case candidate with the supplementary information.

[0159] According to any of the methods described in the foregoing clauses, generating the guaranteed case further includes forwarding one or more data entries corresponding to the query to a second computation model.

[0160] According to any of the methods described in the foregoing clauses, the generation of the guarantee case candidate further includes populating the guarantee case candidate with one or more data entries using the second computational model.

[0161] According to any of the methods described in the foregoing clauses, the generation of the guaranteed case candidate further includes processing one or more data entries with the second computational model to generate supplementary information related to the one or more data entries.

[0162] According to any of the methods described in the foregoing clauses, generating the guarantee case further includes populating the guarantee case candidates with the supplementary information using the second calculation model.

[0163] According to any of the methods described in the foregoing clauses, the normalized database is constructed based on a database ontology.

[0164] According to any of the methods described in the foregoing clauses, the computational model is configured to process the at least one query in a manner consistent with the database ontology.

[0165] According to any of the methods described in the foregoing clauses, the query includes the user's natural language request.

[0166] According to any of the methods described in the foregoing clauses, the query includes the sample guarantee case provided by the user.

[0167] According to any of the methods described in the foregoing clauses, the query includes the objective and / or objective conclusion that the guaranteed case is to satisfy.

[0168] According to any of the methods described in the foregoing clauses, the ontology of the query is different from the database ontology.

[0169] According to any of the methods described in the foregoing clauses, the method further includes returning the guaranteed case candidate to the computational model for further generation if the guaranteed case candidate fails to satisfy one or more constraints.

[0170] A method for generating self-consistent guaranteed cases. The method includes storing multiple data entries in one or more normalized databases. The method includes storing multiple original data entries in one or more original data databases, such that one or more of the data entries in the normalized databases are based on one or more of the original data entries. The method includes submitting one or more queries to a computational model via a computational model interface. The method includes processing the queries to generate recommendations in response to the queries based on information contained in the original databases. The method includes submitting one or more retrieval requests to the normalized databases via a guaranteed case interface to retrieve one or more data entries. The method includes inputting the data entries into a guaranteed case candidate pool. The method includes processing the guaranteed case candidates with a critic to determine whether the guaranteed case candidates satisfy one or more constraints.

[0171] According to any of the methods described in the foregoing clauses, the method further includes returning the guarantee case candidate to the user if the guarantee case candidate fails one or more constraints / when the guarantee case candidate fails one or more constraints.

[0172] According to any of the methods described in the foregoing clauses, the method further includes submitting a commentator query to the computational model if the guaranteed case candidate fails to pass one or more of the at least one constraint / when the guaranteed case candidate fails to pass one or more of the at least one constraint.

[0173] According to any of the methods described in the foregoing clauses, the method further includes having the at least one reviewer evaluate the accuracy of the recommendations before presenting the recommendations provided by the computational model to the user.

[0174] According to any of the methods described in the foregoing clauses, the recommendation is evaluated according to one or more constraints.

[0175] According to any of the methods described in the foregoing clauses, the guarantee case interface is further configured to restrict the user to a predefined format of the guarantee case candidates.

[0176] According to any of the methods described in the foregoing clauses, the guaranteed case interface is further configured to generate suggestions for the retrieval requests or queries submitted by the user to the normalized database or the computational model based on the predefined format.

[0177] According to any of the methods described in the foregoing clauses, the inquiry includes a natural language request from a user for instructions on how to populate at least a portion of the guaranteed case candidates.

[0178] According to any of the methods described in the foregoing clauses, the data entry includes evidence, one or more activities, one or more subjects, and one or more relationships between two or more of the evidence, the activities, and the subjects.

[0179] According to any of the methods described in the foregoing clauses, the existence of the guarantee case is used as a prerequisite for the operation of the device, system and / or its sub-parts.

[0180] According to any of the methods described in the foregoing clauses, the existence of the warranty case is critical to enabling the device, system and / or its sub-parts to operate.

[0181] According to any of the methods described in the foregoing clauses, the information derived from the warranty case becomes critical to enabling the device, system and / or its sub-parts to operate.

[0182] According to any of the methods described in the foregoing clauses, the information derived from the guarantee case is a hash or decomposition of the guarantee case.

[0183] According to any of the methods described in the foregoing clauses, the information derived from the guarantee case is a hash or decomposition of the claim tree of the guarantee case.

[0184] According to any of the methods described in the foregoing clauses, the information included in the warranty case is used to provide operating parameters for the processes, procedures, functions, etc. performed by the device, system, and / or its sub-parts.

[0185] According to any of the methods described in the foregoing clauses, the guarantee case is generated in response to a triggering event.

[0186] According to any of the methods described in the foregoing clauses, the triggering event is adding new information to the normalized database.

[0187] According to any of the methods described in the foregoing clauses, the triggering event is an update of regulations, guidelines, best practices, standards, etc., related to the warranty case.

[0188] According to any of the methods described in the foregoing clauses, the triggering event is the addition and / or modification of a device, system and / or its sub-parts, the operation of which depends at least in part on the existence of the warranty case.

[0189] A non-transitory computer-readable storage medium includes instructions that, when executed by at least one processor, cause the at least one processor to operate a computational model to generate self-consistent guaranteed cases. The storage medium includes instructions that cause the processor to receive a query submitted by a user through a computational model interface. The storage medium includes instructions that cause the processor to retrieve data entries corresponding to the query from one or more normalized databases. The storage medium includes instructions that cause the processor to populate guaranteed case candidates with the one or more data entries retrieved from the normalized databases. The storage medium includes instructions that cause the processor to forward the guaranteed case candidates to a reviewer, the reviewer being configured to determine whether the guaranteed case candidates satisfy at least one constraint.

[0190] According to any of the preceding clauses, the storage medium, wherein the data entry includes evidence, one or more activities, one or more subjects, and one or more relationships between two or more of the evidence, the activities, and the subjects.

[0191] According to any of the preceding clauses, the storage medium wherein the computational model is further configured to process the one or more data entries retrieved from the normalized database to generate supplementary information related to the one or more data entries.

[0192] According to any of the preceding clauses, the storage medium wherein the computational model is further configured to populate the guarantee case candidates with the supplementary information.

[0193] According to any of the preceding clauses, the storage medium wherein the computational model is further configured to forward the one or more data entries retrieved from the normalized database to a second computational model, the second computational model being configured to populate the guarantee case candidates with the one or more data entries.

[0194] According to any of the preceding clauses, the storage medium wherein the second computational model is further configured to populate the guarantee case candidates with the supplementary information.

[0195] According to any of the preceding clauses, the storage medium wherein the normalized database is constructed based on the database ontology.

[0196] According to any of the preceding clauses, the storage medium wherein the computational model is configured to process the at least one query in a manner consistent with the database ontology.

[0197] According to any of the preceding clauses, the storage medium, wherein the query includes the user's natural language request.

[0198] According to any of the preceding clauses, the storage medium, wherein the query includes the sample guarantee case provided by the user.

[0199] According to any of the preceding clauses, the storage medium, wherein the query includes the objective and / or objective conclusion that the guaranteed case is to satisfy.

[0200] The storage medium described in any of the foregoing clauses, wherein the ontology of the query is different from the database ontology.

[0201] According to any of the preceding clauses, the storage medium wherein the commentator is configured to return the guaranteed case candidate to the computational model for further generation if the guaranteed case candidate fails to satisfy one or more constraints.

[0202] A non-transitory computer-readable storage medium includes instructions that, when executed by at least one processor, cause the at least one processor to operate a user interface to generate self-consistent guaranteed cases. The storage medium includes instructions that cause the processor to receive one or more queries from a user. The storage medium includes instructions that cause the processor to transmit the queries to a computational model configured to process the queries and generate recommendations as a response based on information contained within an original data database. The storage medium includes instructions that cause the processor to display the recommendations to the user. The storage medium includes instructions that cause the processor to receive from the user a retrieval request for one or more normalized data entries from one or more normalized databases. The storage medium includes instructions that cause the processor to receive instructions from the user to input data entries into guaranteed case candidates. The storage medium includes instructions that cause the processor to transmit the guaranteed case candidates to a reviewer to evaluate whether the guaranteed case candidates satisfy one or more constraints.

[0203] According to any of the preceding clauses, the storage medium, wherein the data entry includes evidence, one or more activities, one or more subjects, and one or more relationships between two or more of the evidence, the activities, and the subjects.

[0204] According to any of the preceding clauses, one or more of the data entries in the normalized database are based on one or more of the original data entries.

[0205] According to any of the preceding clauses, the storage medium wherein the inquiry includes a natural language request from the user for instructions on how to populate at least a portion of the guaranteed case candidates.

[0206] According to any of the preceding clauses, the storage medium wherein the user interface is further configured to restrict the user to a predefined format of the guaranteed case candidate.

[0207] According to any of the preceding clauses, the storage medium wherein the user interface is further configured to generate suggestions for retrieval requests or queries submitted by the user to the normalized database or the computational model based on the predefined format.

[0208] According to any of the preceding clauses, the storage medium wherein the user interface is further configured to transmit the recommendation to the reviewer for evaluation of the accuracy of the recommendation before displaying it to the user.

[0209] According to any of the preceding clauses, the storage medium wherein the at least one reviewer evaluates the recommendation based on one or more constraints.

[0210] According to any of the preceding clauses, the existence of the guarantee case is used as a prerequisite for the operation of the device, system and / or its sub-parts.

[0211] According to any of the preceding clauses, the existence of the warranty case is critical to enabling the device, system and / or its sub-parts to function.

[0212] According to any of the preceding clauses, the storage medium wherein the information derived from the warranty case is critical to enabling the device, system and / or its sub-parts to function.

[0213] According to any of the preceding clauses, the storage medium wherein the information derived from the guarantee case is a hash or decomposition of the guarantee case.

[0214] According to any of the preceding clauses, the storage medium wherein the information derived from the guarantee case is a hash or decomposition of the claim tree of the guarantee case.

[0215] According to any of the preceding clauses, the storage medium, wherein the information contained in the warranty case is used to provide operating parameters for the processes, programs, functions, etc. performed by the device, system, and / or its sub-parts.

[0216] According to any of the preceding clauses, the storage medium, wherein the guarantee case is generated in response to a triggering event.

[0217] According to any of the preceding clauses, the storage medium wherein the triggering event is the addition of new information to the normalized database.

[0218] According to any of the preceding clauses regarding the storage medium, wherein the triggering event is an update of regulations, guidelines, best practices, standards, etc., related to the warranty case.

[0219] According to any of the preceding clauses, the storage medium wherein the triggering event is an addition and / or change to a device, system and / or its sub-parts, the operation of which depends at least in part on the existence of the warranty case.

[0220] While specific aspects have been shown and described herein, it should be understood that various other changes and modifications may be made without departing from the spirit and scope of the claimed subject matter. Furthermore, although various aspects of the claimed subject matter have been described herein, these aspects need not be used in combination. Therefore, the appended claims are intended to cover all such changes and modifications within the scope of the claimed subject matter.

Claims

1. A system for generating self-consistent guaranteed cases, characterized in that, The system includes: A standardized database, wherein the standardized database contains evidence, activities, subjects, and relationships between two or more of the evidence, activities, and subjects as data entries; A computational model interface is configured to facilitate users submitting queries to a computational model, wherein the computational model is configured to process the queries to generate guaranteed case candidates. A constraint library containing at least one constraint stored in a commentator-readable format; A critic, configured to process the guaranteed case candidates generated by the computational model, to determine whether the guaranteed case candidates satisfy one or more of the at least one constraint; and A translator configured to convert the guarantee case candidates into a predetermined format.

2. The system according to claim 1, characterized in that, in, To generate the guaranteed case candidates, the computational model is further configured to retrieve and query one or more corresponding data entries from the normalized database, and The computational model is further configured to populate the guarantee case candidates with the one or more data entries.

3. The system according to claim 2, characterized in that, in, To generate the guaranteed case candidates, the computational model is further configured to process the retrieved one or more data entries to generate supplementary information related to the one or more data entries, and The computational model is further configured to populate the guaranteed case candidates with the supplementary information.

4. The system according to claim 1, characterized in that, in, To generate the guaranteed case candidates, the computational model is further configured to retrieve one or more data entries corresponding to the query from the normalized database, and The computational model is further configured to forward the one or more data entries corresponding to the query and the query to a second computational model, which is configured to populate the guaranteed case candidates with the one or more data entries.

5. The system according to claim 4, characterized in that, in, To generate the guaranteed case candidates, the second computational model is further configured to process the one or more data entries to generate supplementary information related to the one or more data entries, and The second calculation model is further configured to populate the guarantee case candidates with the supplementary information.

6. The system according to claim 1, characterized in that, in, The query includes the user's natural language request and a sample guarantee case.

7. The system according to claim 6, characterized in that, in, The normalized database is constructed based on database ontology, and The computational model is configured to process the at least one query in a manner consistent with the database ontology.

8. The system according to claim 7, characterized in that, in, The ontology of the query is different from the ontology of the database.

9. The system according to claim 6, characterized in that, in, The query further includes at least one guaranteed case objective.

10. The system according to claim 1, characterized in that, in, When the guaranteed case candidate fails to satisfy one or more of the at least one constraint, the commentator is configured to return the guaranteed case candidate to the computational model to generate another guaranteed case candidate.

Images