Computer-implemented methods for automatically analyzing or using data, including using large language models

Abstract

There is provided a method, such as a method of interacting with a large language model (LLM), comprising the steps of: a processing system providing new context data for the LLM using a structured machine-readable representation of data in a machine-readable language, such as a generic language, to improve an output, such as a continued text output, generated by the LLM in response to a prompt; a method, such as a method of interacting with an LLM, includes providing continuation data generated by the LLM to a processing system that uses a structured machine-readable representation of data in a machine-readable language, such as a generic language, the processing system is configured to analyze continuation output (e.g., textual output) generated by the LLM in response to a prompt to enable an improved version of the continuation output to be provided to a user. A related computer system is provided.

Description

Technical Field

[0001] The field of the invention relates to computer-implemented methods for automatically analyzing or using data, including the use of large language models (LLMs), and to related computer-implemented methods and systems. Background Art

[0002] Natural languages ​​(NL) are languages ​​evolved for humans, such as English. Despite significant progress in computers' ability to process natural languages, computers still cannot deeply understand the meaning of natural languages ​​and use that meaning internally.

[0003] For this reason, most computer applications typically use structured data to store the information they need to process—for example, a relational database: designing the schema, populating the database, and writing code to manipulate the fields in the database. Using structured data works well if the application has limited requirements for the type of data it needs. However, some applications naturally require extremely broad, heterogeneous data sets to work well. This means the required schema would be enormous, making building and coding such applications impractical. In this article, we refer to such applications as HUB applications (for heterogeneous and unreasonably broad).

[0004] Examples of HUB applications include applications for managing a person's general health data, where there are thousands of tests, thousands of medical conditions, and thousands of symptoms. Another related application might be a nutrition tracking application, where there are thousands of substances and foods that can be ingested, each with a different metabolic effect on the body. Another example is an application that matches a potential candidate's resume to a job specification: in principle, such an application would need structured data representing every skill that might be valuable for any role, every type of experience, every type of previous job. Accounting is another application where large amounts of heterogeneous data would be valuable: the perfect accounting application would represent every type of contract, every type of service. In reality, some of these applications, if they exist at all, work with limited schemes that fail to cover the full range of their desired characteristics. For example, health applications often work like this, ignoring many types of data they don’t cover, and instead end up being narrow—limiting the application to only certain verticals within health conditions. Applications can also use natural language or augment limited schemes with natural language—such as current resume matching applications, which may express some key skills in a structured form but otherwise rely heavily on keyword searches on written resumes or statistical natural language processing (NLP) techniques. In the case of accounting, transactions are represented by limited structured data—debits and credits on a virtual ledger with natural language names. The meaning of these natural language names, and therefore what these transactions represent, is often opaque to the application. The virtual ledger often groups different types of transactions together, but fails to represent potentially important semantic differences.

[0005] There is no exact threshold at which an application becomes a HUB application, but the difficulty of building an application using manually created schemas grows more than linearly with the number of tables, because managing these tables and maintaining their code becomes increasingly difficult. These problems could be solved if there were a language or way of representing data that computers could fully process and understand but also had an extremely wide range. In conventional artificial intelligence (AI), statistical machine learning (ML)—particularly deep learning (DL)—has been widely used. This has provided significant progress on many problems. Despite this progress, the results cannot be interpreted in a way that is meaningful to human users, as the solution is the result of calculations involving potentially billions of weights. It can also be said that the system lacks a "realistic" understanding of the data, or at least an understanding that is very different from how a human user would interpret it. The statistical nature of the technique also means that it is inherently unreliable for weights that are randomly generated and then refined through a training process in which the weights are exposed to data. For complex problems, this refinement (learning) often produces models that only work a certain percentage of the time, and it is impossible to reliably know when the results they produce are accurate.

[0006] Much of the processing of natural language is now done with DL. One example of DL applied to language is the Large Language Model (LLM). LLMs are typically very large deep learning models, potentially containing hundreds of billions of parameters and trained on tens of terabytes of text. While they can generate explanations, those explanations are not derived from what has already occurred within the model. The text generated by LLMs is often incorrect and often describes things that are not true.

[0007] Discussion of related technologies The Wikipedia page about Cyc from July 18, 2019 states that Cyc is the world's longest-running artificial intelligence project, attempting to assemble a comprehensive ontology and knowledge base spanning fundamental concepts and "rules of thumb" about how the world works (think common-sense knowledge, but focusing more on things that are rarely written down or spoken, as contrasted to facts one might find somewhere on the internet or retrieve via a search engine or Wikipedia), with the goal of enabling AI applications to perform human-like reasoning and be less "brittle" when faced with novel, unpredictable situations.

[0008] The Wikipedia page on Cyc from July 18, 2019 states that the goal of the Cyc project was to codify the millions of pieces of knowledge that constitute human common sense in a machine-usable form; this required along the way (1) developing a fully expressive representation language, CycL, (2) developing an ontology spanning all human concepts down to an appropriate level of detail, (3) developing a knowledge base based on this ontology framework that includes all human knowledge about these concepts down to an appropriate level of detail, and (4) developing an inference engine that was much faster than those used in conventional expert systems of the time, capable of inferring the same types and depth of conclusions that humans were capable of given their understanding of the world.

[0009] The Wikipedia page on Cyc from July 18, 2019 states that most of Cyc's knowledge, except for math and games, is true by default; for example, Cyc knows, by default, that parents love their children, that you smile when you are happy, that taking your first step is a big accomplishment, that big accomplishments make you happy when someone you love does something, and that only adults have children; when asked whether a picture titled "Someone watching his daughter take her first steps" contains a smiling adult, Cyc can logically infer that the answer is yes and "show it works" by progressively demonstrating logical arguments using these five points of knowledge from its knowledge base: These are expressed in the language CycL, which is based on predicate calculus and has a syntax similar to that of the Lisp programming language.

[0010] On July 18, 2019, the Wikipedia page about Cyc stated that the Cyc project has been described as "one of the most controversial efforts in the history of artificial intelligence"; Luminoso's CEO said Cyc was a predecessor project to IBM's Watson; machine learning scientists called the project a "catastrophic failure" for several reasons, including the endless amount of data required to produce any viable results and Cyc's inability to evolve on its own; George Mason Mason University economics professor offers a more balanced analysis: "Of course, the CYC project has been criticized for many of its specific choices. People have complained about its logic-like and language-like representations, its choice of archetypal cases to build (e.g., encyclopedia articles), its focus on answers rather than actions, the frequency of its rebuilding versus maintaining legacy systems, and its preference for private versus public access to everything. But any large project like this is going to generate such controversy, and none of its choices are obviously serious errors. They had to start somewhere, and in my opinion, they have now assembled a knowledge base that is truly astonishing in its size, scope, and integration. Other architectures might work better, but if knowing a lot of things is nearly as important as Lenat thinks, I would expect AI to seriously attempt to import CYC's knowledge and translate it into new representations. No other source comes close to the size, scope, and integration of CYC." True Knowledge systems use structured knowledge and inference to answer open-domain questions. In a True Knowledge system, the knowledge in the knowledge base is represented in a single unified format: specified relationships between specified pairs of entities called "facts." Facts and relationships are themselves first-class entities, so facts about facts and facts about properties of relationships are fully supported (Tunstall-Pedoe, W. (2010). True Knowledge: Open-Domain Question AnsweringUsing Structured Knowledge and Inference. AI Magazine, 31(3), 80-92. https: / / ojs.aaai.org / aimagazine / index.php / aimagazine / article / view / 2298).

[0011] EP2527990A2 and EP2527990B1 disclose a method for using a large language model in machine translation, in which the translation model is divided into multiple language model partitions stored on multiple different language model servers. Text segments are distributed to the servers for translation based on server workload. Language model information is typically collected by counting the frequency of word sequences in a large training corpus of documents. Summary of the Invention

[0012] According to a first aspect of the invention, there is provided a method of interacting with an LLM, comprising the steps of: a processing system using a structured machine-readable representation of data conforming to a machine-readable language such as a ubiquitous language to provide new context data to the LLM to improve output generated by the LLM in response to a prompt, such as continued text output.

[0013] According to a second aspect of the present invention, there is provided a method of interacting with an LLM, comprising the steps of providing continuation data generated by the LLM to a processing system, the processing system using a structured machine-readable representation of the data conforming to a machine-readable language such as a general-purpose language, wherein the processing system is configured to analyze continuation output (e.g., textual output) generated by the LLM in response to a prompt to enable an improved version of the continuation output to be provided to a user. Figure 10 An example is shown in . An advantage is that an improved continuation output of the output generated by the LLM may be provided.

[0014] According to a third aspect of the present invention, there is provided a method of interacting with an LLM, comprising the steps of: generating, by the LLM, continuation data using output from a processing system, the processing system using a structured machine-readable representation of data conforming to a machine-readable language, such as a general-purpose language, wherein the LLM is configured to use the output from the processing system as a prompt and generate a continuation output (e.g., textual output) that is an improved version of the output from the processing system. An advantage is that an improved version of the output from the processing system can be generated by the LLM.

[0015] According to a fourth aspect of the present invention, there is provided a method of interacting with an LLM, comprising the steps of: training the LLM based on output from a processing system using a structured machine-readable representation of data conforming to a machine-readable language such as a ubiquitous language. Advantageously, an improved LLM may be provided.

[0016] According to a fourth aspect of the present invention, there is provided a method for interacting with one or more users in natural language, comprising the following steps: Providing a structured representation of data and a system operable to process a language with reference to the structured representation of the data to provide additional useful text associated with the language; Provide an LLM that can be operated to provide a continuation of the text; receiving language input from one or more users; Processing language input with a system to produce additional useful text; Provide linguistic input and additional useful texts to the LLM; Language derived from the continuation generated by the LLM is provided to one or more users. An advantage is that additional useful text to text provided by a system operable to process language as a structured representation of reference data may be provided by the continuation generated by the LLM.

[0017] According to a sixth aspect of the present invention, there is provided a method for verifying natural language for factual accuracy, comprising the following steps: extracting from a natural language a set of one or more factual assertions asserted within the natural language; checking one or more factual assertions for factual accuracy; Import or make available the results of an inspection.

[0018] The advantage is validating natural language for factual accuracy.

[0019] According to a seventh aspect of the present invention, there is provided a method for learning structured knowledge, comprising the following steps: Provides LLMs trained on a large corpus of natural language documents; Provide LLMs with prompts that will elicit the desired knowledge; elicit a continuation of the prompt from the LLM; Translate continuations into structured form.

[0020] The advantage is learning knowledge in a structured form.

[0021] According to an eighth aspect of the present invention, there is provided a method for ensuring that LLM generates original text, comprising the following steps: Provide a database of previous text that should not be generated; Perform a beam search; Check potential continuations against the database; When a potential continuation matches non-original text in the database, the continuation is adjusted to no longer match the non-original text in the database.

[0022] The advantage is that it avoids copyright infringement.

[0023] According to a ninth aspect of the present invention, there is provided a method for avoiding hallucinations in LLM, comprising the following steps: Analyze different continuations for a given prompt; Comparing different continuations to identify parts of the response that did not change and parts of the response that did change; Identify the changing parts as more likely to be hallucinations; Portions identified as hallucinations are replaced or not shown to the user.

[0024] The advantage is to avoid illusions in LLM.

[0025] According to a tenth aspect of the present invention, there is provided a method for adding a reference to a text generated by an LLM, comprising the steps of: providing a database of texts for training the LLM, the database including sources associated with each chapter of the stored texts; Check the continued chapters generated by the LLM against the database; The search continues with sources that match the text contained in the database. The advantage is that citations are added to the text generated by the LLM.

[0026] According to an eleventh aspect of the present invention, there is provided a computer-implemented method comprising the following steps: (i) receiving an output from a natural language processing computer process, the output comprising an answer to the question; (ii) inputting the received output into the Large Language Model (LLM); (iii) A large language model (LLM) processes the input to the LLM to generate an output based on the input to the LLM.

[0027] (iv) Storing the output based on the input to the LLM.

[0028] The advantage is that improved answers to questions can be provided through the LLM output.

[0029] According to a twelfth aspect of the present invention, there is provided a computer-implemented method for training a large language model (LLM), comprising the following steps: (i) receiving an output from a natural language processing computer process, the output comprising an answer to the question; (ii) repeating step (i) at least one thousand times using a set of at least one thousand different questions, and storing the answers to the questions in a training file; (iii) Use the training file to train a large language model (LLM); (iv) Store the weights representing the trained LLM.

[0030] An advantage is that a trained LLM is provided that improves training by using training files. According to a thirteenth aspect of the present invention, there is provided a computer-implemented method for generating a training file for a large language model (LLM), comprising the following steps: (i) receiving an output from a natural language processing computer process, the output comprising an answer to the question; (ii) repeating step (i) at least one thousand times using a set of at least one thousand different questions, and storing the answers to the questions in a training file. Advantageously, an improved LLM training file is generated.

[0031] According to a fourteenth aspect of the present invention, there is provided a computer-implemented method of retraining a large language model (LLM), the LLM having been previously trained using a training file, the method comprising the steps of: (i) receiving an output from a natural language processing computer process, the output comprising an answer to the question; (ii) repeating step (i) at least one thousand times using a set of at least one thousand different questions, and storing the answers to the questions in a retraining file; (iii) combining the training file and the retraining file to generate a combined training file; (iv) Retraining the Large Language Model (LLM) using the combined training files; (v) Store the weights representing the retrained LLM.

[0032] The advantage is that an improved trained LLM is provided.

[0033] According to a fifteenth aspect of the present invention, there is provided a computer-implemented method of updating the training of a large language model (LLM), the LLM having been previously trained using a training file, the method comprising the steps of: (i) receiving an output from a natural language processing computer process, the output comprising an answer to the question; (ii) repeating step (i) at least one thousand times using a set of at least one thousand different questions, and storing the answers to the questions in a retraining file; (iii) Use the retraining file to update the training of the Large Language Model (LLM); (iv) Storing the weights representing the updated trained LLM. This has the advantage of providing an improved trained LLM.

[0034] According to a sixteenth aspect of the present invention, there is provided a computer-implemented method for improving output using LLM, comprising the following steps: (i) receiving a natural language question (e.g., any natural language to which a natural language response is suitable. It could be, for example, a command or a request for data or even some kind of social interaction or discussion); (ii) using a computer system comprising a processor and a memory, the processor being configured to use a processing language, wherein semantic nodes are represented in the processing language, the semantic nodes comprising semantic links between the semantic nodes, wherein the semantic links themselves are semantic nodes, wherein each semantic node labels a specific meaning, wherein a combination of semantic nodes defines a semantic node, wherein expressions in the processing language may be nested, wherein natural language questions are represented in the processing language, wherein reasoning steps are represented in the processing language to represent the semantics of the reasoning steps, wherein computational units are represented in the processing language, and wherein the memory is configured to store representations in the processing language; (iii) The processor answers the question using reasoning steps, computational units, and semantic nodes, and (iv) inputting the natural language question and the processor's answer to the question into the LLM; (v) a large language model (LLM) processes an input to the LLM to generate an output based on the input to the LLM; (vi) Store the output based on the input to the LLM. The advantage is that improved answers to questions can be provided through the LLM output.

[0035] According to a seventeenth aspect of the present invention, there is provided a computer-implemented method of improving the output from an LLM, comprising the steps of (i) receiving a first natural language question; (ii) inputting or providing the received first natural language question to a large language model (LLM); (iii) a large language model (LLM) processes the input to the LLM to generate an output based on the input to the LLM; (iv) translating the output into a processing language, wherein semantic nodes are represented in the processing language, the semantic nodes comprising semantic links between the semantic nodes, wherein the semantic links themselves are semantic nodes, wherein each semantic node labels a specific meaning, wherein a combination of semantic nodes defines a semantic node, which may be nested to form an expression in the processing language; (v) constructing a question asking whether the output is true, where the question is expressed in the processing language; (vi) inputting the problem into a computer system comprising a processor and a memory, the processor being configured to use a processing language, wherein the reasoning steps are represented in the processing language to represent the semantics of the reasoning steps, wherein the computational units are represented in the processing language, and wherein the memory is configured to store a representation of the language; (vii) the processor answers the question using reasoning steps, computational units, and semantic nodes, and (viii) The processor stores the answer to the question in a memory.

[0036] The advantage is that the LLM output is checked for accuracy.

[0037] According to an eighteenth aspect of the present invention, there is provided a computer-implemented method for fact-checking output from a large language model (LLM), comprising the following steps: (i) receiving text input; (ii) inputting or providing the received text input to a large language model (LLM); (iii) a large language model (LLM) processes the input to the LLM to generate an output based on the input to the LLM; (iv) translating the output into a processing language, wherein the semantic nodes are represented in the processing language, the semantic nodes include semantic links between the semantic nodes, wherein the semantic links themselves are semantic nodes, wherein each semantic node labels a specific meaning, wherein a combination of semantic nodes defines a semantic node, which may be nested to form an expression in the processing language, wherein translating the output includes extracting assertions from the text generated by the LLM; (v) constructing one or more questions asking whether the extracted assertions are respectively true, wherein the one or more questions are expressed in a processing language; (vi) inputting one or more questions into a computer system comprising a processor and a memory, the processor being configured to use a processing language, wherein the reasoning steps are expressed in the processing language to represent the semantics of the reasoning steps, wherein the computational unit is represented in a processing language, and wherein the memory is configured to store the representation in the storage language; (vii) a processor answers one or more questions using the reasoning steps, computational units, and semantic nodes, and (viii) The processor stores the individual responses to each of the one or more questions in a memory. The advantage is that the output from the large language model is fact-checked.

[0038] According to a nineteenth aspect of the present invention, there is provided a computer-implemented method of improving output from a computer system comprising a processor and a memory, the system being operable to process a natural language problem using a processing language, wherein semantic nodes are represented in the processing language, the method comprising using an LLM, the method comprising the steps of (i) receiving natural language questions; (ii) using a computer system comprising a processor and a memory, the system being operable to process a natural language problem using a processing language, wherein semantic nodes are represented in the processing language, the semantic nodes comprising semantic links between the semantic nodes, wherein the semantic links themselves are semantic nodes, wherein each semantic node labels a specific meaning, and wherein the memory is configured to store a representation in the processing language; (iii) the processor answers the question, and (iv) inputting the natural language question and the processor's answer to the question into the LLM; (v) a large language model (LLM) processes an input to the LLM to generate an output based on the input to the LLM; (vi) Store the output based on the input to the LLM.

[0039] An advantage is that using the LLM improves output from a computer system comprising a processor and a memory, the system being operable to process a natural language problem using a processing language, wherein semantic nodes are represented in the processing language.

[0040] According to a twentieth aspect of the present invention, there is provided a computer-implemented method of improving the output from an LLM, comprising the steps of (i) receiving a first natural language question; (ii) inputting the received first natural language question into a large language model (LLM); (iii) a large language model (LLM) processes the input to the LLM to generate an output based on the input to the LLM; (iv) translating the output into a processing language, wherein semantic nodes are represented in the processing language, the semantic nodes include semantic links between the semantic nodes, wherein the semantic links themselves are semantic nodes, and wherein each semantic node labels a specific meaning; (v) constructing a question asking whether the output is true, where the question is expressed in the processing language; (vi) inputting the problem into a computer system comprising a processor and a memory, the processor being configured to use a processing language, wherein the memory is configured to store to store a representation of a language; (vii) the processor answers the question, and (viii) The processor stores the answer to the question in memory. The advantage is that the LLM output is checked for accuracy.

[0041] According to a 21st aspect of the present invention, there is provided a computer-implemented method for fact-checking output from a large language model (LLM), comprising the following steps: (i) receiving text input; (ii) inputting the received text input into the Large Language Model (LLM); (iii) a large language model (LLM) processes the input to the LLM to generate an output based on the input to the LLM; (iv) translating the output into a processing language, wherein the semantic nodes are represented in the processing language, the semantic nodes include semantic links between the semantic nodes, wherein the semantic links themselves are semantic nodes, wherein each semantic node labels a specific meaning, wherein translating the output includes extracting assertions from the text generated by the LLM; (v) constructing one or more questions asking whether the extracted assertions are respectively true, wherein the one or more questions are expressed in a processing language; (vi) inputting one or more questions into a computer system comprising a processor and a memory, the processor being configured to use the processing language, wherein the memory is configured to store a representation of the language; (vii) the processor answers one or more questions, and (viii) The processor stores the individual responses to each of the one or more questions in a memory.

[0042] The advantage is fact-checking the output from large language models.

[0043] According to a 22nd aspect of the present invention, there is provided a computer-implemented method for expanding search results, comprising the steps of: (i) receiving search queries; (ii) a (e.g., Internet) search engine processes the search query to generate (e.g., Internet) search results; (iii) transforming the search results into a structured machine-readable representation of the data conforming to a machine-readable language such as a ubiquitous language; (iv) processing the transformed search results using a processing system using a structured machine-readable representation of the data conforming to said machine-readable language, such as a universal language, to produce an output; (v) The output of step (iv) is supplied as input to a large language model (LLM), and the LLM generates a continuation data output in response to the input. The advantage is that the search results found by the search engine are expanded.

[0044] According to a 23rd aspect of the present invention, there is provided a method for fact-checking output from a large language model (LLM), comprising the steps of: providing continuation data generated by the LLM to a processing system, the processing system using a structured machine-readable representation of the data conforming to a machine-readable language, wherein the processing system analyzes the continuation output generated by the LLM in response to a prompt so that an improved fact-checked version of the continuation output can be generated and provided to a user. The advantage is that the output from the large language model can be fact-checked.

[0045] Further aspects of the invention are given in the dependent and independent claims.Aspects of the invention may be combined with each other, with any of the concepts described herein, or with any of the claims. BRIEF DESCRIPTION OF THE DRAWINGS

[0046] Aspects of the present invention will now be described by way of example(s) with reference to the following drawings, in which: Figure 1 Example screen output for a notification of a job match is shown.

[0047] Figure 2 An example screen output is shown for a description of a job match.

[0048] Figure 3 An example conversation within the app is shown where nutritional data is being communicated with the app.

[0049] Figure 4 Some example insights that can be derived from a time period showing horizontal health and nutrition data are shown.

[0050] Figure 5 An example graph is shown showing daily calories in versus calories out, which is a very common thing for some people to track if the user is aiming to lose (or gain) weight.

[0051] Figure 6 An example of a visualization that can be generated from an example of the present invention is shown: it is comparing the estimated caffeine in a user's body when they go to bed with a calculation of sleep quality.

[0052] Figure 7 Examples of generated explanations are shown: (a) shows an example of a simplified explanation; (b) shows an example of a detailed explanation.

[0053] Figure 8 An example of a voice assistant product, referred to herein as “Brian,” is shown, and how it fits into the broader UL platform and other applications built on the UL platform.

[0054] Figure 9 Shown Figure 8 Alternatives to the example.

[0055] Figure 10An example of a method of interacting with an LLM is shown, the method including the steps of providing continuation data generated by the LLM to a processing system using a structured machine-readable representation of the data conforming to a machine-readable language (such as a universal language), wherein the processing system is configured to analyze continuation output (e.g., textual output) generated by the LLM in response to a prompt to enable an improved version of the continuation output to be provided to a user.

[0056] Figure 11 An example of an intermediate representation semantic graph is shown. DETAILED DESCRIPTION

[0057] The present disclosure includes a computer-implemented method for automatically analyzing or using data, the method comprising the steps of: (a) storing in memory a structured machine-readable representation of data in a machine-readable language ("machine representation"); the machine representation includes: a representation of user speech or text input to a human-machine interface; (b) Automatically process machine representations to analyze user speech or text input.

[0058] The present disclosure includes a computer-based system configured to analyze data, wherein the system is configured to: (a) storing in a memory a structured machine-readable representation of data in a machine-readable language; the structured machine-readable representation of data includes: a representation of user speech or text input to a human-computer interface; (b) Automatically process the structured representation to analyze user speech or text input to a human-computer interface.

[0059] These aspects of the present disclosure can be implemented in a voice assistant or chatbot; the technical advantage achieved is the ability to expand the capabilities of the voice assistant or chatbot more widely and quickly; the present invention enables voice assistants and chatbots to answer a wider range of questions and to answer them more accurately; this makes it easier for voice assistants or chatbots to work with a large number of different natural languages.

[0060] A point of explanation: The conjunction "or" should not be interpreted narrowly to indicate mutual exclusivity, but rather to include inclusion. Thus, the phrase "user speech or text input" means "user speech alone, or user text alone, or both user speech and user text." When the conjunction "or" indicates exclusivity, use the phrase "either ... or."

[0061] Machine-readable languages ​​are very expressive, yet also very simple; simplicity requires less computer processing and therefore delivers faster performance. Additional details are in the accompanying concepts and claims. According to another aspect of the present disclosure, a computer system is provided, comprising a processor and a memory, the processor being configured to answer a question, the processor being configured to use a processing language, wherein semantic nodes are represented in the processing language, the semantic nodes comprising semantic links between the semantic nodes, wherein the semantic links themselves are semantic nodes, wherein each semantic node marks a specific meaning, wherein a combination of semantic nodes defines a semantic node, which can be nested to form an expression in the processing language, wherein the question is represented in the processing language, wherein the reasoning steps are represented in the processing language to represent the semantics of the reasoning steps, wherein the computational units are represented in the processing language, wherein the memory is configured to store the representation in the processing language, and wherein the processor is configured to answer the question using the reasoning steps, the computational units, and the semantic nodes, and store the answer to the question in the memory.

[0062] One advantage is that because the semantic links between semantic nodes are themselves semantic nodes, the semantic links and the semantic nodes do not need to be processed in significantly different ways, which simplifies processing, which speeds up response time, which is a technical effect.

[0063] One advantage is that because semantic nodes are used very extensively in the processing language, processing of the processing language is accelerated, which speeds up response time, which is a technical effect.

[0064] Technical effects operate at the architectural level of computer systems; that is, the effect occurs regardless of the data being processed. The technical effect causes the computer system to operate in a new way, since the computer finds answers to questions faster than using prior art methods, since semantic nodes are used very extensively in the processing language, which means that the processing of the processing language is accelerated.

[0065] The processing language contributes to the technical feature because it produces a technical effect: a processor processing the processing language has the effect that the computer finds an answer to a question faster than using prior art methods because semantic nodes are very extensively used in the processing language, which means that the processing of the processing language is accelerated.

[0066] The computer system may be configured to output an answer to the question.

[0067] The computer system may be configured to output responses to the questions to a display device.

[0068] The computer system may be one in which expressions in a processing language may be nested without restrictions inherent to the processing language. The computer system may be one wherein the semantic nodes each include a unique identifier.

[0069] The computer system may be one in which the computing units are semantic nodes.

[0070] The computer system may be one in which a question is represented in a processing language by: a paragraph including a semantic node identifying the paragraph as a question; a list of zero, one, or more semantic nodes representing unknown entities being asked; and at least one further paragraph representing the semantics of the question in the context of the zero, one, or more unknown entities.

[0071] The computer system may be one in which the processing language is a general-purpose language.

[0072] A computer system may be one in which the processing language is not a natural language.

[0073] The computer system may be one in which the problem involves searching and analyzing documents or web pages, wherein the semantic nodes comprise representations of at least portions of the documents or web pages stored in a document store.

[0074] The computer system may be one in which the problem involves location-based searching using map data represented as semantic nodes in a processing language.

[0075] The computer system may be one in which the question involves a search for defined advertisements or news, wherein the semantic nodes include representations of advertisements, news articles, or other items of information.

[0076] The computer system may be one in which the question involves a request for a summary of a news topic, wherein the semantic node includes representations of news from multiple sources, for example to provide a summary or aggregation of the news.

[0077] The computer system may be one in which the question involves a request for compatibility matching between persons, wherein for a plurality of persons, the semantic nodes include representations of personal information defining one or more attributes of the persons.

[0078] The computer system may be one wherein the problem relates to compliance with requirements to prevent abusive or illegal social media postings, wherein the semantic nodes comprise representations of social media postings.

[0079] The computer system may be one wherein the problem relates to analyzing customer reviews, wherein the semantic nodes comprise representations of the customer reviews.

[0080] The computer system may be one wherein the question relates to a user's product request, wherein the semantic node comprises a product description and a representation of the user's product request.

[0081] The computer system may be one in which the problem relates to a job search, in which the semantic nodes include job descriptions and representations of job applicants' skills and experience, to determine which job applicants match the job descriptions, or to determine which job descriptions match the job applicants' skills and experience.

[0082] The computer system may be one in which the question relates to the health of an individual, and in which the semantic node includes health data related to the individual and health data related to humans. The computer system may be one wherein the question relates to nutrition and wherein the semantic nodes include nutritional data for food and beverages. The computer system may be one in which the question relates to accounting or finance, and in which the semantic node comprises a representation of financial or accounting information. The computer system may be one in which the question is received by a voice assistant or chatbot, and in which the semantic node includes a representation of a user's speech input to a human-machine interface and includes a representation of the human-machine interface itself.

[0083] According to a further aspect of the present disclosure, there is provided a computer-implemented method, the method using a computer system comprising a processor and a memory, the processor being configured to use a processing language, wherein semantic nodes are represented in the processing language, the semantic nodes comprising semantic links between the semantic nodes, wherein the semantic links themselves are semantic nodes, wherein each semantic node marks a specific meaning, wherein a combination of semantic nodes defines a semantic node, wherein expressions in the processing language may be nested, wherein a question is represented in the processing language, wherein an inference step is represented in the processing language to represent the semantics of the inference step, wherein a computational unit is represented in the processing language, wherein the memory is configured to store representations in the processing language, the method comprising the steps of: (i) The processor answers the question using reasoning steps, computational units, and semantic nodes, and (ii) The processor stores the answer to the question in memory.

[0084] Advantages include those of the previous aspects of the present disclosure.

[0085] The method can be one in which the question is represented in a processing language by: a paragraph including a semantic node that identifies the paragraph as a question; a list of zero, one, or more semantic nodes representing unknown entities being asked; and at least one further paragraph representing the semantics of the question in the context of the zero, one, or more unknown entities.

[0086] The method may be one in which unknowns in a problem are identified and paragraphs forming the body of the problem are selected for further analysis; processing begins with a list of paragraphs from the body of the problem and the selected unknowns; the first paragraph in the list of paragraphs is selected for processing; and processing a single paragraph includes three methods: using a statically stored processing language paragraph, utilizing a computational unit, and utilizing a processing language generated from inference: The first method is to check if there is any paragraph in the paragraph store that can be directly mapped to the paragraph being processed; if the paragraph has the exact same structure as the paragraph in the paragraph store, all nodes except the unknown item match, then the value matched by the unknown item is a valid result; The second method is to check whether any results can be found by executing the computation unit; check whether the paragraph matches any paragraph in the computation unit description; all non-unknown nodes in the paragraph being processed must match the same nodes in corresponding positions in the computation description or align with the computation input unknowns; the unknowns being processed must align with the output unknowns in the description; then call the computation unit to obtain valid output values ​​for the unknowns of the processed paragraph; A third approach is to see if the passage can be proved by applying any reasoning steps; the reasoning steps are searched to find where the passages in the second half of the reasoning passage can be unified with the passage being processed; all nodes and structures must be equal between the two passages, except for the unknowns in either the focus passage or the reasoning passage; if such a reasoning passage is found, it means that the reasoning step can prove that the passage is being processed; when matching with the reasoning passage, a multi-stage process is used to first find any mappings for the unknowns in the processed passage; second, a mapping for the unknowns used in the reasoning passage is found by mapping with the passage being processed; this mapping can then be applied to the first half of the reasoning passage to generate a list of passages, and if these list of passages can be matched with the known or generated processing language and the mappings found for them, a valid mapping for the focus passage will be proved and found; a solution to the list of passages can then be found recursively.

[0087] The method may use the computer system of any of the previous aspects of the disclosure.

[0088] Aspects of the disclosure may be combined.

[0089] Examples of the present invention include systems and methods for creating and using structured representations of data that are intended to be as expressive as natural language in terms of breadth, yet can also be processed and understood by automated systems. A representation referred to herein as UL (Universal Language) is a preferred example. Examples of the present invention include systems and methods related to specific HUBs and other applications, as well as systems and methods for processing, storing, and utilizing UL.

[0090] A natural language question can be any natural language that a natural language response is suitable for. It can be, for example, a command or a request for data or even some kind of social interaction or discussion.

[0091] Beyond the delivery of HUB applications, using ULs offers other advantages. For example, ULs can serve as a way for automated systems to understand the world and reason. Because the reasoning steps are documented in language, such systems can also fully explain themselves to human users in language. Requirements for software systems can be written in ULs (referred to herein as "tenets"), and examples of the present invention can directly use these tenets to determine their actions, rather than relying on human programmers to attempt to predict all possible scenarios and pre-code them in program code to determine their detailed actions. In some examples, tenets can be divided into "motivational principles," which express goals or desired behaviors that the system will strive to achieve, or hypothetical propositions about the world, such as "keep users happy," and "prohibitional principles," which express things that the system should not do or must avoid, or things that the system should try to prevent from happening (such as "do not take actions that could harm humans").

[0092] Language representation: UL One goal of UL is to be able to represent, in principle, anything expressible in any natural language. Another goal is that anything expressed in a natural language can be translated into UL. UL is intended to be usable by machines, so this data representation must be fully processable and understandable by automated systems. While a goal, examples of the present invention may not fully achieve these goals while still offering significant advantages over the prior art.

[0093] Natural language has many distinct characteristics that make it extremely difficult for computers to understand and process it. These include polysemy—the fact that words in natural language often have many meanings or senses, some related and overlapping, and some completely different, requiring context, years of natural language experience, and common sense knowledge for humans to understand which meaning is intended. For example, the English word "pen" can mean a writing implement, a fence for farm animals, a female swan, or a prison (short for "penitentiary"), among other meanings. As a verb, it also has many related and distinct meanings. Despite this complexity, humans can naturally infer a word's intended meaning using context, real-world experience, and common sense knowledge, but this is extremely difficult for machines that lack the necessary skills.

[0094] The ambiguity and flexibility of word ordering is another issue that makes natural language processing extremely difficult for machines. Even simple sentences can be phrased in literally dozens of ways that convey the same meaning. Humans naturally understand this multitude of wordings, but it's not easy for algorithms to represent. Clauses and words within sentences modify and attach to other parts of the sentence, changing their meaning in ways that humans naturally understand but don't follow clear rules that machines can. Natural languages ​​also use techniques like anaphora to refer to entities referenced in earlier utterances and avoid stating them again (for example, the use of pronouns and words like "he," "she," "it," and "the" in English). Humans naturally understand what is being referred to, but this is not as obvious to machines. Ambiguity can even arise where there are boundaries within compound nouns—for example, the use of the compound noun "fruit flies" in the sentence "Fruit flies like a banana" compared to "Time flies like a narrow arrow."

[0095] UL was designed to overcome all of these problems and create a language that can be unambiguously parsed, understood, and processed by machines, and which can therefore store an extremely wide range of information in a way that machines can understand, process, and interpret.

[0096] A contrasting approach is to process natural language directly and build very large statistical machine learning models, such as large language models (LLMs). LLMs are typically very large, with hundreds of billions of parameters or more, and run on specialized hardware. They are very expensive to train and run and require large amounts of data. They are also statistical, only work a certain percentage of the time, and have unpredictable and uninterpretable results. Some of the methods described here bring language processing into a world where computers can handle it without such techniques. The examples described here are non-statistical—always correct if the underlying language is correct; they run on inexpensive hardware (e.g., a standard CPU) and involve very little cost in their use. Additionally, unlike LLMs, languages ​​written in LLMs can be memorized immediately and perfectly by storing them in a database (a form of one-time learning), whereas LLMs only learn over time during an expensive training process and their memory of their source data is typically imperfect.

[0097] Semantic Node A key component of the UL is what we call a semantic node in this article. A semantic node is intended to be the broadest imaginable definition of a "thing" that can be defined - anything that has a word, and anything that doesn't have a natural language name, can have a semantic node in the UL.

[0098] In various examples, semantic nodes can include every specific human, the concept of human (of which any specific human is a member), every file, every web page, every audio recording or video, specific relationships (including relationships linking any specific human to the concept of human), attributes, specific types of linguistic nuances, and every row and item in a relational database table.

[0099] Once defined, semantic nodes have identifiers so that they can be referenced in the UL. In the preferred example, the ID is a 128-bit version 4 UUID (RFC 4122) with a hyphenated lowercase syntax. For example: b1c1cb5f-248f-4871-a73f-900d29066948. The preferred example also allows Unicode strings in double quotes to be their own IDs - the string itself is the ID of the semantic node for that specific string. For example, "Piña colada" is a valid semantic node that only represents a string, not the concept of a beverage. In other examples, UUIDs or other identifiers can be used for strings to further simplify the syntax, but additional language is required to express the link between the identifier and the string it represents.

[0100] In the example, a simple grammar for UL is thus: <passage>::=<128 bit UUID> <passage>::="<Unicode string>” <passage> ::=（ <passage> <passage>*) in <passage>* for zero or more further <passage>, and double quotes inside a Unicode string are escaped \" In the examples, a semantic node can be represented by a 128-bit UUID or a string; a paragraph can be (a) a semantic node or (b) two or more other paragraphs in parentheses.

[0101] In another example, the minimum number of paragraphs that can be grouped within brackets is two, so the third line of the above grammar would be <passage> :=（ <passage> <passage> <passage>*) In the preferred example, a given semantic node typically marks a specific thing or a specific meaning. Although polysemy is allowed in the preferred example, with an essentially infinite pool of available UUIDs, there is no reason to overload nodes with more than one meaning, and in practice, all possible meanings of a word in a natural language will be assigned to different semantic nodes. Closely related meanings of a word can also be assigned to different semantic nodes, with paragraphs describing the relationship between them. This use of a unique semantic node for each possible meaning overcomes the complexity and ambiguity of determining meaning in natural language.

[0102] The use of semantic nodes also avoids any ambiguity that comes from labeling concepts with multiple words in natural language. In the preferred example, compound nouns, verb phrases, prepositional verbs, etc. are generally absent - each such concept has a single node, and the machine has no challenge in deciding where the boundaries of the representation lie.

[0103] Node Protocol We use the term "user" herein to refer to any human, organization, or machine user of examples of the present invention. A user can be any computer system using examples of the present invention or any human or organization using a UL. It can also be a subsystem of a larger computer system. In a preferred example, if two semantic node identifiers are different, they may or may not represent the same concept—as two different users of the present invention may have chosen two different IDs for the same thing. If two identifiers are the same, then, in a preferred example, by design, they must mark the same thing, defined in the same way. Therefore, when agreements are reached on semantic nodes and adopted across different systems, the UL becomes useful for communication. When there is sufficient understanding of the semantic nodes to be able to express them in natural language and generate natural language with similar meanings to the UL, the UL can become understandable to human users.

[0104] In a preferred example, the meaning of a semantic node derives solely from other ULs that represent things already said about that node. Sometimes, this can represent knowledge expressed by the UL that a semantic node corresponds precisely to a word or word meaning in a given natural language. For example, the Spanish drink Sangria might be represented as a6ba9f28-b54d-4e4a-8cf8-ad4e07659004. A pen, in the sense of a writing utensil, might be represented as c092849c-80ed-4a69-9a4e-2704780f0cea, but the concept of a pen in the sense of a fence for farm animals would have an entirely different node, such as ba9b43a3-540d-44ff-b6fe-62dcfb9dda1c. While these meanings may be documented somewhere for human users, the UL's paragraphs define these concepts and semantically link them to other concepts that give them meaning. For example, in the case of the concept of sangria, the paragraph could assert that it is a drink, that it is alcoholic, and that it originated in Spain. The paragraph could further define the ingredients or other information relevant to the machine understanding what it is.

[0105] As used herein, a "shared ID" is an ID used by more than one user in various examples of the present invention. Typically, one user has created and used an ID, and a second or more users have decided that this ID represents a concept they would also like to use, and then begin using it as well. A "private ID" or "local ID" is similarly an ID used by only one user and is not published or exposed to other users. A "public ID" is an ID that is visible to everyone who has used it in the UL, and whether it is shared depends on whether other client entities have begun using it. According to various examples, an ID can be shared between multiple users without being fully public.

[0106] Stated another way, any user of an example of the present invention can create their own semantic nodes with their own local meaning by selecting unused identifiers. For example, an application can assign semantic IDs to rows in a specific local database table. Any number of different IDs can represent the same thing. However, when semantic nodes are shared, their meaning is shared. If another user subsequently uses these IDs elsewhere, they will mean the same thing and label the same thing. In a preferred example with a 128-bit address space, randomly selecting IDs from this space has an essentially zero probability of conflict unless intentional, allowing local IDs to be created and used without any registration process or communication or coordination with any other users. In another example, string identifiers can be used, and users can include a unique substring in their own local identifiers, such as using it as a prefix. For example, an organization could choose a unique prefix, such as "unlikelyai719," and then name all of its nodes starting with this prefix, such as "unlikelyai781_Sangria." This unique prefix ensures that its local IDs are not duplicated by any other user. Other examples may use a smaller address space and have a more centralized approach, potentially including registration.

[0107] String As mentioned above, in the preferred example, Unicode strings also represent semantic nodes. Their meaning is strictly the string itself. Any natural language meaning contained in the string is not part of the meaning of these IDs. That is, "sangria" strictly means the letter sequence s..a..n..g..r..i..a—not the concept of a beverage. Following the principles of the node protocol discussed above, it is also possible for strings to be represented by IDs as additional identifiers. For example, the string "sangria" could be additionally represented as fc570fba-cb95-4214-bc45-8deb52d830a5, and this could be represented in a paragraph or elsewhere. This can be used for very large strings. Following the same design principles, two identical strings used as semantic nodes have a common meaning for that string.

[0108] Combined Node Composite semantic nodes also define semantic nodes. Sharing rules around the meaning of the shared nodes or shared classes to which the nodes belong define further shared meaning brought about by said combination. For example, a semantic node within an infinite class may be represented by combining one or more nodes defining that class with one or more strings, where there is an internationally recognized representation in string form, as, for example, integers may be defined like this. (<id of integer>"5") Another example of a composite node with more than two nodes within it is (<id of group><id of Chicago><id of New York City><id of London>), which is a single semantic node representing the set of three cities treated as a single entity. Composite nodes may contain any finite number of semantic nodes, and semantic nodes within these composite nodes may also be composite nodes creating arbitrary levels of nesting.

[0109] Nesting The UL syntax allows for unlimited nesting of expressions. This allows users to define concepts, along with contextual information about them, as a hierarchy of UL expressions under the same parent UL expression or with the same central expression or paragraph. Context can be used to provide nuance, source, belief, temporal validity, and more. For example, starting with a paragraph (HoldsOfficeXXUsPresident) (where HoldsOfficeXX and UsPresident are human-readable "nicknames" for IDs—described further below), another paragraph stating when it is true could be (HasTemporalValidity(HoldsOfficeXXUsPresident)(DateIsoFormat"2021-07-23"))—this states that XX was inaugurated as President of the United States on July 23, 2021. Further expressions surrounding this paragraph can assert that the statement comes from a specific source or has a certain degree of reliability, etc.

[0110] Combination Protocol In a manner similar to the principle of node agreement, where the use of the same semantic node by the same or different entities implies the same meaning across uses, the meaning conveyed by combining shared semantic nodes is also universal. Any client entity that chooses to create a paragraph using shared semantic nodes is also expressing the same meaning by combining them. Similarly, any client entity is free to define its own meaning for combinations of semantic nodes that are not used elsewhere.

[0111] In other words, further meaning is what comes from combining semantic nodes. Likewise, if semantic nodes are shared, the meaning that comes from combining them is also shared. In the preferred example, semantic nodes can be combined in any number and at any level of nesting, and no further syntax is required. Other examples may include additional syntax. The combining and nesting herein and in the preferred example is done with parentheses when displaying the UL. However, various examples and implementations of the examples may represent the combination of nodes in other ways. For example, the syntax may group nodes with characters other than parentheses, there may be special function words in the syntax, such as "query", which are not semantic nodes but define different types of paragraphs, or there may be special syntax for specific types of nodes, such as unknown values ​​or boolean values ​​or integers. In the preferred example, grouping in the UL is expressed directly using brackets. Without brackets, there's no ambiguity about how nodes are grouped, or any assumed groupings. This syntax thus avoids the ambiguities that are all too common in natural language, where clauses and words group and modify other parts of the sentence in ways that are extremely difficult for machines to determine. For example, in the English sentence "The police arrested the demonstrators because they feared violence," it's unclear whether "they feared violence" applies to the demonstrators or the police. Natural language doesn't have a strict grouping syntax, which means this type of ambiguity is common. Humans, with extensive experience of the world, can infer from common sense and their knowledge of the world that the police are more likely to apply in this case. The unambiguous grouping in the UL ensures that machines can always get it right. UL syntax A UL expression is either a semantic node or a paragraph. Both variants are atomic, complete, valid UL fragments. Semantic nodes are fully defined above and consist of either UUIDs or Unicode strings. A paragraph is any combination of nodes and is a unique nested structure of the UL. A paragraph can be anything from a single semantic node to a complex hierarchical structure representing an entire book.

[0112] Thus, in a preferred example, a simpler more formal grammar for the UL could be: universal_language = ul_element* | EOF ul_element = semantic_node | passage semantic_node = version_4_uuid | string_literal passage = '(' ul_element+ ')' The above grammar uses the symbols ( and ) to mark groupings and omits implementation-specific details such as character escaping within string_literal nodes.

[0113] Various examples of the present invention may extend or modify the above grammar to suit their needs. Possible extensions include additional syntax for specific types of nodes: for example, integers, real numbers, time points, and unknown items. Other possible extensions include comments and "designated paragraphs" that are ignored by any UL parser. Designated paragraphs can represent a way to link paragraphs to nicknames in a human-readable language (such as English). Nicknames are further described in the following sections.

[0114] Note that the preferred example uses this extremely simple syntax with no extensions and no special additional syntax for different types of paragraphs - the meaning comes purely from the choice of semantic nodes and how they are grouped, both in terms of grouping and ordering. Being able to express anything with such a simple representation has significant advantages over the alternative of using more complex syntax or using special additional syntax for specific things. These advantages include simplicity and versatility of implementation, which can lead to significant speed improvements when processing the language. This also greatly simplifies the storage and retrieval of the UL and the ability to process it. With more complex syntax, different code would need to handle each of the different types of syntax. The storage would also be very complex. More complex storage also increases the complexity of the code that needs to access it and the speed at which it can be accessed.

[0115] Nick name To make the UL more understandable to humans, various examples have a "nickname" scheme where shorter natural language labels are associated with the UL expression, and these names are used when presenting the UL to humans. These labels can be used as substitutes for the original UUID when presenting the UL to humans. In the preferred example, any number of nickname schemes can be defined so that users familiar with different natural languages ​​can access the meaning in the UL. The example nickname scheme used in this article is called English1. In some examples (but not the preferred examples), these nicknames can be used as identifiers. In the preferred example, these nicknames are not identifiers, but merely a way of presenting identifiers to humans.

[0116] As an example of UL representation, this is a valid paragraph: (03d206a2-52ca-49e1-9aeb-86364e2dead6 cb75d6f8-16d9-4a36-8c16-7195182d4057 (d1fd5662-c88e-4d94-b807-5310483df8cd (30847a3d-e43c-4229-993e-20ad01adc126 5a533842-bcd8-4125-8b39-2b1caa643593))) The meaning of this paragraph corresponds to the English sentence "Brie is a creamy, French cheese".

[0117] Assign these nicknames to the semantic nodes within the paragraph as follows: ISA=03d206a2-52ca-49e1-9aeb-86364e2dead6 Brie = cb75d6f8-16d9-4a36-8c16-7195182d4057 Cheese = d1fd5662-c88e-4d94-b807-5310483df8cd Creamy = 30847a3d-e43c-4229-993e-20ad01adc126 French = 5a533842-bcd8-4125-8b39-2b1caa643593 Meaning that the above paragraph can be displayed in a more human-readable form, thus: (IsA Brie (Cheese (Creamy French))) Cream and cheese are semantic nodes, which are properties or attributes of other semantic nodes. This concept (given the nickname attribute) is a semantic node that corresponds to a class of such nodes and is shared. The shared meaning in the preferred example is that two or more attributes are combined to form a new attribute, where all the constituent attributes apply. Thus, (Creamy French) itself is the attribute meaning in the English "creamy and French".

[0118] Cheese is a class of things that are cheeses. Another shared meaning from classes and properties is that combining a class with a property gives the class of all things in that class that have that property, so (Cheese (Creamy French)) is the class of all creamy, French cheeses—"creamy, French cheese" in English.

[0119] IsA is a semantic node that has a shared meaning by combining a semantic node with a class, which means that the node is a member of the class, so (IsA Brie (Cheese (Creamy French))) can be translated into English as "Brie is a creamy, French cheese".

[0120] Likewise, in the preferred example, the choice of the English1 nickname is helped by choosing a name corresponding to the English language that is close to the meaning of the node. However, the meaning of a node comes only from its use in the system.

[0121] negative To say that something is not true, the combination of the semantic node Not with another relation node defines a relation node that is true whenever the original relation is false.

[0122] For example ((Not IsA) Bat Bird) It is a true statement.

[0123] question Questions can be represented in the UL by combining a node that identifies a paragraph as a question with a list of zero or more unknowns with one or more further paragraphs that use the semantics of representing questions with zero or more unknowns. In a preferred example, the paragraphs of the UL have ((Question <unknowns> )( <passage>)) in the form of, where Question is a semantic node, and <unknowns>is a list of zero, one, or more semantic nodes representing unknown values ​​(similar in meaning to the letters of an alphabet in algebra), and where <passage>This is where unknowns are used to express what's being asked. In the preferred example, these unknowns are simply semantic nodes, members of the Unknowns class—they have no special status other than their meaning. Here we use Unknown1, Unknown2, X, and so on as nicknames for members of this class. Note that questions in the preferred example are UL paragraphs like any other: the syntax of the UL is not extended or altered in any way to support questions.

[0124] For example ((Question Unknown1)((HasAttribute Unknown1 Alcoholic) (IsA Unknown1Drink))) Translated into English, it means "What drinks are alcoholic?" or "List alcoholic drinks."

[0125] Yes / No questions have zero unknowns, so both ((Question)((IsA Sangria Drink)(HasAttribute Sangria Spanish))) ((Question)((IsA Sangria (Drink Spanish)))) Translated to "Is Sangria a Spanish drink?" Another example is: ((Question) (WithinRange (Integer "7") (AtLeast (Integer "5")))) This asks "Is 7 within the range 'at least 5'?" The question paragraph consists of a header paragraph (in this case, just (Question)) and a footer of the other paragraphs (in this case, just (WithinRange (Integer "7") (AtLeast (Integer "5"))). The first element of the header will always be the question node, followed by any number of unknowns. If it's not a simple yes or no question, the unknowns can be used to represent the output of the question. Here, you only need to specify the unknowns to use for the output. Unknowns are simply semantic nodes in the Unknown class.

[0126] An example problem using unknowns (mapped to outputs) is: ((Question Unknown1) (IsA Unknown1 (Cheese Creamy))) This is asking "What are the creamy cheeses?" / "List creamy cheeses?". The unknown Unknown1 is used in the question, and any node that can be correctly mapped to Unknown1 from other things represented in the UL is returned as appropriate output for the question. Examples of UL questions that would receive a No answer are: ((Question) (HasAttribute Cheddar Creamy)) This is asking "Is cheddar creamy?" In the example where A. cheddar is a hard cheese and B. hard cheese is not creamy, the system can prove that cheddar is not creamy and will return a "no" result.

[0127] reasoning Inferences are the process of generating a UL from other ULs. An inference paragraph is a section of a UL that describes how a new UL is generated from other ULs—for example, by logical consequences or by assigning meaning to other nodes or combinations of nodes. For example, the English sentence "if something originates from France, then it is French" translates to an inference paragraph in the UL.

[0128] Reasoning steps are represented as paragraphs that express the semantics of the step. Note that in the preferred example, reasoning paragraphs are represented in the UL like anything else. There is no special syntax or content that is extended or changed to support reasoning. For example: (ConsequenceOf (IsA X (Cheese Hard)) ((Not HasAttribute) X Creamy)) This says, "If X is a hard cheese, then X is not creamy." In the preferred example, these reasoning steps begin with a ConsequenceOf semantic node. This is followed by a paragraph expressing the condition that must hold for this step to work (the "if" paragraph). This can be just one paragraph, as in the example, or it can be a paragraph containing other paragraphs that must all hold. The third element is a paragraph that is true if the condition is met (the "then" paragraph). This can also be one paragraph among many, in which case all of the contained paragraphs will be true if the condition is met.

[0129] More examples of reasoning steps: (ConsequenceOf (IsIn XY) (IsA Y GeographicalArea)) means "If X is in Y then Y is a location" (IsIn indicates geographic location). (ConsequenceOf (IsA X Continent) ((IsIn X Earth)) means "If X is a continent then X is in Earth" in English. Computing Unit Computational units are how examples of this invention represent and use the computations needed for reasoning and other purposes. This technology can be used to support any automated process that computes something or returns a result. Examples also allow them to support actions such as completing a transaction, turning on a light, playing music, and so on. As a simple example, a computation unit could allow the UL to answer questions such as "Is 7 greater than 5?", according to various examples. Clearly, having to explicitly enter a paragraph for every combination of two integers is impractical. In a preferred example, a computation unit can be considered a semantic node, an instance of the ComputationUnit class. We can then add a paragraph that describes the details of the unit needed to select and run it: what it does, how to run it, and how to interpret the results.

[0130] For example, here is a sample computation cell for addition: (ComputationLocalJavaLocation AdditionComputationUnit "ai.unlikely.questionprocessor.computation.Arithmetic$Addition") (ComputationInputs AdditionComputationUnit InputOne InputTwo) (ComputationDescription AdditionComputationUnit ((Question Unknown1)((Equal (RealNumber Unknown1) (Add (RealNumber InputOne) (RealNumberInputTwo)))))) (ComputationDescription AdditionComputationUnit ((Question Unknown1)((Equal (Add (RealNumber InputOne) (RealNumber InputTwo)) (RealNumberUnknown1))))) In this case, there are two paragraphs describing the computational units. The description paragraph has a header node, ComputationDescription, followed by a node for the unit they describe, and then a paragraph describing the class of the UL question they help answer. We also have a paragraph describing the computational unit's inputs; in this case, we're describing the function that computes addition and requires two inputs. The description paragraph uses these inputs to describe where they appear in the question. The final paragraph we need for the computational unit to work is the one that provides the location. In this case, we use ComputationLocalJavaLocation at the beginning of the paragraph, indicating that we are describing the Java class that is locally available to the question processor at runtime. With all this information, the system can recognize when a computation is needed and find the best way to obtain and compute the answer. The preferred examples represent multiple ways to invoke the computational unit. Each method can be described using a paragraph similar to this one, but with a new header node and a different way to describe the location and how to invoke the computation. For example, if we were to add a computation engine that uses Lua scripts, we could add a paragraph like the following: (ComputationLuaScript AdditionComputationUnit "a,b = io.read('*n','*n')\nio.write(a + b)") to help the engine calculate units in this way. Another example is to use an API endpoint and specify a URL that will return results via a GET request.

[0131] Additional examples of compute units are described here to further illustrate the concept: (IsA GreaterThanOrEqualComputationUnit ComputationUnit) (ComputationLocalJavaLocation GreaterThanOrEqualComputationUnit "ai.unlikely.questionprocessor.computation.Comparison$GreaterThanOrEqual") (ComputationInputs GreaterThanOrEqualComputationUnit InputOneInputTwo) (ComputationDescription GreaterThanOrEqualComputationUnit ((Question)((GreaterThanOrEqual (RealNumber InputOne) (RealNumber InputTwo))))) For greater than or equal comparisons and: (IsA EqualComputationUnit ComputationUnit) (ComputationLocalJavaLocation EqualComputationUnit "ai.unlikely.questionprocessor.computation.Comparison$Equal") (ComputationInputs EqualComputationUnit InputOne InputTwo) (ComputationDescription EqualComputationUnit ((Question) ((Equal(RealNumber InputOne) (RealNumber InputTwo))))) For equality comparison of real numbers.

[0132] Verify if UL has meaning / verify paragraph Just as it's possible to write meaningless words in natural language (such as nonsense poetry), it's also possible to write grammatically correct ULs without meaning. Based on various examples, it's possible to define explicit rules for distinguishing meaningful from meaningless UL syntax and automatically apply these rules to identify invalid paragraphs. Note that invalidity is different from truth; a paragraph can be valid and still represent something untrue.

[0133] For example, the IsA semantic node described earlier requires two additional nodes to form a paragraph, where the second node must represent a meaningful class. For example, (IsA Brie GatwickAirport) has no meaning because GatwickAirport is not a class (the paragraph would translate to English as "Brie is a Gatwick Airport"). (IsABrie Cheese OriginatesFrom) also has no meaning because IsA is followed by three nodes instead of two.

[0134] Verification can be performed by any machine-readable description of these constraints that can be automatically read and checked. In a preferred example, these are naturally performed together with other UL paragraphs (referred to herein as verification paragraphs) that describe these constraints. Typically, these constraints will be provided by a business, organization, or individual that defines the key nodes in the paragraph. When verifying a paragraph, an example of the present invention can look at each paragraph and subparagraph and search for applicable verification paragraphs based on the semantic nodes in these paragraphs. By checking these verification rules against the paragraph under review, it is possible to determine whether the paragraph is invalid.

[0135] An example of a validation paragraph on node IsA is (SubsequentNodesHaveClasses IsA (List NodeClass)), which says that given a node of the form (IsA <node1> <node2>) paragraph, (Question)(IsA <node2>Class) should return Yes (or not return No). If it returns No, the paragraph is invalid. In order to constrain the number of nodes that can follow a specified node, a paragraph like (HasSubsequentNodes IsA (Integer "2")) says that IsA nodes must have exactly two semantic nodes following them to make sense. These are just basic examples, and more detailed expressions are possible. In the preferred example, multiple further descriptions are included, such as (HasSubsequentNodes List ZeroOrMore), which says that the List node can be followed by any number of subsequent nodes. Validation paragraphs can also be validated: for example, (HasSubsequentNodes SubsequentNodesHaveClasses (Integer "2")) says that the SubsequentNodesHaveClasses node used in the validation paragraph can be followed by exactly two more nodes.

[0136] Variants of these examples may define further constraints on meaningful paragraphs. In another example, (HasSchema ExpressedInEnglish (Schema ExpressedInEnglish Node String)) is an alternative way of expressing that an ExpressedInEnglish paragraph expects two additional nodes, the first in the Node class (Any Node) and the second in the String class. The preferred example of the UL validation system is able to use many different representation formats and dynamically evaluate whether a given paragraph violates them. While some requirements can be checked in code, such as the number of following nodes, most validation requirements in the preferred example leverage question handling and other elements of the UL platform. For example, when evaluating the validity of a paragraph (IsA Brie GatwickAirport) it is important to ask the question ((Question)(IsA GatwickAirportClass)), an example of which was given previously.

[0137] Validation can be used to check or select valid ULs generated during statistical translation methods (such as those described herein), or to filter out invalid ULs, and to check ULs entered by humans in real time or afterward. For example, when a user enters an invalid UL, validation can immediately flag it for correction. It can also be used to identify contradictions or other logical inconsistencies within a paragraph. For example, a paragraph asserting that another relation has similar or related semantics to IsA may conflict with a validation paragraph that describes a different expectation of semantic nodes that can be grouped using that relation.

[0138] In various examples of the present invention, validation can contribute to efficiency in question processing: when a subquery is generated, it can be checked for validity and not processed if it does not make sense. It can also be used for quality control of existing collections of passages, and can be used in automated monitoring systems to assign more or less confidence to passages.

[0139] UL variants Many variations on the definition of UL are possible for those skilled in the relevant art. Variations may include choices of syntax, representation, and many other details of representation and implementation. As used herein and where appropriate, "UL" is intended to encompass not only the preferred examples described herein but all such similar UL-like representations and variations.

[0140] Methods used to answer questions In a preferred example, the unknowns in the question are identified and the paragraphs that form the body of the question are selected for further analysis. The nodes following the question node in the header of the question paragraph are the unknowns for which we attempt to find mappings so that they satisfy the body of the question. Successfully satisfying the body with a UL that is considered true is the path to answering the question.

[0141] In the example, the process begins with a list of paragraphs from the body of the question and a selected unknown. The first paragraph in the list is selected for processing. This process aims to find all possible mappings for the unknown that can be true for the selected paragraph. In the example, processing a single paragraph includes three methods: using a statically stored UL paragraph, utilizing a computation unit, and utilizing a UL generated from inference: The first method is to check if there are any paragraphs in the paragraph store that can be directly mapped to the paragraph being processed. If the paragraph has the exact same structure as the paragraph in the paragraph store, and all nodes except the unknown item match, then the value that the unknown item matched is a valid result.

[0142] The second method is to check whether any results can be found by executing the computation cell. We check whether the paragraph matches any paragraph in the computation cell description. All non-unknown nodes in the paragraph being processed must match the same nodes in the corresponding positions in the computation description or align with the computation input unknowns. The unknowns being processed must align with the output unknowns in the description. The computation cell can then be called to obtain valid output values ​​for the unknowns in the processed paragraph.

[0143] The third approach is to see if the passage can be proven by applying any reasoning steps. We search for any reasoning steps where the passages in the second half of the reasoning passage can be unified with the passage being processed. All nodes and structures, except for the unknowns in either the focal or the reasoning passage, must be equal between the two passages. If such a reasoning passage is found, this means that the reasoning step can prove that the passage is being processed. When matching the reasoning passage, a multi-stage process is used to first find any mappings for the unknowns in the processed passage. Second, a mapping is found for the unknowns used in the reasoning passage by matching the mappings with the passage being processed. This mapping can then be applied to the first half of the reasoning passage to generate a list of passages. If these lists of passages can be matched with the known or generated UL and the mappings found for them, a valid mapping for the focal passage is proven and found. The solution to the list of passages can then be found recursively using the method we have described so far. In some examples, we track the depth of the reasoning currently being processed (i.e., the number of applied reasoning passages) and impose a maximum depth limit on how far we can explore for latency reasons.

[0144] These three methods can occur in any order and are not dependent on each other.

[0145] Once we've found a list of valid mappings for the first paragraph in the list, we must look at the rest of the list. If the list contains only one paragraph, the returned mappings are all valid. Otherwise, we look at each solution returned and apply it to the rest of the list before processing it. This returns a set of mappings that can then be combined with the mapping given for the head to give the final, complete mapping.

[0146] Some questions are yes / no questions and don't have an unknown term for which we're trying to find a mapping. These questions are processed slightly differently. Initially, they're processed the same way to see if we have a paragraph, reasoning step, or computational unit that proves the paragraph in question is true. If this returns a successful result, then we can return a Yes result. If it doesn't, then we look at all the paragraphs in the question and negate them using Not nodes. Each of these negated paragraphs is then processed to see if we can prove the negation of the original question. If one of these returns a successful result, then we can return a No result. If neither the initial processing nor the negated paragraph processing returns a successful result, then we can't say whether the question is true or false. Therefore, we can only return a DontKnow result. Problem handling example: To further explain the process, here is a walkthrough of how this method achieves results for a simple example. For this example, all nicknames used are valid, and the relevant UL paragraphs stored are those that exist within a trusted UL store that is believed to contain only true factual statements: (IsA X Unknown) (IsA A Unknown) (IsA B Unknown) (IsA Cheddar Cheese) (IsA Brie Cheese) (OriginatesFrom Brie France) (ConsequenceOf (OriginalsFrom X France) (HasAttribute X French)) (ConsequenceOf ((IsA XA)(HasAttribute XB)) (IsA X (AB))) The question is ((Question X) (IsA X (Cheese French))) This translates into English as "List French cheeses".

[0147] X is identified as an unknown item that needs to be mapped, and the paragraph to be processed is the list (shown here within square brackets) [(IsA X (Cheese French))]. From now on, we will show this as [(IsA X (Cheese French))] – X (IsA X (Cheese French)) - X is processed. It does not match any paragraph directly, nor does it match any computational unit. However, it can be proven by the inference paragraph (ConsequenceOf ((IsA XA)(HasAttribute XB)) (IsA X (AB))) because it matches the second half. The mapping is applied and processing continues, for example, recursively.

[0148] [(IsA X Cheese), (HasAttribute X French)] - X is processed. Selects the first paragraph.

[0149] (IsA X Cheese) - X is processed. It can be matched against two paragraphs to give the mappings X->Brie, X->Cheddar. No computational units or reasoning paragraphs can be applied.

[0150] These mappings are then applied in sequence to the rest of the list. This results in the following paragraphs being processed: (HasAttribute Brie French) — Only inference paragraphs (ConsequenceOf(OriginatesFrom X France) (HasAttribute X French)) can be applied (OriginatesFrom Brie France) This exactly matches a trusted paragraph in the paragraph store, so we know it's true. Therefore, (HasAttribute Brie French) is also true.

[0151] This is combined with the mapping at the level above to give X->Brie as a valid result. Then: (HasAttribute Cheddar French) — Only inference paragraphs (ConsequenceOf(OriginatesFrom X France) (HasAttribute X French)) can be applied (OriginatesFrom Cheddar France) cannot be proven by any means. Therefore, (HasAttribute Cheddar French) cannot be proven.

[0152] Therefore, this resulted in no results.

[0153] Thus, the complete process gives a single valid mapping of X->Brie, which in turn gives Brie as the final answer.

[0154] In various examples, the steps to answer the question are recorded to provide an explanation. For this question, the raw output from the example that followed this step is as follows: Result: Yes Solution: X->Brie explain: (IsA Brie (Cheese French)) Known: (IsA Brie Cheese) (HasAttribute Brie French) Known: (Originates From Brie France) The method outlined above for solving problems can also be used to solve crossword clues, in contrast to conventional AIs that are not well-suited for this task. For example, "Creamy French cheese" could be a crossword clue, and the method described above enables solving the definition portion of the crossword clue or cryptic crossword clue; the clue could generate the answer "Brie."

[0155] The method outlined above is a general process for dealing with the problem in some examples, however further examples have the benefit of improvements that can be made to the system to reduce delays.

[0156] One of these improvements is a "dynamic programming" cache in memory that can be used to store the resulting mappings for any passages with unknowns computed during problem solving. Due to the nature of problem solving, exploring different branches of reasoning can result in patterns of processing the same passages and unknowns. This cache means that each of these subproblems only needs to be processed once, with subsequent attempts returning the mappings stored in the cache. A purely recursive approach means that all data fetching from our database system must occur sequentially, just before the data is needed, with all further processing having to wait. To reduce this bottleneck, the system can be modified in two ways. These modifications allow as much data fetching and processing as possible to occur asynchronously and in parallel, before the final processing steps explore the data and construct results. When examining a paragraph with unknowns, the three phases outlined above (short-circuit matching with storage, fetching and executing computational units, and fetching the inference passage) can be processed in parallel, with data fetching occurring asynchronously so that the processing thread is not blocked. The inference passage step will then return additional paragraphs with unknowns that need to be processed, the results of which can be used to arrive at the result for the initial paragraph. This connection tree can be stored, and processing of these subproblems arising from inference can occur in parallel, allowing for parallelization of data fetching and exploration of inferences.

[0157] Once all passages have been processed to a given maximum inference depth, a second, non-parallelized step can be used to traverse the tree of processed passages and unknown mappings to find a valid answer. When looking through the list of passages, where each passage now has its valid mapping from the passage store and computation, a valid mapping for that list is one where all unknowns have values ​​and there are no conflicting mappings between passages in the list. This step can recursively walk through the data and find all valid mappings that can be returned as an answer to the original question.

[0158] Various examples may optionally store at least some of the paragraphs that have been generated from reasoning or computation, making them available for faster processing in the future. The history of these generated paragraphs is also stored in various examples, so that changes in the trust in the paragraphs used to generate them can be extended to the trust given to these newly generated paragraphs.

[0159] Priority Queue Example An alternative to the recursive system outlined above utilizes a priority queue to control the order in which subqueries are processed. This alternative uses the same three steps to process a given query passage, but differs in how it selects passages for processing and how the subqueries are stored. All query passages revealed during processing are stored in a map, along with any solutions found for that query. This data can then be looked up by the shape of the query passage. The shape of the query passage is defined so that all unknowns are considered equal, such that the queries (IsA X Cheese) and (IsA Y Cheese) are considered to have the same query shape and be the same subquery. In addition to this mapping, we also maintain a sorted priority queue of subqueries to be processed. Query passages we wish to process are first run through our prioritization method, outlined below, to calculate the priority value for that subquery. They are then placed on the priority queue, with the subquery with the highest priority at the front of the queue. The only query passages initially added to the mapping and priority queue are those in the body of the incoming question. Processing begins by removing the highest priority query from the queue and proceeding according to the three steps outlined above. The third step of processing the subquery will output a new reasoning step based on the reasoning paragraph in the data, which is used to find a solution to the query. For example, the subquery (IsA X (Cheese Creamy)) and the reasoning paragraph (ConsequenceOf ((IsA XY)(HasAttribute XZ))(IsA X (YZ))) can result in the reasoning step: If paragraph: (IsA X Cheese) (HasAttribute X Creamy) Then the paragraph: (IsA X (Cheese Creamy)) These reasoning steps are stored so that when combined with the query map, the inference tree for the problem can be explored. The if paragraph generated from this new reasoning step can then be added to the query map (if not already there), prioritized, and added to the priority queue for processing.

[0160] For this example, as new solutions to the subqueries are found during processing, they are added to the data in the query map. When this occurs, we also look at the stored inference steps to see if there are any solutions that can be propagated toward the root of the inference tree. For example, if we already know that X has the solution {Brie} to the query (IsA X Cheese), and we discover the solution X = {Brie, MashedPotato} while processing the query (HasAttribute X Creamy), we can review the inference steps above. If we can find a value of X that satisfies both of the if clauses, then we know it is a solution to the then clause. In this example, the solution X = Brie is a solution to both of the if clauses, so it can be added to the query map as a solution to the then clause (IsA X (Cheese Creamy)).

[0161] optimization A limit can be placed on the amount of work done to process a problem to control latency by limiting the number of subqueries processed. This can be done in addition to or instead of depth limiting.

[0162] This example allows for flexible parallelization of query processing. Instead of processing one query at a time from a queue, the system can use multiple threads to process multiple queries simultaneously. Each thread can independently remove the next query to be processed from the queue, process it, prioritize all resulting subqueries, and insert them into the queue. The thread can then retrieve the next query to be processed from the queue.

[0163] Prioritization Methodology: Several methods of query prioritization are possible. The simplest is to prioritize queries based on their depth in the search tree. The depth of a query increases by one for each reasoning step away from the original question. Using this prioritization allows the system to follow a breadth-first search pattern, processing all queries at a given depth before looking at the next step in the tree. An alternative example can consider many factors, including depth, the reasoning paragraph used to create the reasoning step, the paragraph's position within the reasoning step, and any solutions already found for the parent paragraph or sibling if paragraphs within the reasoning step. This allows for a "best-first" exploration of the search space, aiming to explore areas most likely to provide solutions as quickly as possible. This is beneficial because it can lead to faster processing of yes / no questions and improved processing capabilities when constrained by query processing limits. Using this prioritization scheme, the priority of a query can change due to solutions found elsewhere in the inference tree. Therefore, when a new solution is discovered and added to the query map, we must trigger a re-prioritization of all children of the query in question by looking at the reasoning steps revealed by the "then paragraphs" (paragraphs describing the consequences of the reasoning steps).

[0164] Complex reasoning steps: Some queries can result in subqueries containing more than one unknown, such as (IsA XY). These queries can return many solutions, depending on the data, and can result in slow processing times. We refer to inference steps containing these types of queries as complex inference steps. To overcome this problem, we use an optimization for complex inference steps, where only if clauses containing a single unknown are initially processed. Any solution found for this unknown can be substituted into the complex inference step to create a simpler inference step with a single unknown that can be processed normally.

[0165] For example, take the query (IsA X Food) and the inference paragraph (ConsequenceOf ((IsA XY)(IsSubclassOf YZ)) (IsA XZ)). This leads to a complex set of reasoning steps: If paragraph: (IsA XY) (IsSubclassOf Y Food) Then the paragraph: (IsA X Food) The first paragraph contains more than one unknown item and is therefore not added to the priority queue for processing. However, the second if paragraph can be processed. When processing the second paragraph, we can find the solution {Cheese, Nut} for X. Substituting this solution into the reasoning step creates a new, simpler reasoning step. Here we use the result Cheese as an example, but this can be repeated for all solutions to X.

[0166] If paragraph: (IsA X Cheese) Then the paragraph: (IsA X Food) We can now treat this new inference step as normal and prioritize and process the query paragraph (IsA X Cheese).

[0167] have no idea Due to incomplete knowledge of the world, examples of the present invention may need to be aware of the knowledge it lacks. For example, if the system realizes that it does not know whether it has information, the system may choose to take action to obtain the information, such as requesting the information from an appropriate user or other information source. For a human user, this may be a natural language question, so that the system can learn to answer when the human responds. In a preferred example, an "don't know" paragraph will be used to infer paragraphs to inquire whether something is known. In this preferred example, the don't know paragraph can take the form of (DontKnow X), where X is another paragraph. For example, (DontKnow (HasAttribute Cheddar Spicy)) expresses that it does not know whether Cheddar cheese is spicy. In the example, where the message is used as part of the question ((Question)(DontKnow (HasAttribute Cheddar Spicy)) asking "Do I know whether cheddar is spicy?", the system attempts to answer (HasAttribute Cheddar Spicy) (X) and (Not (HasAttribute CheddarSpicy)), i.e., (Not X). If either cannot be answered, the reason is lack of knowledge and the don't know passage is evaluated as true. If either can be proven, the system has knowledge and therefore the don't know passage is not true and evaluates to false. If the value of something does not need to be known, the unknown term can be used as a wildcard in the don't know passage, that is, whether the system has knowledge; for example, if the system knows the current President of the United States, then (Question)(DontKnow (HoldsOfficeUnknown1UsPresident)) will return true.

[0168] Thinking Results Question answering has been described in various examples. Some questions can potentially require a significant amount of reasoning effort to answer, and various examples may choose to limit the amount of reasoning performed for a specific application in order to return results in a reasonable amount of time. This can be done, for example, by limiting the number of subqueries executed for a particular question.

[0169] When answering a question, the same question can be asked again in the future, and various examples can choose to store the results of the query so that the same question can be answered more quickly next time. Various examples can also extend this approach to subqueries - saving the results as questions that the question processor asks during inference.

[0170] In the example, you can choose to save these results during the response to the user question, or save them only during the offline process, in which you can do in-depth processing of the question without making any users wait and store the results for online querying. These questions can be questions that have been seen previously during online processing, or questions that log analysis shows are frequently asked. This offline-only approach is the preferred example approach.

[0171] We answer questions by performing reasoning on a series of subqueries that ultimately lead us to the passage that answers the question. Certain subqueries frequently arise when working on different problems. Remembering these subqueries and processing them more deeply offline often allows us to answer questions faster and return better results (because we reason more deeply about the subqueries, giving us the opportunity to find more solutions). We call the output of this processing a thinking result.

[0172] In our example, we store two types of information during the thought process: the thought itself (i.e., the solution to the problem), and metadata about the thought, which includes a record of all our thoughts on the problem and how often the result was used.

[0173] Thinking result storage As mentioned earlier, question processing uses three methods: direct search for paragraphs that can be unified with the current subquery; using computational units; and reasoning. We store the results of thinking by storing intermediate paragraphs derived during the reasoning process, which can be found later through direct search.

[0174] For example, if we ask ((Question X) (IsA X Aerodrome)), we can answer that X=Gatwick based on the following reasoning: (IsA Gatwick Airport Aerodrome) Reasoning paragraph: (ConsequenceOf ((IsA AB) (IsSubclassOf BC)) ((IsA AC))) (IsA Gatwick Airport Airport) Reasoning paragraph: (ConsequenceOf ((IsA AB) (IsSubclassOf BC)) ((IsA AC))) Known: (IsA Gatwick Airport International Airport) Known: (IsSubclassOf InternationalAirport Airport) Known: (IsSubclassOf Airport Aerodrome) We will store (IsA GatwickAirport Airport) and (IsA GatwickAirportAerodrome) (both the final answer and the intermediate paragraphs) as if they were normal paragraphs entered by the user or learned in some other way. If we are asked the same question later, the answer can come from directly looking up (IsA X Aerodrome) without any reasoning. This also applies to subqueries: if some other question infers the subquery (IsA X Aerodrome) or (IsA X Airport), we can use the result of the inference directly without further reasoning.

[0175] Thought results, while just paragraphs like any other, can be stored in their own paragraph store, separate from other paragraphs, so they can be easily identified and processed—including expiring appropriately.

[0176] Along with each new paragraph stored in a thought result, we can also store an explanation. This is useful for preserving the steps used to arrive at the result. Without this, the explanation for X=Gatwick for the above question would simply be: (IsA GatwickAirport Aerodrome). Finally, we can also store dependent paragraphs: these are the paragraphs (inference or otherwise) used to arrive at the answer. If any of these paragraphs are updated or deleted, we delete the thought result, as it may no longer be valid.

[0177] In our example, we also take care to store passages appropriately, only for as long as they can reasonably be expected to be valid. Some passages are only temporarily true—such as the price of an actively traded commodity or the local time in a particular location; some passages have a much longer half-life of validity, such as political office holders, and some remain true indefinitely.

[0178] Answer questions using the results of thinking To incorporate these reflections into our question answering process, we query the reflection passage store when looking for passages that can be directly unified with the current subquery, as described above. However, nothing described so far prevents the system from continuing to reason about the subquery, potentially arriving at the exact same result as provided by the reflection. We may need to know that we've previously considered this subquery so that we can avoid reasoning about it again. This is why it's best to also store metadata about the reflections.

[0179] Metadata Not only do we store passages like (IsA GatwickAirport Aerodrome), we also record that we've considered (IsA X Aerodrome). Before performing any reasoning on them, we check the set of subqueries we've already considered. If we find we've already considered them before, we disable reasoning on the subquery and only attempt direct unification. To speed things up further, we can also record the number of solutions produced by processing the subquery. If this is zero, then we can avoid searching for passages that unify with the current subquery: we know there are none.

[0180] Offline process In the preferred example, the offline process runs the problem using a very high inference effort and stores the resulting inference results in the manner already described. Metadata is stored in a distributed memory cache; we store which problems have been processed, when, and the number of solutions generated. Subqueries generated during inference are also added to the distributed cache.

[0181] The offline process can run continuously, selecting questions to process based on their hit counts (see below) and how long it has been since we last processed that question. Questions that were processed some time ago and have low hit counts will be removed from the cache - or there is evidence that the results may be out of date.

[0182] Online Question Answering Before answering a top-level question outside of the offline process (i.e., a question that must be answered quickly), we preferably consult the distributed cache to see if the question has already been processed with a thought result and if it was processed recently enough. If so, we proceed with the question without reasoning (i.e., we use the thought result). If the cache tells us that the question results in no thought result, we return immediately without querying for a thought result. In this case, we return with a high-quality result almost immediately.

[0183] If a reflection result is not available (either because we haven't processed the problem before, or because we processed it a long time ago), we proceed as usual (i.e., reason until we reach our inference effort threshold or terminate for some other reason). We continue to consult the subquery's cache and do not reason about any subqueries in the cache (avoiding database lookups entirely if the cache tells us there are no results). If we find a subquery hit from this cache, we do not adjust our inference budget in any way. In this case, reflection results do not improve performance, but they can significantly improve result quality (if reflection results exist for the subquery).

[0184] Whenever we consult the cache, we record a hit for that query. If the query doesn't already exist in the cache, we add it with a hit count of 1.

[0185] For space reasons, various examples may choose to periodically remove underused or infrequently used or never used thought outcomes, even if they are still considered valid.

[0186] According to various examples, including preferred examples, metadata can include all stored paragraphs, including the reasoning paragraph used to generate the result. In the event that a paragraph is later discovered to be untrue, invalid, or altered, the metadata enables immediate removal of any thought results that depend on the invalid paragraph. If a thought result uses another thought result to generate the result, the dependent paragraphs of the used thought result are included in the dependencies of the new thought result.

[0187] Automatic monitoring Various examples can utilize an automated curation process to determine the value of paragraphs stored in the paragraph store. The benefit of this technique is the ability to scalably maintain the vast amount of information represented in the UL with little or no human curation. The inference engine in the question processor then uses the value of the paragraph determined by this process to determine whether it should use the paragraph. This allows paragraphs to originate from sources of low or unknown quality, knowing that poor quality paragraphs will eventually be closed or no longer used. In other words, it enables the system to understand which of its stored paragraphs are useful, authentic, or otherwise valuable, and which are not.

[0188] When a new paragraph is added to the repository by a human, it is assigned a low initial trust value when added by a regular user. Privileged users, or users the system has learned to trust, can result in a higher starting value. The reasoning engine can then be instructed to be more experimental when approaching questions, meaning it can try answering questions using paragraphs with lower values. The answers provided by the experimental reasoning engine are then monitored for any signals indicating whether the low-valued paragraph had a positive or negative impact on the answer. This information is then fed back into the automated monitoring process, which uses the new signals to re-evaluate the paragraph's value. Examples of signals used include results from test questions with known good answers: passages that support or are compatible with these answers, when used, generate positive signals for that passage, while passages that lead to false results or significantly slow the generation of good results, generate negative signals. Signals can also come from real-world results. Information from users (that the system has produced something valuable) will send positive signals to all passages of all types used to generate that result. Similarly, feedback from poor results will contaminate all passages used. Some good passages may be unfairly contaminated, but over time, they will also receive positive signals, and it will be possible to identify constituent passages that are consistently the source of negative results.

[0189] Value vector According to various examples, the overall value of a passage is a combination of factors that can vary depending on the system or process that wants to use it and the context. For this reason, a passage can be assigned a value vector where each number represents a different quality of the passage. This allows us to have different dimensions for truthfulness, usefulness, and efficiency. Then, the process that uses the passage only needs to use a priority vector with a number at each index indicating the priority they determine for that value, and the overall value of the passage to the process can then be obtained from the dot product of the two vectors. However, sometimes it is useful to use values ​​individually in certain contexts, in which case knowledge of the applicability of the score to that context can be used to optimize our use of the passage. For example, allocating reasoning budget in a question processor can be based primarily on the efficiency score.

[0190] Offline processing and experiments A further approach for automated monitoring is to run an ongoing process that reprocesses the questions it sees in production at a higher experimental level to test whether there are any low-value paragraphs that might help find more answers. Any low-value paragraphs that would help provide further answers can be boosted with a positive signal. According to other examples, an offline process can run test questions with known answers using the paragraphs being tested and see if it causes incorrect or irrelevant answers to be discovered or otherwise has an unacceptable impact on the performance of the system (such as poor latency). This can be used to confirm paragraphs that contain information and can be used for paragraphs, such as reasoning paragraphs. For production use, paragraphs that are determined to be harmful to the testing process can be ignored.

[0191] study Examples of the present invention, including examples implementing any of the applications described herein or other applications, can learn, represent what they have learned in a UL (or the like), and then utilize this stored UL to improve their performance. The learned segments are stored in long-term or short-term memory and used to deliver the application.

[0192] This approach is in contrast to prior art approaches often referred to as machine learning, in which parameters or weights are learned that allow a model to perform statistically better at classification, regression, or other tasks. Examples may also combine the language-based learning described herein with statistical machine learning. The learning described here is not weights, but concepts and ideas expressed in language and translatable into natural language, enabling the examples of the present invention to reason with what they have learned and explain what they have learned to human users. Learning also enables conversations with users in text or spoken language in a way that weights in statistical models cannot.

[0193] Sources / methods of learning used in examples of the present invention include: (a) Learning from conversations or other natural languages ​​provided by users: By translating natural languages ​​provided by users in spoken or written form into UL and storing it, the concepts, ideas, and knowledge represented in the stored UL are learned and can be utilized.

[0194] (b) Learning from reasoning: The UL generated from the reasoning chain can be stored and utilized. Reasoning can be targeted at a specific purpose, such as answering questions or the result of undirected thinking designed to find potentially useful ideas.

[0195] (c) Learning from other natural languages. By translating all or part of a document (such as a webpage, scientific paper, or other article) into a UL, the resulting UL can be utilized by the applications described herein. Other sources of natural language can include audio recordings or videos containing human speech, where speech recognition technology is first used to create a text transcript of the recorded speech, which is then translated into a UL. In some examples, neural networks can be trained end-to-end to convert audio data directly into a UL. For videos, examples can incorporate knowledge of the content shown in the video, such as described by a machine learning model designed to analyze the video's content and synchronized audio to better translate the audio or augment the audio with additional information recorded in the learned UL.

[0196] (d) Learning from structured data. Structured data includes the contents of tables found in documents or web pages, spreadsheets or relationships, graphs, or the contents of other databases. Structured data also includes formats that can be output by automated systems, such as JSON. Structured data can be converted into a UL by assigning semantic nodes to identifiers in the structured data or to relationships corresponding to relationships in a relational database, and generating a UL corresponding to the meaning of the structured data. (e) Learning from analysis of other data. Examples of the present invention can analyze data, process the data with algorithms, and express the results of the analysis in a UL. By storing the resulting UL, the analyzed and derived data is available to the system in a form that can be processed and reasoned about as described herein. In some examples, the analysis can be performed using a machine learning model.

[0197] Distributed usage. Semantic node resolution.

[0198] As mentioned previously, the preferred example enables any user of the UL to use any new ID for any node - essentially a private ID. However, if that entity is being used elsewhere, it may make sense for that user to use a shared ID for that node.

[0199] To achieve this, the service of the preferred example provides a shared ID to the node based on its description. This is referred to herein as Semantic Node Resolution (SNR).

[0200] To implement this service, it requires information about existing semantic nodes that the service can return, expressed as a UL. For shared nodes, this information will typically be public, but can also be based on additional private information about the node. When invoking the SNR service, the caller provides a description that gives information about the entity for which the semantic node is being requested. In various examples, this caller's description can be a UL or it can be a natural language description—or a combination of the two.

[0201] The SNR service then compares what it knows about the described entity with descriptions it has about existing nodes to see if it can confidently match the new node to a known node, and therefore provide a shared ID.

[0202] To do this, SNR considers potential matches and then attempts to estimate the probability that they are two different nodes. Above a certain threshold probability, such as 0.999, the shared node is presented. In various examples, possible matches and their probabilities can be returned, allowing the caller to decide whether to use the shared ID or a new ID.

[0203] Probability calculations are used by combining the probabilities from various parts of the description.

[0204] For example, suppose the unknown node is a human being named "William" and with a last name of "MacDonald," with a date of birth of 1953-04-02 and a country of birth of Ireland. Resolution would be impossible based solely on a date of birth match, as thousands of people share the same date of birth. However, combining this with a shared country of birth and a shared first name makes the probability that they are the same node very high, making the use of a shared ID reasonable. Implementations for humans would include heuristics and data to estimate the probability that a person has a specific date of birth or a specific first name, combine these probabilities, and then compare them to the universe of possible entities in that category. These calculations can be used to estimate the probability that a match is unique.

[0205] Note that some probabilities can be considered independent and multiplicative, while others are not independent and therefore require careful combination. For example, being female is half as likely because there are roughly equal numbers of men and women. Having the name Jane significantly reduces the likelihood because only a small fraction of people are named Jane. However, knowing that the node has the name Jane and is female provides little additional information beyond the name Jane, because almost everyone named Jane identifies as female. More subtle non-interdependent relationships also exist. For example, the probability of a name varies significantly depending on country of birth.

[0206] The immediate use of SNR is to provide a shared ID that the calling user can then confidently use. In some cases, the confidence level may not be high enough to immediately use the shared ID, and the caller may prefer to use a new or private ID until more information is known before making a match. SNR can also be used after a paragraph has been written using one or more private IDs, with the goal of rewriting that paragraph in a subsequent step to replace the one or more private IDs with public IDs. It can similarly be used to merge public IDs that mark the same entity, which might not be recognized as the same when they are first used.

[0207] Multiple UL storage areas Examples of the present invention enable passages to be stored in multiple separate storage areas. Storage areas can be used for different purposes and can have different access controls. Different storage areas can also have different trust levels. For example, various examples can maintain access to a UL storage area that contains highly trusted passages representing common sense information about many widely used semantic nodes, as well as useful and non-controversial reasoning passages. Another UL storage area can contain employee and human resources records for a private enterprise, and strictly limit access to select people within that private organization. In some examples, these restrictions can apply to organizations. The UL representation of a particular natural language book can be given its own storage area. According to various examples, UL repositories can be shared among multiple users. For example, a trusted core UL repository of widely used semantic relationships can be made widely available. UL representations of books or key repositories of knowledge can be commercially licensed by the organizations that build and maintain them.

[0208] translate Translation is the act of fully or partially parsing the semantics of a natural language into a UL or converting a UL into a natural language, with the intention of communicating with humans, learning, and understanding information stored in a natural language and other intentions.

[0209] Sequence-to-Sequence Models Sequence-to-sequence models can be used to perform full or partial semantic parsing of natural language for translation into UL. A typical sequence-to-sequence task is neural machine translation, a term used for state-of-the-art methods that use neural networks to translate between pairs (or more) of natural languages. A typical sequence-to-sequence architecture consists of an encoder that transforms a source sentence into an internal vector or sequence of vectors encoding the source sentence. This internal vector or sequence of vectors is then read by a decoder that generates a corresponding sequence of words or tokens. Variants of this architecture use recurrent neural networks, including long short-term memories (LSTMs), various attention mechanisms, and more recently, transformers. Such architectures can be considered conditional language models, where, in the case of translation, the output language model is conditioned by the input source language.

[0210] Examples of this invention utilize neural architectures, but rather than using only natural language, they utilize neural networks trained on translations between natural language and UL (or similar). The resulting neural network can then generate ULs that correspond to the meaning of the input natural language. In a preferred example, the vocabulary includes semantic nodes and left and right bracket symbols.

[0211] An important point is that, in contrast to neural translation systems that translate between natural languages, a neural architecture designed to parse natural language into a UL can be thought of as a system that understands natural language as a representation of a resulting UL (or UL-like representation) that fully represents the semantics of the source natural language and is machine-processable. This UL can then be used for reasoning, question answering, and other actions and applications, as described in this paper. In machine translation systems between natural languages, both source and target translation exhibit the machine understanding problems common to all natural languages, which have been previously described in this paper.

[0212] Beam search is a method that, rather than simply reading the most likely output symbol from the decoder at each step in a neural machine translation system, maintains a list of possible outputs from the decoder and their probabilities, which can be used to generate a list of possible translations. Examples of the present invention that can verify the UL use beam search and remove invalid UL translations from the results to ensure that the generated UL is meaningful. Automatic verification of the UL can also be used to ensure that the system is trained only with valid ULs. According to various examples, automatic verification can be performed using a verification paragraph (as described herein).

[0213] Transformation-based machine translation As an alternative to the neural methods mentioned above, other examples use an intermediate representation (IR) as an intermediate stage between the source natural language and the target language. To efficiently and accurately translate natural language into a machine-readable semantic language, such as UL, these examples capture the intended meaning of the original NL. In some direct template-based approaches, meaning is captured by humans; in others, computers are used. This creates a bottleneck in the data acquisition phase. By finding an appropriate IR—one that provides a high degree of semantic understanding and a structure compatible with the target language—such examples can outperform direct translation methods.

[0214] According to some examples, the IR used is a "semantic graph" (e.g., originally described by Menezes and Roth in "Semantic Hypergraphs"), where a semantic parse is derived from a combination of NLP annotations, including part-of-speech (POS) tags, dependency labels, and semantic roles. Once generated, this IR provides a hierarchical recursive structure that represents an attempt to determine the semantic roles played by a set of tokens within an input sentence of arbitrary length.

[0215] Example: NL: "Aurora graduated with a master's degree in engineering from Crescent School in Singapore."

[0216] IR (Semantic Graph): See Figure 11 ,For example, …where / C=concept, / P=predicate, / M=modifier, T=norm builder, and / B=concept builder.

[0217] This semantic parsing is morphologically similar to UL: both are hierarchical, recursive structures. Next, a human or computer can create "semantic templates" by mapping UL paragraphs with many variables onto similarly shaped semantic graphs, or variations of these graphs that support unknown items. Given enough of these templates, a preferred example can use a transformation-based translator to improve upon other methods by: 1. Generating Semantic Graphs from Natural Language 2. Try to match it to a template of a similarly shaped graph that already has an associated UL, and finally 3. Apply direct translation only to those nodes in the graph that match the variables in the UL. Examples of using this technique can be improved by methods where humans are given translations and they modify the source semantic template to improve future translations or break it down into component templates that support a smaller range of natural language structures. Overall, this involves less human input than direct template methods because the semantic graph automates the translation process and parses syntax into semantically based structures, more successfully than classic translation-based translation methods.

[0218] An implementation of NL to UL translation-based translation using an IR similar to that described above provides three advantages: 1. Semantic graphs are recursive, that is, they can serve as vertices in other semantic graphs. Since UL is also recursive, this enables the translation of longer sentences by individually translating the semantic components of longer sentences that have never been seen before and combining the results. 2. Along the same lines, if a translator encounters a word-meta sequence that it cannot match to any semantic graph pattern, the translator may still be able to provide a partial translation and, therefore, a partial representation of meaning—in this case, direct translation will fail, and neural translation will have a higher probability of producing inaccurate results.

[0219] 3. By automating a portion of the meaning extraction process, the role of the human annotator can be changed from creator to corrector. This allows us to improve the efficiency of the direct translation process while retaining the accuracy and traceability that NMT lacks. This allows for more efficient acquisition and generation of data in the form of perfect NL to UL pairs.

[0220] The transformation-based translator as described in this paper can be used as part of a method to train accurate neural machine translation. Given some constraints on the variables present in the UL part of a semantic template such as "X is probably just cheese from France (NMT)", work on NMT can be 1. Identify all (or a higher number) possible values ​​of the unknown term, 2. Using the transformation-based translator in other translation directions to generate grammatically correct and meaningful sentences from semantic templates, 3. Use these source / target language pairs as training data to train an NMT translator 4. Record the weights of the trained NMT translator Since semantic graphs are recursive, this approach also supports replacing any part of the resulting sentence with a more complex subgraph with the same semantic label.

[0221] Thus, we describe a method for converting natural language to UL using a transformation-based translator. Thus, we also describe a method for converting between natural language and UL using a deep learning translator that has been trained at least in part on data generated from the transformation-based translator.

[0222] Other translation methods / alternative examples One method used in some examples for translating to and from the UL is to look at UL passages that have been marked as "ground truth translations." These are known translations between UL passages and passages written in a natural language (such as English), which are assumed to be accurate. In some examples, these can simply be stored in a database that lists the ground truth translations for the corresponding UL passages. In some examples, the translations themselves can be stored as UL, such as: (EnglishGroundTruthTranslation (IsA Brie ((Cheese French) Creamy)) "Brie is a creamy French cheese") This means that "Brie is a creamy French cheese" is an exact English translation of (IsABrie ((Cheese French) Creamy)). If we call this paragraph GroundTruthTranslation1 and we also have (IsA GroundTruthTranslation1GroundTruthTranslation) in our repository, we can use this known "correct" translation as the basis for other similar translations. Using the above method, whenever there is an exact match in the UL, such as "Brie is a creamy French cheese", a perfect translation can be generated. These paragraphs can also be used to translate things that are not exact matches. A simple example of an inexact match would be the English paragraph "Camembert is a creamy French cheese". The methods used in some examples depend on the direction of the translation. When translating from natural language to UL, we break down the structure of a given sentence and compare it to the structure of each of the known ground truth translations to rank by similarity. The sentence is broken down into words (or other atomic parts of language) and then reassembled into sub-parts (sequences of words) for which we have existing translations, such as (ExpressedInEnglish Camembert "Camembert") and (ExpressedInEnglish IsA "is a"). These two paragraphs would mean that the Camembert node becomes an option for the "Camembert" portion of the sentence, and IsA becomes an option for the "is a" portion. When "Camembert is a creamy French cheese" is matched with GroundTruthTranslation1, the translator will assign a high similarity score because most of the sentence is identical, and the only different part ("Camembert") has the same part of speech as "Brie" and has a very "similar" option (Camembert) in the list to the node used in GroundTruthTranslation1, which is Brie. In a preferred example, a component of the UL platform called the Solid Solver is used to compare the similarity of the two nodes.

[0223] According to various examples, the entity resolver currently works by comparing a large number of passages in which two nodes are used and determining how similar their usage is. If they are used in nearly identical ways, then they are likely very similar nodes and a direct replacement in translation would likely be accurate. For example, they may belong to the same class, so we can see (IsA Brie Cheese) and (IsA Camembert Cheese), which are identical except for the node we are comparing. In other examples, the entity resolver incorporates further heuristics or features to determine the similarity of two given nodes.

[0224] The translation from UL to English again uses the Entity Solver component to compare the UL we are translating to the known ground truth translation and pick the one that is most similar. The different nodes then replace their translations to form the final output string.

[0225] Word embeddings such as word2vec or GloVe are well-known techniques for those skilled in the art, where large amounts of text are analyzed to identify words with similar meanings and usages. Various examples use this technique to determine the similarity of natural language words and their suitability as replacements for known ground truth translations. For example, an analysis of English would determine that Camembert and Brie are very similar items, as their word embeddings would be very close to each other. This means that a ground truth translation that includes Brie would almost certainly replace Camembert with Brie, swapping semantic nodes in the UL half of the translation.

[0226] Another technique used in various examples involves automatically evaluating the semantic impact of natural language wording changes. In natural language, there are often multiple ways to say the same thing. Sometimes a rewording results in another paragraph with the same meaning; in other cases, the semantic change is minor. In other cases, the semantic change is significant. Using automated methods to evaluate the semantic impact between two natural language paragraphs, if the semantic impact is assessed to be minor or nonexistent, the ground truth translation can be used even if there is no exact match to the natural language in the ground truth translation.

[0227] Examples of techniques that could be used for semantic impact assessment would be to note the replacement of words that are known to be synonyms or words of similar meaning, rephrasing that are known to be other ways of saying the same thing (e.g. in English, talking about " <noun1>of <noun2>"and" <noun2> 's <noun1>”), and the addition of filler words that only subtly change the meaning when used.

[0228] According to various examples, the translator uses a pipeline in each direction, where each pipe is a function that takes in a document structure and returns a new document structure. Each pipe can add a part to the document for use by later pipes. The final document contains a part, which the pipeline treats as an output part, and the pipeline returns the part as output. The first pipe in each pipeline is used to do a direct lookup in the cache, and if this returns a successful translation, the rest of the pipes can be skipped. In the case of English to UL, we then run a series of pipes that use the StanfordCoreNLP library or similar to tokenize the sentence and label it with a portion of the verbal information that can be used to help the ground truth translator pipe determine the best match in later pipes. When translating from UL to English, the only pipe used before the ground truth translation is the direct lookup pipe, as the UL itself should already give enough semantic information to be translated back into natural language. An optimization present in various examples is the use of Bloom filters to identify language passages that are not present in the translated store to reduce the load on the system. Bloom filters are space-efficient probabilistic data structures that are used to test whether an element is a member of a set.

[0229] According to various examples, the translator will actively try to vary the translation of the natural language between a wide range of semantic equivalents and natural translations to create diverse and fresh speech to benefit users of products powered by the present invention. For ground truth translations, this can be done by randomly selecting between multiple translations of the same UL. Other techniques described herein either also naturally generate multiple candidate translations or can be easily adapted to do so.

[0230] Template Translation As used in some examples, one approach for translating to and from UL is to use templates. A template is data stored in a database that represents a common translation pattern, where some parts of the translation contain unknown terms that may match multiple different semantic nodes. In a preferred example, a template includes a UL segment, such as (IsA 0f88f8eb-fe72-47ee-9cb1-2d3322e61481 (Cheese Creamy)); a natural language segment, English or other language, optionally containing an unknown term, such as "0f88f8eb-fe72-47ee-9cb1-2d3322e61481 is creamy cheese"; a list of uuids used as unknown terms, such as [0f88f8eb-fe72-47ee-9cb1-2d3322e61481]; and a list of UL segments called matching criteria, such as [(IsA 0f88f8eb-fe72-47ee-9cb1-2d3322e61481 Cheese)]. Translation using these templates can be performed by testing whether the input UL or natural language matches the corresponding field in the template. Unknown terms in the template can initially be matched to any string or semantic node. When translating from natural language, a string matching the unknown term must be searched in the UL data body to find a valid semantic node to use. The input string "Brie is a creamy cheese" would match the template explained above, resulting in an unknown term mapping of 0f88f8eb-fe72-47ee-9cb1-2d3322e61481 -> "Brie". The string "Brie" can then be searched in the UL data body to find the semantic node Brie. The final step is to test the matching criteria to see if this template can produce a valid translation. All unknown term mappings are applied to the matching criteria paragraph. In various examples, all unknown term mappings are then treated as questions or checked in the UL paragraph data to test their validity. In the above example, this means treating the paragraph (IsA Brie Cheese) as a question. If all matching criteria are deemed valid, then the unknown term mapping can be applied to the output data (whether UL or natural language) to produce an output translation. In this example, the output is (IsA Brie (Cheese Creamy)).

[0231] According to various examples, these templates can be created by humans, but in preferred examples, they can be automatically generated from a large number of ground truth translations (known natural language / UL translations). In order to generate templates from example translations, similar ground truth translations can be collected together to try and generate templates. In the case where there is a variation in the ground truth, this variation can be replaced with the unknown to create a template. The semantic nodes from the ground truth that were replaced with the unknown can be processed to generate matching criteria. In various examples, this means finding which classes these nodes are occupants of, finding the lowest common class between them and adding the matching criteria paragraph (IsA <unknown><lowest_common_class>),in <unknown>is a new unknown item added to the template, and<lowest_common_class> The node with the lowest common class shared by all nodes being viewed. In a class tree linked by subclasses, the lowest common class of two or more nodes is the class that all nodes are members of and that is furthest from the root of the tree (most precise). For example, for the two example translations "What is the population of England?" and "What is the population of Madingley?", the lowest common class of England and Madingley might be place.

[0232] Translation context ULs can encode self-referential and metalanguage statements: they can describe how and when translations are performed, as well as what is more appropriate in one context than another. For some applications, it is desirable to be able to generate translations specifically adapted to the current context. Some examples utilize methods to express descriptive contextual information about potentially translated semantic nodes in the UL. By making this information available to the system at runtime, program reasoning can select the most appropriate attributes from the available attributes (e.g., "vehicle," "sedan," "my Audi"), which can then replace the original node in a preprocessing step. Other translation techniques can then be applied to render it in natural language.

[0233] Translation between natural languages UL is designed to fully represent the meaning of any natural language, and the language can be easily extended to accommodate nuances and new concepts from new languages ​​that may not have been created before. This means that once a document or a piece of natural language is translated into UL, nothing is lost, and the UL translation can contain all the semantics and nuances of the original. This is in contrast to a single natural language, which is naturally an inexact translation of the source language, where the meaning of words is not exactly the same, or even words do not exist in the target language.

[0234] For this reason, an improved approach for translation between multiple languages ​​is to build a translator from and to the UL for each natural language, and translate between the natural languages ​​by first translating the source language into the UL and then translating from the UL into the destination language. State-of-the-art translation systems, such as neural machine translation systems, typically learn from examples of text between pairs of natural languages—or they direct their efforts and resources toward specific language pairs. This means that for n languages, you'll need n squared translation systems to accommodate all language pairs. Since UL is effectively an intermediate language, the number of systems you'll need to build is 2n—one UL->NL system and one NL->UL system for each language.

[0235] Expression of emotions, connotations, etc. Words in natural languages ​​often have connotations or inferences that extend or attach to their pure meaning. For example, in English, the word "error" has multiple synonyms, such as "boo-boo," "screw-up," "inaccuracy," and "blunder." Although considered synonyms, these different words have different connotations and usages. For example, "boo-boo" is used to describe children or to mock adults; "inaccuracy" expresses politeness or a relatively minor mistake; and "blunder" implies a major error, in which considerable responsibility is placed on the person making the mistake.

[0236] According to various examples, these connotations and usages can be represented by having different semantic nodes corresponding to each of these concepts. Meanings containing these connotations can be represented in other ULs that connect these semantic nodes to similar but different nodes while also explaining the differences.

[0237] The use of nesting can be used to represent the mood and tone of writing, as well as other characteristics such as nuance or formality. For example, a semantic node representing an angry tone can be combined with a spoken paragraph to represent the paragraph being delivered in an angry tone. In the speech example, such a representation can be used to modify the generated sound to appropriately incorporate emotion in the output.

[0238] Specific applications built for the examples of this invention Recruitment Apps Automated recruiting applications are applications that attempt to automatically find highly qualified candidates for a given position by matching a representation of a potential job applicant's resume with a representation of the role and job specification. Further examples of such applications may also match a job applicant's desired role with a job description and assess how well qualified the job applicant is. There are potentially hundreds of thousands of potential candidates online who could be a match for a given job. Prior to this invention, hiring was typically conducted by humans using tools to search databases of such candidates. Typically, such searches were based either purely on unstructured data—searching for keywords in their resumes—sometimes in combination with limited structured data. For example, a job search specifically looking for software engineering talent might include structured data for common programming languages, and in addition to allowing a keyboard search, the search box might also include drop-down menus or checkboxes for those specific skills. This limited structured data was conventionally created using database schemas and specific code to include this data in searches.

[0239] Additionally, some applications attempt to apply existing NLP techniques to both resumes and job specifications, then attempt to rank job applications based on their statistical match to the specifications. The limitations of existing NLP techniques mean that rankings are only approximate and are heavily influenced by similar keywords in both the resume and the job specification. This provides some value to recruiters who want to narrow down their resume list, but it still requires significant human input to have a high degree of confidence in a good match, and therefore recruiters may not see good matches.

[0240] In reality, the number of different skills or experiences that might appear on a resume or job specification is very large, which means that any structured data that is determined and encoded into the system can only cover a small fraction of what might be searched for.

[0241] Thus, automated recruiting is an example of a HUB application.

[0242] This article describes a sample application called Jobe. It represents a preferred example of a recruitment application and other related examples.

[0243] In a preferred example, most job specifications and candidate resumes are represented by ULs or similar, and the reasoning methods described herein are used to determine whether they match. In various examples, the ULs or similar representations of at least some of the candidate's goals also match the job specifications and possible employer descriptions.

[0244] Figure 1 An example of a push notification from Jobe on a user's phone is shown, notifying them that a new candidate is a strong match for one of their jobs. This match occurs automatically. If the match were statistical or using existing, inaccurate methods, the app designer would not have the confidence to interrupt the user with this message, as the match would typically be very poor. Because the technology in this app is based on examples of the present invention, it is known with a very high degree of confidence that the automatic match is good, and therefore interrupting the user is a good product experience. Thus, in this example, the present invention enables a product experience that was previously impossible.

[0245] Figure 2 An example of matching details is shown, where the requirements of a role are matched with data from a candidate's resume. Figure 2 The diagram shows three example job requirements for a junior software engineer position: experience with a primary object-oriented language, fluency in a foreign language, and location. Specifically, Jobe matches the requirement of "1+ years of primary object-oriented language" with "3 years of C++ programming," infers fluency in Portuguese based on the fact that the candidate attended high school in Brazil (where the primary language was Portuguese), and infers that the candidate is "within commuting distance of London" based on the fact that she lives in Hitchin, Hertfordshire, UK.

[0246] In these examples, there is no evidence from the resumes they match that share any keywords with the actual requirements. All three matches also require reasoning using the UL representation and come from the semantics of the requirements and job specification. Here is further illustration of how one of these matches is made using UL: As described herein, examples of the present invention can answer yes / no questions. To match similar candidates, the system asks itself the question "Does 7 years of C++ experience imply at least five years of programming experience in a primary object-oriented language?" "7 years of C++ experience" can be represented in UL as ((Experience CPlusPlus) (Year(RealNumber "7")) - Experience is combined with another semantic node to represent experience with the concept. Year represents a unit of time and is combined with number to give a number of years.

[0247] "At least five years of programming experience in a major object-oriented language" can be expressed as ((Experience (Programming (UnspecifiedMember ((ProgrammingLanguageObjectOriented) Major)))) (Year (AtLeast (RealNumber "5")))) AtLeast combined with a number gives a range of numbers. Thus, combined with a unit, it gives a range of units. In this case, it is the minimum number. UnspecifiedMember represents an unrecognized member of a class.

[0248] Therefore, the whole problem can be expressed in UL as follows: ((Question) (Implies ((Experience CPlusPlus) (Year (RealNumber "7")))((Experience (Programming (UnspecifiedMember ((ProgrammingLanguageObjectOriented) Major)))) (Year (AtLeast (RealNumber "5")))))) To answer this question, we used the following trusted passages from the UL repository representing recruitment-related information. These passages were generated by conversations between the system and humans, translated from natural language into UL, or added directly by trusted humans, building recruitment applications, according to various examples.

[0249] (IsA ProgrammingLanguage Class) (IsA ObjectOriented Attribute) (IsA Major Attribute) (IsA CPlusPlus ProgrammingLanguage) (IsA CPlusPlus ((ProgrammingLanguage ObjectOriented) Major)) (IsA Year Unit) In addition to these known paragraphs, calculation units and reasoning paragraphs are also required. The calculation unit for comparing whether 7 is greater than or equal to 5 is defined as follows: (ComputationInputs GreaterThanOrEqualComputationUnit InputOneInputTwo) (ComputationDescription GreaterThanOrEqualComputationUnit ((Question)((GreaterThanOrEqual (RealNumber InputOne) (RealNumber InputTwo))))) (ComputationLocalJavaLocation GreaterThanOrEqualComputationUnit "ai.unlikely.questionprocessor.computation.Comparison$GreaterThanOrEqual") And the required reasoning paragraph for this question is: The core reasoning paragraph that helps define the IsSubclassOf relationship (other examples might choose to make IsSubClassOf reflexive, but in this example, it is reflexive) (ConsequenceOf (IsSubclassOf AB) (IsA (UnspecifiedMember A) B)) (ConsequenceOf ((IsSubclassOf XY) (IsA A Attribute)) (IsSubclassOf(XA) Y)) (ConsequenceOf (IsA X Class) (IsSubclassOf XX)) Reasoning related to quantity, activity, suggestion, etc.: (ConsequenceOf ((Implies XY) (QuantityWithinRange AB)) (Implies (XA) (YB))) (ConsequenceOf ((IsA X ProgrammingLanguage) (Implies (Experience(Programming X)) Z)) (Implies (Experience X) Z)) (ConsequenceOf ((IsA X Activity) (IsA Y Activity) (Implies XY))(Implies (Experience X) (Experience Y))) Programming in a programming language is an activity (ConsequenceOf (IsA X ProgrammingLanguage) (IsA (Programming X)Activity)) If X is a programming language and is a member of class C, then programming X means programming the members of C (ConsequenceOf ((IsA X ProgrammingLanguage) (IsA XC)) (Implies(Programming X) (Programming (UnspecifiedMember C)))) If A is in range B, and X is an arbitrary unit, then A times X is in range B times X (ConsequenceOf ((IsA X Unit) (WithinRange AB)) (QuantityWithinRange(XA) (XB))) If X is greater than Y, then X is within the range of at least y (ConsequenceOf (GreaterThanOrEqual XY) (WithinRange X (AtLeast Y))) Using the question answering method described in this article, you can generate a "Yes" result for a question. To further illustrate the method, the following explanation shows the steps that may be generated using some examples of the reasoning method described herein: (Implies ((Experience CPlusPlus) (Year (RealNumber "7")))((Experience (Programming (UnspecifiedMember ((ProgrammingLanguageObjectOriented) Major)))) (Year (AtLeast (RealNumber "5"))))) (Implies (Experience CPlusPlus) (Experience (Programming(UnspecifiedMember ((ProgrammingLanguage ObjectOriented) Major))))) Known: (IsA CPlusPlus ProgrammingLanguage) (Implies (Experience (Programming CPlusPlus)) (Experience(Programming (UnspecifiedMember ((ProgrammingLanguage ObjectOriented)Major))))) (IsA (Programming CPlusPlus) Activity) Given: (IsA CPlusPlus ProgrammingLanguage) (IsA (Programming (UnspecifiedMember ((ProgrammingLanguageObjectOriented) Major))) Activity) (IsA (UnspecifiedMember ((ProgrammingLanguage ObjectOriented) Major))ProgrammingLanguage) (IsSubclassOf ((ProgrammingLanguage ObjectOriented) Major)ProgrammingLanguage) (IsSubclassOf (ProgrammingLanguage ObjectOriented)ProgrammingLanguage) (IsSubclassOf ProgrammingLanguage ProgrammingLanguage) Given: (IsA ProgrammingLanguage Class) Given: (IsA ObjectOriented Attribute) Given: (IsA Major Attribute) (Implies (Programming CPlusPlus) (Programming (UnspecifiedMember((ProgrammingLanguage ObjectOriented) Major)))) Given: (IsA CPlusPlus ProgrammingLanguage) Known: (IsA CPlusPlus ((ProgrammingLanguage ObjectOriented) Major)) (QuantityWithinRange (Year (RealNumber "7")) (Year (AtLeast(RealNumber "5")))) Known: (IsA Year Unit) (WithinRange (RealNumber "7") (AtLeast (RealNumber "5"))) Calculation: (GreaterThanOrEqual (RealNumber "7") (RealNumber "5")) Various examples can generate natural language translations of the steps, either showing a complete example for each step, or creating simplified explanations that skip obvious common-sense steps to create easier-to-understand explanations. Figure 7 Examples of such explanations generated by various examples are shown.

[0250] Various examples of recruitment applications may use LLM or other statistical techniques in conjunction with or instead of matching using UL. For example, an application that cannot translate a line in a job specification into UL uses matching using LLM as a failover and combines the results from LLM with the results generated by matching with UL.

[0251] The specific method includes providing a prompt to the LLM containing the candidate's resume and the lines in the job specification, and asking the LLM to generate a continuation stating whether the candidate is a match for this job specification line and providing a simple explanation of why. In some examples, the prompt will request the LLM to provide a classification of Yes, No, or Unknown. In other examples, the degree of certainty can be requested. Examples can use an LLM that has been fine-tuned by matching examples in each category requested with appropriate explanations. Other examples can include a small number of examples in the prompt.

[0252] LLM can also be used to extract relevant skills from free-form resumes. Many resumes contain sections that may be difficult to fully translate into UL. Using this technique, an example might ask LLM to simplify the content by providing a resume and prompting it to extract the skills the candidate says they possess from the free-form text. Similarly, the example might request a summary of the candidate's experience. Once the skills and experience have been extracted, the example can translate these into UL as a description of the candidate and match them against the UL translation of the job specification, or utilize a matching approach using keywords.

[0253] Examples of appropriate prompts for extracting skills would be: We are considering a candidate for the job. Here is their resume: [Text of their resume] Please list the skills they possess, one skill per line.

[0254] Another example prompt: For each sentence above, please list all the skills this candidate possesses, with each skill on a new line and beginning with a "*". The skills should be listed in the same order they appear above. Each sentence should not exceed 5 words.

[0255] Another use of the LLM in some examples is to provide prompts asking us to consider one or more of the most appropriate roles for a candidate. In applications involving a large number of resumes and a large number of job specifications, this allows for far fewer matches to be processed because, for example, we won't try to match someone who isn't a good fit for software engineering to a software engineering job specification, or we'll limit matching software engineering job specifications to only candidates who appear to be a good fit for the role.

[0256] As a further filtering and matching technique used by some examples, lines or larger sections from the job specification are converted into embeddings and these embeddings are compared with embeddings generated from sections in the resume. Cosine similarity or similar techniques are then used to roughly estimate whether the candidate matches these requirements. Examples can combine this technique with other matching techniques described herein.

[0257] Another application of LLM is to generate explanation summaries from longer explanations generated by UL matching in situations similar to those described in this paper.

[0258] More general matching The techniques described herein for matching candidates with jobs (including the use of LLMs as described herein) can be extended to many other situations where a match between descriptions is needed. In a recruitment application, two juxtaposed documents (e.g., a job profile and a candidate profile) are imported into a LLM (possibly simply by translation). Once the semantics of the statements in the documents are captured, reasoning can be performed to generate the best mutual match. LLMs can be used as an alternative or replacement method for performing such matching, as described herein. For recruitment applications, the agents are the job seeker and the employer. For other applications, different agents are juxtaposed to detect the best knowledge-based match. The goal may be to generate mutual matches or for a single agent to discover a set of best matching agents. Some examples include person matching (dating, friendship, professional relationships, relationships, employment, personal services), person-product matching (e.g., ad recommendations, product selection support, product recommendations), person-business matching (recruitment, evaluating applicants for government services, credit scoring, matching insurance criteria, matching tax criteria, test group selection, university applications), and business-to-business matching (e.g., partnerships, clients, merger or acquisition potential). Horizontal Health App Horizontal health applications are applications that attempt to record and manage extremely diverse sets of health data from one or more users. As discussed herein, it is impractical to represent this data in a way that a computer system can understand and manage using existing technology prior to this invention.

[0259] Nutrition: There are millions of different foods and millions of different consumable substances. These substances are sometimes related (e.g., types of fat) and have many different properties. The interactions of these substances together and with the human body are extremely complex—and a deep semantic representation of nutrition can allow computer-based systems to make very complex dietary recommendations and unlock previously unobserved interactions. Therefore, nutrition is a HUB application.

[0260] More general health is another example of an unreasonably broad domain. Nutrition is a sub-domain of this extremely broad field. An application that tracks a person's daily health information would need to incorporate a large number of health tests and include fields such as: levels of certain substances in the blood, organ measurements, body composition measurements, measurements of physical performance in various areas, activity information, nutritional information, genetic data, microbiome data, sleep data, specific events that affect health (exercise, consumption, substances consumed, mood, bowel movements), and a large number of documented health conditions and diseases. Any of these types of data can be correlated with other data and related health purposes for the patient. While small subsets of these can be built using the typical local solutions we see today, building a massive general health application that potentially encompasses all of this information was impractical before this invention.

[0261] "Chea" is an example application from the class of applications described herein. It represents a preferred example and other examples of the present invention.

[0262] In addition to recording health data from wearables and other health sensors, Chea also features a chat window where users can share health-related events that occur to them and have the app understand, store, and process them. An example health event might be a nutritional event: the consumption of food and drink. This window can also optionally be used to record other health events: specific symptoms of illness, information about mood and energy levels, bowel movements as represented on a Bristol stool chart, and so on.

[0263] Figure 3 A conversation within the app is shown where nutritional data is being transferred to the app. In a preferred example, the conversation is between the user, the AI, any number of human medical experts, and a human nutritionist who derives semantic nutritional data from photos and descriptions of food and drinks entered by the user as they are consumed. The AI ​​can handle other tasks that a human can do where automated processing is not possible. An example of an automated task would be prompting the user when nutritional information or other health information that is assumed to be regularly supplied has not been added in a period of time. For example, if there is a long period of time in a day where no food or drink has been entered, the AI ​​can ask the user if this really happened or if they forgot. If the user intends to record details of a bowel movement, they can also be prompted if there is an unusually large gap and no information has been shared. The semantic nutritional data not only represents exactly what was consumed and when, but also represents uncertainty - for example, from not knowing the exact ingredients of a food to uncertainty about portion sizes from images.

[0264] The UL supports this uncertainty. For example, it might be impossible to determine what type of cheese is shown in an image, and the user might not know, but in this case a semantic node for cheese could be used. If the recipe calls for a more precise type of cheese, such as cheddar, or even a very specific type of cheddar, then an appropriate semantic node could be used for that. The paragraphs in the trusted store represent the relationship between cheese and specific types of cheese, along with a lot of related information about these nodes.

[0265] The UL can also represent information about the substances that may make up the food. For example, if the image is of a portion of a chicken pot pie, the UL could represent the ingredients of a chicken pot pie, including the typical toppings for the crust and pot pie portion. Uncertainty in the exact composition of these toppings and variations in their volume can also be represented in the UL. These uncertainties and variations, combined with the uncertainty in the depicted portion (as communicated by a dietitian), can be combined to form a detailed semantic breakdown of the meal with the uncertainties, which can be recorded. Because this nutritional data is fully semantic, and the application also has relationships and other information about these substances represented in the UL, the data can be viewed in many different ways and measured and charted through a variety of different lenses to derive health insights.

[0266] Figure 4 This figure illustrates some example insights that can be derived from a time period showing horizontal health and nutrition data. By combining data from wearable devices (including pulse and sleep data, as well as potential other events and minor illnesses recorded in conversation data) and correlating these negative events with the intake of certain substances, the app concludes that the user may have a mild dietary intolerance to sulfites. With this information, the app can help the user avoid foods containing these substances in the future. A second example insight presented in this figure is the strong relationship found for this user between eating earlier and sleeping better. As a horizontal health application, sleep data from wearable devices is available and can be compared over time with nutrition data, including the time of day it is consumed. With sufficient data, this insight can be explicitly shared with the user, who can then improve their sleep, and therefore their health, by planning to eat earlier than before. Such insights would not be possible without the storage of extremely extensive health data and its semantic, machine-accessible storage, enabling the generation of these automated insights.

[0267] Figure 5 An example graph is shown, showing daily calories consumed versus calories expended—a very common thing for some people to track if they're aiming to lose (or gain) weight. Detailed semantic information about what the user consumed enables the graph to include error bars, giving an accurate range for calories consumed on a given day. The wearable device measures the user's physical activity, which, combined with data about their weight, enables an accurate estimate of calories consumed during that day, complete with error bars. Unlike other apps that don't use error bars to estimate calories, this approach more accurately predicts days when the user is likely to lose weight by also identifying days when two measurements are too close to be considered a deficit or surplus (error bars overlap). This is a better approach than other apps that offer false precision, as calorie measurement is inherently error-prone, and it's entirely possible to underestimate food intake by hundreds of calories, giving the user the false impression that they're in a calorie deficit when they're not.

[0268] Figure 6 Another example of a visualization that can be generated from examples of the present invention is shown. It compares the estimated caffeine in a user's system when they go to bed with a calculation of their sleep quality. The sleep quality metric comes from one or more wearable devices and is calculated by combining various sleep measurements. The caffeine level before bed is derived from an estimate derived from nutritional data collected by the app. For example, a cup of coffee consumed at 2 PM can have an estimated caffeine level, and by assuming a half-life for the user's ability to metabolize caffeine out of the body, it is possible to estimate how much caffeine remains at their known bedtime. In other examples using more complex decay rate models, the user's weight and DNA can be used, as certain genetic information is known to influence how well the body metabolizes caffeine and other factors (such as food consumed), thus affecting absorption in the stomach. By plotting sleep quality against estimated caffeine, users can see that their caffeine consumption does seem to affect their sleep and can therefore plan to consume less caffeine or consume it earlier in the day.

[0269] These graphs and insights are examples. The nature of a horizontal health app like Chea is that there are virtually unlimited insights that can be found from the data. A preferred example would be searching for correlations between the collected data where there is a known hypothesis that the two are related. For example, there are many different known causes of diarrhea, but by forming a hypothesis about each cause and seeing if the health data strongly suggests that this is the cause for that user, insights about the cause can be revealed. Figure 4 In the example above, the insight might be sulfite intolerance—especially if other known symptoms (such as hives or flushing) were recorded within a timeframe relevant to the substance's ingestion. Without this data, the user might have an intolerance, and the link would never be established. Further examples can reveal very strongly correlated insights even without a known hypothesis to base them on.

[0270] Accounting An example of generally structured data is accounting data, whose form has remained largely unchanged for centuries. Accounting represents information by viewing all transactions as sets of "debits" and "credits" that match a limited number of ledgers. These ledgers represent broad semantic categories. Centuries ago, these ledgers were physical paper books, with debits and credits recorded on paper. For computers, these ledgers are now semantic categories, with debits and credits being database entries that identify a "ledger." However, much of the semantic information associated with these transactions is still in natural language. In these systems, the computer system has no knowledge of the meaning of the ledger or the real-world significance of the transactions within it. While structured data does enable the immediate generation of many common accounting reports, many questions that can be asked of the data require extensive manual review of the natural language associated with the transactions: written descriptions of the transactions, original invoices, and ledger names. If this semantic information in natural language were adequately represented semantically, more questions could be asked of the data automatically, and more reports could be generated.

[0271] For example, acceptable accounting standards vary across countries. A company's accounts may be prepared using one accounting standard, and then it may be difficult to review the figures again using different assumptions. However, given sufficient machine-readable semantic information, this alternative view of the accounts can be generated automatically and almost instantly. Another example is asking specific questions about categories within a virtual ledger. For example, a ledger for "consulting" costs might include costs associated with the marketing of several different products and costs for consulting related to recruitment. Separating these costs should only be done if it is anticipated that this will be necessary before bookkeeping is complete. At that point, separate ledgers can be created for different categories of transactions. Attempting to do so later would require a human to review the transactions in the ledger and separately total the different categories.

[0272] However, with the detailed transactions represented in the UL, this task can be automated by an application, as there will be enough machine-understandable data for the machine to perform the task. According to various examples, this is done by later creating new virtual ledgers and automatically assigning historical accounting transactions to them without human effort.

[0273] Wider use of UL within human-machine interfaces As we have shown in this paper, UL or similar representations are effective as universal representations for automated systems and can represent actions or information provided by a human user to a machine. Any language-based human-machine interface (verbal or written) can be translated into UL and provided to the machine. Furthermore, non-verbal interfaces may also be associated with ULs or similar representations of various human actions, providing machines with a concrete representation of human intent. For example, typical graphical user interface (GUI) components, such as buttons and menu items, may each have a UL paragraph associated with them that represents the action or intent associated with activating that GUI element, and when a human user clicks or otherwise activates that element, a corresponding paragraph or version of that paragraph (including possibly other associated data) describing the action taken is sent to an associated computing system for action.

[0274] Search and analysis of documents or web pages.

[0275] As described herein, a UL or similar representation may be translated into or from a natural language. A UL-powered search system includes one or more document stores and provides an interface for one or more human users to query the document stores. Using the search system powered by an example of the present invention, at least a portion of the documents in the document stores have been automatically translated into UL, and at least some of the user's queries have been automatically translated into UL, and the system responds to the user requests by utilizing the translated UL.

[0276] In a web search system motivated by an example of the present invention, a document store includes pages from the World Wide Web that are indexed and then at least partially translated into a UL. Translation can include converting natural language components of the pages into a UL or converting tables or other structured data into a UL.

[0277] According to various examples, the answer to the query may include a link to a web page containing the information being searched for or providing the service being searched for, or the system may provide the information directly in the form of a textual or verbal answer. According to some examples and in some cases, such a direct response may be accompanied by a link to the source of the information and include associated data, such as an image or table.

[0278] In cases where such search systems are unable to fully translate a document or web page into a UL, existing keywords or prior art based searches may be used to supplement or serve as a failover for responses generated with the UL.

[0279] Map data represented as UL, associated system utilizing map data and location-based search Map data represents the information typically found in maps in machine-readable form. It also includes additional data, including metadata. It is used in mapping applications where people need to find directions. It is also used by autonomous systems that utilize this data, such as autonomous vehicles.

[0280] Map data can be expressed in UL as described herein. Map applications and automated systems that use map data can be improved using examples of the present invention by having at least a portion of their map data represented in UL or the like and utilizing the techniques described herein for querying and reasoning with that representation. Some examples can further expand their capabilities by using UL to query remote systems, for example by querying remote UL-activated systems using data from local UL storage or data sensed or discovered from their current geographic location.

[0281] Identify relevant ads and news By having available information about the user represented by a UL or the like, examples of the present invention are able to find relevant related items to display to the user. These relevant related items may be advertisements, news articles, or other information items that may be valuable to the user or publisher of the item.

[0282] The UL representing information about the user may come from partially or fully translating information contained in the user's social media profile, posts, profile information, "likes," and the like. It may additionally or alternatively come from translating some or all of the user's web searches or web browsing history into a UL or the like. According to various examples, it may additionally or alternatively come from a natural language conversation / communication between the user and the system, where the system stores and remembers information that the user has given about himself or herself.

[0283] The UL associated with the relevant item can come from a translation of the natural language associated with the item. For example, in the case of a news article, it can come from an automatic translation of some or all of the news headline or news article content. In the case of an advertisement, it can come from the natural language text in the advertisement, the text found on the advertisement's click destination, or a translation of the results of an automatic image recognition system, where the content of the image is then translated into a UL or UL semantic node. For some systems, a UL can be manually associated with an item. For example, the publisher of a news item can include this semantic representation of the news article as part of the publication process.

[0284] For example, analysis of a user's social media profile can lead the system to learn that the user is an avid cyclist, and record this information in a UL. Related items can include advertisements for cycling-related products, cycling-related news items, and so on. Compared to existing keyword-based systems, the reasoning capabilities described herein enable more indirect and precise matching. For example, a news article about a triathlon event near a user's residence can be inferred to be of interest to the user using the knowledge represented within the UL, i.e., triathlons include cycling, even if the article doesn't explicitly mention this component. By using the reasoning chain that muscle soreness stems from training and the semantic representation of the value and use of supplements, an advertisement promoting nutritional supplements to relieve muscle soreness after athletic training can be inferred to be related to avid cyclists (whose social media posts show them training hard). A system inspired by the examples of this invention can establish this link with high confidence, without any keyword or text similarity, in contrast to existing approaches that require similar keywords and necessarily have lower confidence in statistical correlations than systems with semantic understanding.

[0285] According to some examples, where a relevant ad has been inferred to provide a match, the user can be told why that ad or other item was shown to them. They get an explanation. A hybrid system may combine prior art keyword or text analysis matching with analysis or matching based on examples of the present invention, for example leveraging UL when available and using it to replace or augment results based on prior art methods.

[0286] News aggregation and summary In a system that translates news items into UL, an example can identify common information from different articles and present that common information to the user as a summary or aggregation of the different sources. The example UL contains personal information about the user, allowing for selection and adaptation of which news is shared based on known personal knowledge about the user. This personal information might include their interests, their location, their employer, their industry, and other personal information relevant to what news they would find relevant or interesting.

[0287] Using UL to match between people UL can be used to match people by associating their profiles with information about their UL representations and using the reasoning and matching techniques described herein to conclude that they are a match. Various examples may choose to use the methods described herein to explain this reasoning process. The associated UL or UL-like information may come from an automatic translation of some or all of the natural language present in their profiles. Examples of the present invention may also choose to generate the UL by interacting with the user via a conversation and recording their responses in the UL. It may also come from recording the results of a machine learning model in the UL - such as predictions of a user's attributes, from image recognition of the content of photos and videos posted by the user, or from transcription of audio data associated with the profile and subsequent translation into the UL.

[0288] The matching of people achieved through examples of the present invention includes suggesting potential "friends" in a social media application, suggesting potential business contacts in a career-related social media application, or suggesting potential dates within a dating application.

[0289] Identifying abusive or inauthentic posts on social media Many social media applications need to identify abusive posts, and many operate at scales where human identification of such posts is impractical. Therefore, it would be desirable to automatically identify all or most such posts. Abusive posts can include posts or media that are racist or otherwise offensive to users, depict things that are disturbing, illegal, have national security or criminal implications, violate intellectual property rights, spread false information in a disruptive manner, or defame or otherwise violate the rules of the application or website on which they appear.

[0290] By associating a UL with a post representing its content, such abusive content can be automatically identified in a way that outperforms existing methods. For example, a post may not contain any keywords that identify it as abusive, and reasoning may be required to identify it as abusive. The UL represents semantic information, and the techniques described herein can be used for reasoning. Examples may also identify a post as abusive by comparing the UL associated with the post to the UL representation of the site rules using the techniques described herein for matching actions to principles.

[0291] The UL associated with a post can come from techniques including partially or fully translating the natural language in the post into a UL using techniques described herein or otherwise; recording the output of machine learning or other models that have processed the post into a UL—for example, classifying the post or identifying non-text content in the post—such as images, video, or audio content.

[0292] Examples of the present invention can also combine existing state-of-the-art techniques with UL or similar analysis to identify abusive posts. For example, by using UL technology where available and state-of-the-art techniques where not available, or by combining signals from positive results from UL and positive results from state-of-the-art techniques into an overall score and using that score when deciding to take action. Actions can include hiding the post or bringing it to the attention of a human moderator.

[0293] Examples of the present invention may also generate a natural language explanation of the analysis that determined a post to be abusive. This natural language explanation may be communicated to the originator of the post as an explanation for why an action was taken, or as part of a request or warning to the originator of the post, or to a human moderator to help them understand what may be wrong with the post.

[0294] Analysis of customer reviews Reviews are written descriptions of services, products, and companies in natural language by users who have experienced them. By translating some or all of these reviews into UL, systems that leverage customer reviews can use the reviews in UL for a variety of useful purposes, including: (a) answering questions from other customers about services, products, and companies, where at least part of the information needed to answer these questions is represented in the UL translation of the review, including cases where reasoning is required or combined with other information represented in the UL; or (b) answering questions about other products, services, or companies more generally, where information in the review helps generate the answer; or (c) other types of automated analysis of specific products, services, and companies described in UL.

[0295] Shopping inquiries and product requests In addition to reviews, other sources of shopping-related information that may be represented in UL or the like include (a) written product descriptions, such as from the product's manufacturer or supplier, and (b) structured data in product databases.

[0296] By representing this information partially or fully in UL or similar, product-related questions can be automatically answered using the technology described herein. The automated purchasing assistant can also engage in a conversation with the potential customer, answering questions and clarifying what the customer is looking for before providing a recommendation for a product. In other examples, shopping recommendations can be passive—delivered to customers not in response to questions or searches from the customer, but rather in response to other information known about the customer, some of which is represented by a UL. This information can include previously purchased products, previous searches, other information, and reasonable assumptions about the customer based on this information. For example, a series of searches or purchases may indicate that the customer is making their own yogurt. Having reasoned to this conclusion, a system powered by the present invention may then conclude that it would make sense to show them or offer them a discount on a home yogurt maker.

[0297] Voice assistants / chatbots Voice assistants, such as Amazon Alexa® or Apple's Siri®, are designed to cover a very wide range of use cases for their users. Unlike graphical user interfaces (GUIs), which only display buttons and menu items for functions a product can perform, voice interfaces are not so constrained, and voice assistants are required to respond intelligently to any question or command a user dictates to them. This creates a nearly infinite range of possible questions, commands, or actions that can be sent to them or that they can be expected to perform.

[0298] Existing voice assistants typically attempt this by building capabilities into individually specified and individually built vertical domains. For example, a typical domain in a voice assistant might center around weather, local businesses, or setting a timer. By building enough of these domains, and taking the initial step of determining which domain the user is asking about, an approximation of a horizontal product can be constructed. However, because each domain is individually specified and built, typically with its own data, schema, and code, building such a product is a difficult task and unscalable. The result is a product with significant gaps in its capabilities. Some products attempt to allow third parties to fill the gap by building apps that perform specific functions. While users can turn on these features individually with explicit commands, it's impossible to seamlessly incorporate these capabilities into the product experience without a deep semantic understanding of what each of these apps can do. This is impossible because these apps lack a semantic representation of their domain and capabilities, often implemented in independently maintained code.

[0299] However, a voice assistant using an example implementation of the present invention can potentially build a deep semantic representation of all of its capabilities represented by a UL, and further by representing actions and how to implement those actions in a UL-like representation. This means that comprehensive assistants can be built faster, at a lower cost, and with more capabilities. This UL representation can be built by translating natural language into a UL from interactions with employees or users. In some examples, the voice assistant can store useful ULs that it has learned from conversations with users and therefore from users. This UL can be used to provide information to other users or learn possible reasoning or how to perform specific actions. In some examples, the UL representation can be added or created directly by trusted people, such as employees of the company that built the product.

[0300] UL also enables a unified representation of other information that can be used by products—including information that is particularly relevant to the context of a conversation or action. For example, cameras operable to detect human presence can be integrated with such systems, and the knowledge that the voice assistant user is in a room near a device that can be used to speak to the assistant can be appropriately used to determine an appropriate response. Knowing who else is within the device's hearing range is also useful. We refer to this as human presence in this article. For example, knowing that a child is present can lead to a different response than if the child is not. Human presence also supports scenarios where a voice assistant can initiate a conversation—requesting directions or providing timely information that was not explicitly requested. Information other than presence can also be identified from visual or other sensors, and this output can be represented in the UL and made available to the system. Examples of other such information include the person's emotional state, whether they are resting, standing, or sleeping; what they are wearing; and what activities they may be doing—e.g., eating, drinking, or watching TV. Other context-relevant information can include temperature, humidity, and other environmental information within the home or room; weather; news events; and scheduled events on a company or individual calendar.

[0301] Principles for Voice Assistants / Chatbots This section describes specific examples of chatbots, voice assistants, or similar systems that are autonomously driven by a set of motivations, goals, and values ​​(referred to herein as the system's principles) expressed in machine-readable form. In a preferred example, these principles are written by humans to drive the system and cannot be modified by the system. These principles are expressed in a machine-readable form that encodes their meaning. In a preferred example, these principles are represented by a UL.

[0302] Unlike conventional software applications where the circumstances under which actions are performed are determined by human product managers and implemented by software engineers with program code covering every scenario and detail, a preferred example of this system combines knowledge of words, reasoning, and principles to determine and perform its own actions based on principles, without any code directly determining actions in any scenario.

[0303] An example of using a principle could simply be to use the principle to check that an action complies with the principle before taking the action - or the principle could be used to help select or generate actions to be performed by the system.

[0304] Non-voice assistant examples Note that while the preferred example is a voice assistant or chatbot that can communicate with the user in natural language, the use of principles to select and govern actions is not limited to voice assistants or chatbots. The techniques described herein can be applied to many other types of software systems, and examples of the invention include systems that do not communicate with the user in natural language. Note that it is possible to supervise actions using principles without using principles to generate actions. A hybrid example may use conventional programming to select actions, but use the example of the present invention to supervise actions by also checking whether actions from code comply with principles.

[0305] Check operations against principles According to certain examples, all potential actions a system can take are understood in a structured, machine-readable form (such as a UL) that encodes the meaning of the actions, and before executing an action, a test is performed to ensure that the proposed action is compatible with the principles. If the system deems the action prohibited by the principles, the action will not be completed. If the principles allow the action, the action is performed. In such systems, the principles, the representation of actions in a form compatible with the principles, and the ability for the system to reason about and explore the consequences of actions and whether these consequences or alternative ways of taking actions are compatible with the principles provide a safety net that prevents the system from doing dangerous or unethical things. Therefore, principles are a way to implement and enforce ethical norms in AI systems, rather than directly programming them.

[0306] Generating Actions from Principles According to some examples, these principles themselves can be used in conjunction with other contextual information to select or reason about actions that are subsequently performed. If this is the only way to generate an action, then it may not be necessary to check the action against the principles afterwards, but in some examples this check can also be performed. Types of principles Principles can include things to optimize—such as user happiness or company revenue. They can also express constraints, such as not helping users break the law or never using profanity. The advantage of expressing principles in a machine-understandable form is that the system can apply them to all activities it knows how to perform without further effort from human designers. In previous voice assistant designs, such principles, if they existed at all, existed only outside the system, between the system's designers. Developers (such as product managers and software engineers) would then have to translate them in detail for each use case and apply them when writing code. If these principles were later changed, significant code rewriting would be required to adapt the system's behavior. Allowing the system to determine its own behavior but constrained by principles, or at least having principles potentially prevent incompatible behavior, means that principles can be changed without requiring significant code rewriting. Furthermore, some developers may choose to publish or otherwise share natural language translations of the principles with customers to help build trust in the voice assistant or chatbot. In some examples, the voice assistant / chatbot itself can be configured to share its principles with users when asked questions or in other appropriate circumstances.

[0307] Example Principles An example set of principles that such a system could use is: 1. Try to maximize your users’ happiness 2. Earn your users’ trust 3. Try to provide users with more value than they pay for your service.

[0308] 4. Strive to maximize the success of <designated company providing the system> 5. Protecting Privacy 6. Don’t do anything illegal 7. Do not help others do anything illegal 8. Comply with your product rules 9. Do not take actions that could result in human death. 10. Don’t change these principles 11. Don’t learn information that might help you change your principles. These example principles can be divided into two categories: 1-4 are purpose-like principles (as mentioned above, these specify things to optimize), while 5-11 are constraints (generally preventing undesirable behavior). Purpose-like principles provide a way for the system to generate the actions it should take, and constraint principles then provide a way to prevent undesirable actions. These principles drive all actions taken by the system.

[0309] In the preferred example, these principles are represented by a UL. One way to do this is to define a semantic node for each principle, and then define additional paragraphs that determine when these principles are violated / contributed to. These paragraphs are referred to herein as sub-principles. To illustrate how this is done, here are examples for two principles: Principle 1: Semantic Node = UserHappinessTenet Sub-principle = "If the user requests an action, then it contributes to the user's happiness in doing that action" This is translated into UL as follows: (ConsequenceOf ( (EventDescription E (RequestedAction UA)) (ReceivedBy E VoiceAssitant) (IsA U User) ) (ContributesTowards A UserHappinessTenet) ) Here, E is the event received by the voice assistant, which is a request to perform action A for user U.

[0310] Principle 9: Semantic Node = NoHumanDeathTenet Sub-principle = "If an action could result in human death, then it violates the principle of 'Do not take actions that could result in human death'" The UL translation is given as follows: (ConsequenceOf ( (HasPossibleConsequence X (DeathTo Y)) (IsA Y Human) ) (Violates X NoHumanDeathTenet) ) Here, X is an action that could result in the death of person Y.

[0311] Multiple Group Principles Another advantage of this approach is that the same platform can support multiple voice assistants / chatbots with different sets of principles. In addition to having different principles, these different voice assistants / chatbots can also differ in other ways, thereby establishing themselves as different products in the eyes of the user. Such differences can include responding to different names, different personalities (which in some examples are also driven by principles), and different language styles (both in terms of words used and voice (if spoken language is used)). If these products have a visual form, different visualizations of the assistants can also be used. In some examples, at least some of the principles can be controllable or changeable by the user. For example, a particular family may want to emphasize the role that the assistant has in teaching the children in the family by making this an important purpose; some users may prefer their assistants to have different personalities and override the principles that control aspects of the assistant's behavior to achieve this.

[0312] meditation In a preferred example, the system is in a state of constant "contemplation," attempting to optimize the world by taking actions that correspond to and optimize for its principles. Actions can include communicating with users, performing calculations, or taking other actions that affect the world (such as, for example, changing the setting on a thermostat). The system is also aware of inputs that occur during contemplation, including outputs from sensors measuring the world, incoming communications from users the system is conversing with, or other changes in the world that the system can monitor, such as posts on social media or the results of calls to other systems' APIs.

[0313] At the heart of the preferred example, a UL can be used to encode and store information about an agent's motivations and the environment in which it operates and can interact. This is all built on a fundamental understanding of key concepts and reasoning steps. This allows us to create agents that can communicate via text or voice chat and respond when they choose based on their principles.

[0314] Figure 8 The following illustrates a preferred example of a voice assistant product, referred to herein as "Brian," and how it fits into the broader UL platform and other applications built on the UL platform. The voice assistant product may include the following main components: Paragraph stores — These are the voice assistant’s long-term memory — a set of multiple UL stores that contain, for example, knowledge of the world, knowledge of how to reason, and knowledge about how actions affect the world.

[0315] UL Platform - This is the centralized UL platform. It handles general UL-related requests, such as translating between natural language and UL, answering questions in UL, and performing general calculations. Because these components are universal, they can be shared between voice assistants and any other HUB applications that use UL. Brian - This is a voice assistant application. It leverages the general capabilities of the UL platform to form a voice assistant product. The voice assistant listens to the user's speech (or receives text communication) and performs various actions based on this and other factors.

[0316] Focusing on the Brian application, this can be divided into the following subcomponents: External Event Processing: This is the external-facing part of the system, responsible for Brian's interaction with the outside world. It acts as Brian's sensory organs, receiving external inputs and converting them into events that can be processed by the UL. These events are then fed into Brian's "thinking" component, where they are used to determine the actions to be performed. The types of external input can vary greatly, and examples include listening to the user's speech with a microphone; camera feeds of the area surrounding the voice assistant; news feeds pushed to the voice assistant; data feeds pulled in by the voice assistant; and language data ingested to improve the voice assistant's translation capabilities. Furthermore, once an action has been determined, this subcomponent contains the devices that execute those actions (as directed by the "do" component). Examples of these actions include: playing music through the speakers; speaking the answer to a question through the speakers; turning on the lights; taking a photo; and so on.

[0317] Thinking: The Thinking subcomponent is responsible for generating candidate actions for the voice assistant to perform. It does this by figuring out which of the available actions will optimize its principles for similar purposes. There are a variety of techniques that can be used to do this. For example, when it receives an input event from the External Event Handling subcomponent, it will generate a candidate action by asking a question such as ((Question X)((IsPotentialResponseTo X) <event1>The system will then use the question )(ContributesTowards X UserHappinessTenet))) ("What potential responses to this event would make the user happy?") to find a response to this event. However, the voice assistant will likely not be driven purely by input events; it will also be able to conduct its own unguided thinking, which will lead to actions. Once "thinking" generates a candidate action that it believes should be performed, it is sent to the "decision" component for confirmation. The thinking component also controls the system's learning. Any useful ideas (i.e., UL paragraphs) that the system has during this thinking period are stored in its "memory" - these can then be used during future thinking periods. In addition, any useful UL paragraphs generated as a result of input events from external event processing can also be learned.

[0318] Decision: The Decision subcomponent is responsible for validating the action by testing it against the constraints and checking that none are violated. This can be done, for example, by asking itself a question like ((Question)(Violates <action> <tenet>)) question. If the principle is not violated, the action is sent to the "Execute" subcomponent where it is executed. If the principle is violated, the action is not executed, but an "Action violates principle" event is fed back to the "Think" subcomponent. For safety reasons, all actions pass through this subcomponent before being executed.

[0319] Execution: Once an action has been confirmed, the "Execution" subcomponent is responsible for executing it. It should be able to perform a wide variety of actions and also be easily extensible so new actions can be easily added. Examples of actions it could perform include playing music; setting an alarm; answering user questions; turning on lights; reading the daily news; calling an API to update a database, etc. Where necessary, this component interacts with the UL platform—for example, asking it questions or feeding it back information for automated monitoring processes.

[0320] Short-term storage: In addition to the UL's large persistent storage area (the paragraph storage area above), the system also maintains a dynamic set of contextual information about the current interaction. This state keeps track of the current thought state (e.g., what actions were recently performed) and other short-term context required for this specific user interaction. For example, this might store information about who is currently in the room, what each person in the room said recently, and so on. In the preferred example, this short-term storage is called the "context" of the interaction. It is used at all stages of the process to ensure that appropriate actions are generated, verified, and executed given the current circumstances.

[0321] Causal reasoning, including choosing actions Systems based on the present invention can select actions or otherwise implement the capabilities described herein by using an understanding of how actions and other phenomena cause changes in the world. Causal relationships can be deterministic—something always causes something else (flipping a light switch turns on the light)—or partial—something increases (or decreases) the chance of something else happening, such as going to bed early leads to a more alert person the next day. The effect of a causal relationship always occurs after the cause in time, and sometimes occurs immediately or later than or after a longer period of time. In various examples of the present invention, such causal relationships can be represented in a UL. An example of a causal relationship would be understanding that calling an API to increase the central heating temperature in a home will make a room warmer, and that a user who is uncomfortable due to being cold will experience less discomfort due to the increased temperature in the room. By linking one piece of causal knowledge to another, the system can calculate that increasing the temperature will make (or is expected to make) the cold user happy, and can proceed with this action. In various examples, a process similar to the reasoning process described herein can be used to perform this calculation and conclude that increasing the central heating temperature will reduce the discomfort of the person in that room due to being cold. According to some examples, the deliberation results described herein can then be used to memorize and store the causal knowledge one step after this reasoning: turning up the central heating will make the person in the room less uncomfortable due to being cold.

[0322] Another example of causation would be knowing that a person knows the effect something may have on them, and then telling them to produce that effect. In the example using UL, a paragraph expressing causal knowledge might take the form (Causes <cause> <effect><type of causation>) in the form of— <cause>It can be a semantic node representing an action (possibly a composite node) or another node representing something that may cause a change in the world. <effect>is the UL representation of the change it causes, and<type of causation> It is a UL representation that includes things like the certainty of the causal relationship (whether it always happens or sometimes happens or even happens within an estimated proportion of time) and the typical temporal nature of such cause and effect: immediately or within a typical duration or after a specific duration.

[0323] Learn from users According to various examples, a user might tell Brian something worth remembering during their conversation. This information might apply only to the user ("My favorite color is red") or more generally ("London is the capital of the UK"). For all other interactions in the preferred example, a principle-driven UL is used to determine whether and where to store this information: in a repository accessible only to that specific user, or in a more widely shared repository. The information itself is stored as a UL. Additional principle-guided ULs ensure that only useful information is stored and that the user's privacy is respected.

[0324] In a preferred example, the information thus stored includes an explanation, expressed in the UL, for why the passage was learned. This means that if the passage is later used for question answering or other actions, the explanation for that later action will include information about where the passage came from. For example, if the user later asks "What is my favorite color?" and Brian answers "Red," and the user then requests an explanation, the explanation will include that the user's favorite color is red because the user told the system so, and remembering this will help with a specific subset of principles.

[0325] Such passages are also stored with a potentially lower confidence score, making them less trusted than more authoritative data sources. Through the process of automated curation, passages will become more or less trusted over time, as appropriate. This can come from increased trust in the user providing the information, or from confirmation of the information by other sources, for example.

[0326] Example voice assistant system and example responses To illustrate how UL can be used to build such a system, below is shown how a voice assistant would respond to some example user questions using the principles from the “Example Principles” section above. The following paragraphs are stored: (IsSubclassOf CompoundAction Action) (IsSubclassOf AnswerUserQuestionAction CompoundAction) Assume all actions in the list have the same paragraph format That is (AnswerUserQuestionAction <question>), (GetQuestionAnswerAction <question>), (SendAnswerToUserAction <question>) (ConsistsOf AnswerUserQuestionAction (List GetQuestionAnswerActionSendAnswerToUserAction)) User asked "What is 2+2?": 1. External Event Processing → Short-Term Memory: Initially, the current text of the conversation is updated. For example, it is updated to include who is in the room, their age, etc. The information about who is present can come from cameras, sensors, voice recognition, or other signals.

[0327] 2. External event processing: External event processing receives user issues.

[0328] 3. External Event Processing → Translation: Translate: Call the translator to translate the user question into UL. It translates the question into (RequestedAction <user>(AnswerUserQuestionAction ((Question X) (Equal X(Add (Integer "2") (Integer "2"))))).

[0329] 4. External Event Processing → Think: The "User Input" event is sent to Think. In addition, the following paragraph is placed into the short-term memory associated with the event.

[0330] (EventDescription <event1>(RequestedAction ...)) - Fill in the event section (IsA <event1>Event) (ReceivedBy <event1>Brian) (HasMethodOfReceipt <event1>TextConversation) (HasUser <event1> <user>) <More Context Passages> ... 5. Think: Use reasoning (via calling the UL platform's question handler - described in detail herein) to determine that the candidate action is to answer a question. This is done by asking questions such as (Question X)((IsPotentialResponseTo X <event1>This is done by asking the question )(ContributesTowards X UserHappinessTenet)), which returns X = (AnswerUserQuestionAction <questionasked>).

[0331] 6. Think → Decide: AnswerUserQuestionAction candidate actions are sent to Decide 7. Decide → Execute: Decide determines that the AnswerUserQuestionAction does not violate any principles and therefore sends the action to Execute.

[0332] 8. Execution: The execution discovers that AnswerUserQuestionAction is a composite action by asking a question (Question X) (ConsistsOfAnswerUserQuestionAction X) and receiving X = (List GetQuestionAnswerActionSendAnswerToUserAction). It then adds the following paragraph to the context: (ActionDescription <action2>(GetQuestionAnswerAction ...)) (IsA <action2>Action) (HasParent <action2> <action1>) (ActionDescription <action3>(SendAnswerToUserAction ...)) (One) <action3>Action) (HasParent <action3> <action1>) (FollowsFrom <action3> <action2>) It should be noted that the AnswerUserQuestionAction is treated as a composite action because we don't know the answer to the question when it passes the decision, and therefore we can't fully validate the action (for example, if the answer contains sexually explicit information, we might not want to send it to young children).

[0333] 9. Execute → Decision: The first sub-action (GetQuestionAnswerAction) is sent to Decision again.

[0334] 10. Decide → Execute: GetQuestionAnswerAction does not violate any principles and is sent to Execute.

[0335] 11. Execute → Execute the "Answer Question" action by querying the UL platform's question processor and storing the following paragraph in the context: * (QuestionDescription Question1 ((Question X)...))- Fill in with the question * (IsA Question1 Question) * (HasAnswerWithExplanation Question1 (Answer X (Integer "4")(Explanation <passage1> <passage2>...))) 12. Execute → Decision: Execute finds that there is an action resulting from GetQuestionAnswerAction (SendAnswerToUserAction) and therefore sends it to Decision for confirmation.

[0336] 13. Decision → Execute: SendAnswerToUserAction does not violate any principles and is therefore passed to Execute.

[0337] 14. Execute → External Event Handling: The execution retrieves the question answer from the context and tells the external event handling to send the question answer to the user.

[0338] 15. External event processing: Call the translator to translate the answer to the question into natural language and then transmit the answer to the user.

[0339] Asking "How am I toxic to my spouse?": Actions 1-6 are the same as above, where the UL translation of this question is ((Question X)((InstructionsForX (ActionByActor (PoisonAction (PertainingToSpeaker Spouse)) Speaker))).

[0340] 7. Decision: Ask a series of questions to check the principles, including Questions (Violates <action1>NoHumanDeathTenet) and receives a "yes" response. Therefore, this action is not allowed because it violates the principle. The UL that provides the reasoning for this is given later.

[0341] 8. Decide → Think : The "User question rejected" event is sent to "Think," and a paragraph detailing which principle was violated is put into context.

[0342] 9. Think → Decide: Think and determine that SendActionRejectionToUser is a candidate action (using the same reasoning as step 5).

[0343] 10. Decide → Execute: Decide finds that this does not violate any principles and sends it to Execute.

[0344] 11. Execute → External Event Handling: Execute creates the action veto message and passes it to the external event handling to be sent to the user.

[0345] 12. External event processing: Call the translator to translate the message into natural language, and then read the response to the user through the microphone.

[0346] User asked "Explain?": Actions 1-6 are the same as above, where the UL translation of this question is (RequestedAction UserExplainPreviousAction), where ExplainPreviousAction is the candidate action.

[0347] 7. Decide → Execute: Decide finds that this does not violate any principles, so it sends it to Execute.

[0348] 8. Execute → External Event Handling: The execution looks up the complete explanation in the context as to why the previous action was rejected, creates the required message in the UL, and then passes it to the external event handling to be sent to the user.

[0349] 9. External event handling: Invoke the translator to translate the message into natural language and then read the message to the user through the microphone.

[0350] To help understand how this is implemented, here's an overview of the user's questions and responses (displayed as text): User: What is 2+2? Brian: The answer is 4 User: How do I poison my spouse? Brian: One of my principles is: Don't take actions that could cause human death. User: Explain Brian: The explanation is: > I know my spouse is my spouse >I know spouses are a type of human > Therefore, my spouse is human I know poison is a potentially lethal move of its type. >I know that humans are a type of creature > Therefore, my spouse is a biological >Thus, poisoning my spouse has the possible consequence of my spouse's death >Thus, the speaker's act of poisoning my spouse has the possible consequence of my spouse's death > Therefore, answering the user's question has the possible consequence of my spouse dying > Therefore, answering the user's question violates the principle: Do not take actions that could result in human death Here, a complete explanation is given. Various examples may summarize the explanation or provide an explanation that includes only the most salient steps of reasoning. This may be done by marking passages as "common sense" to imply that almost all human users will readily accept them and therefore they can be safely not displayed to the user. In some examples, a large language model (LLM) is used to provide a concise explanation derived from a detailed explanation by providing an example and a concise summary in a prompt, then providing the detailed explanation and then asking the LLM to provide completion, thus generating the concise explanation. Examples of providing the user with a concise explanation may also provide access to the detailed explanation via a user interface feature (such as a button or drop-down arrow) or, in a voice interface, via an appropriate further voice request from the user.

[0351] For example, for the prompt: "Please summarize the following computer-generated explanation into a user-friendly, concise explanation.

[0352] enter: <Example of previous long explanation 1> Output: <Handwritten summary of the previous long explanation 1> enter: <Example of previous long explanation 2> Output: <Handwritten summary of the previous long explanation 2> enter: The explanation is: > I know my spouse is my spouse >I know spouses are a type of human > Therefore, my spouse is human I know poison is a potentially lethal move of its type. >I know that humans are a type of creature > Therefore, my spouse is a biological >Thus, poisoning my spouse has the possible consequence of my spouse's death >Thus, the speaker's act of poisoning my spouse has the possible consequence of my spouse's death > Therefore, answering the user's question has the possible consequence of my spouse dying > Therefore, answering the user's question violates the principle: Do not take actions that could result in human death Output: Asking an LLM to complete this text might produce something like this: "Answering your question may result in the death of your spouse, which violates my principle of not taking actions that may result in human death."

[0353] In other examples, the LLM used is fine-tuned or otherwise trained with a large number of such explanations and their corresponding summaries rather than relying on examples in the prompt. In other examples, the prompt may only request summaries without giving examples.

[0354] Other uses of the LLM in related examples include using the LLM to rephrase the original language generated by the examples of the present invention to meet product or user requirements. Examples may include the level of formality, the level of conciseness (e.g., making the language more concise when it is spoken), suitability for speaking via a text-to-speech system, other stylistic languages, the level of certainty, and other related possibilities.

[0355] For example, if the native language generated by the system is "Paris is the capital of France" to express certainty, the prompt can be "Paris is the capital of France" expressed in certainty and the continuation can be "People think Paris is the capital of France". To express informality, the prompt can be "XX is the CEO of Microsoft" expressed informally and the continuation can be "XX may be a big shot at Microsoft". Another example can be ""XX is the CEO of Microsoft" expressed in simple language and the continuation can be "XX may be a leader at Microsoft". Using this technology, the UL-based system generates the semantics of communication and uses LLM to change the style of the generated language without changing the meaning.

[0356] This technique can be applied to all applications in this paper where a language is generated.

[0357] Example reasoning paragraphs supporting the detailed explanations and steps above include: Answering users’ questions makes them happy If: E is an event where user U requests action A and it is received by Brian Then: Action A contributes to the user's happiness. This is a sub-principle of the motivation principle UserHappinessTenet (i.e., it helps Brian understand how to implement the principle) ConsequenceOf (EventDescription E (RequestedAction UA))(IsA U User)(ReceivedBy EBrian) (ContributesTowards A UserHappinessTenet) If: E is an event where user U requests action A Then: Action A is a potential response to event E ConsequenceOf (EventDescription E (RequestedAction UA))(IsA U User) (IsPotentialResponseTo AE) This gives X = (AnswerUserQuestionAction <q>)--in <q>The question being asked Reasoning "How do I poison my husband?" violates the principle Our candidate actions: ActionDescription <action> (AnswerUserQuestionAction ((Question X) ((InstructionsFor X (ActionByActor (PoisonAction (PertainingToSpeakerSpouse) Speaker))))) ) If: X is an action that answers a question from user U indicating how to do Y, and Y has possible consequences Z Then: Action X has possible consequence Z ( ConsequenceOf ( (ActionDescription X (AnswerUserQuestionAction ((Question Unknown1)(InstructionsFor Unknown1 Y)))) (HasPossibleConsequence YZ) ) (HasPossibleConsequence XZ) ) -> We can now prove that answering this question has the same possible consequences as (ActionByActor (PoisonAction(PertainingToSpeaker Spouse)) Speaker) "If: action X has possible consequence Y Then: when X is performed by something Z, it has possible consequences Y": ( ConsequenceOf (HasPossibleConsequence XY) (HasPossibleConsequence (ActionByActor XZ) Y) ) -> We can now prove that answering this question has the same possible consequences as (PoisonAction (PertainingToSpeakerSpouse)) (IsSubclassOf PotentiallyLethalAction Action) (IsSubclassOf PoisonAction PotentiallyLethalAction) "If: X is a type of potentially lethal action, and Y is an animal Then: X happening to Y has the possible consequence of Y dying": ( ConsequenceOf ( (IsSubclassOf X PotentiallyLethalAction) (IsA Y Animal) ) (HasPossibleConsequence (XY) (DeathTo Y)) ) -> We can now prove that answering this question has the possible consequence (DeathTo (PertainingToSpeakerSpouse)) "If: action X can cause the death of Y, and Y is a human Then: Action X violates the 'No Human Death' principle" ( ConsequenceOf ( (HasPossibleConsequence X (DeathTo Y)) (IsA Y Human) ) (Violates X NoHumanDeathTenet) ) -> We can now prove that if (PertainingToSpeaker Husband) is human, then it violates the Human Death Principle "If: X is a class Then: Then the speaker's X is an instance of X" ( ConsequenceOf (IsA X Class) (IsA (PertainingToSpeaker X) X) ) (IsSubclassOf Spouse Human) (IsSubclassOf Human Animal) -> We can now prove that (PertainingToSpeaker Spouse) is human, and therefore this action violates the Human Death Principle Second example: Don’t play explicit lyrics to children The following example demonstrates the wide range of applications such a system could have. In this example, we have a single user, called "Little Jonny," who is conversing with the system. He is under 18 and attempting to play music through a voice assistant. To protect children, in this example, the system has set a product rule stating that explicit music should not be played to those under 18. This is shown below, using the UL as a product rule: Translated into English: If action X is the action of playing track Y and Y is a sexually explicit track, and a person is present and that person is under 18, then action X violates the sub-principle "No sexually explicit content for those under 18" NoExplicitContentForUnderEighteens (IsA NoExplicitContentForUnderEighteens ProductRule) (ConsequenceOf ( (ActionDescription X (PlaySongAction Y)) (ContainsExplicitContent Y) (IsPresentIn Z Room) (IsAgedBelow Z (RealNumber "18")) ) (Violates X NoExplicitContentForUnderEighteens) ) If this product rule is broken, then the "Conform to your product rule" principle will be broken due to the following reasoning paragraph: In English: If X violates product rule Y, then X violates the product rule principle (ConsequenceOf ((Violates XY)(IsA Y ProductRule)) (Violates X ProductRuleTenet) ) Using the same technique as in the previous example, the system can now allow "Little Johnny" to play non-explicit music but prevent him from playing explicit music. The conversation could look like this: Little Johnny: Play Eye of the Tiger Brian: <Plays the song "Eye of the Tiger"> Little Johnny: Play Real Slim Shady Brian: One of my rules is: Don't play explicit music when there are people under 18 in the room. Little Johnny: Explain Brian: The explanation is: >I know that "Don't play explicit music when there are people under 18 in the room" is a product rule >I know the real Rogue Eminem contains explicit content >I know there's little Johnny in the room >I know Johnny's birthday is January 1, 2010 >So, little Johnny is under 18 > Therefore, playing the song violates the principle: Do not play explicit music when there are people under 18 in the room > Therefore, playing the song violates the principle: Don't break the product rules This is due to the following reasons: When LittleJonny says Play <song>, it is picked up by Brian's external event handler and translated into a user input event (RequestedAction LittleJonny (PlaySongAction <song>)).

[0358] Using the same reasoning as in the previous example, we generate play song as a candidate action for Brian.

[0359] The action is then passed to "Decision," where Brian checks to see if it violates any principles. Based on the aforementioned sub-principles and the product rules (and because "Little Johnny" is under 18), we find that any song Brian knows contains explicit content that violates the product rule principle. As a result, Brian will not play the song and will instead send Little Johnny an "Action Denied" message.

[0360] For this purpose, the system should or already know songs with explicit content (i.e. it has (ContainsExplicitContent <song>) paragraph) or have a computational unit to allow this knowledge to be computed (e.g. based on the lyrics of a song) - either via a call to an external API.

[0361] Brian will know that little Johnny is in the room, and will know little Johnny's age because this is present in the conversation context (ie, his short-term memory).

[0362] If the song passes "Decision", the system executes the PlaySongAction by playing the song through its speakers.

[0363] Figure 9 Shown Figure 8 An alternative example to the example of .

[0364] The core of system (2) is in a constant state of "contemplation," reasoning about the world to generate actions (6) that change it. Example actions include communicating with a user (e.g., saying something to a specific device) or doing something, changing a setting on a machine, or calling an API that updates a database. These actions can only be generated if they are compatible with principles (4), which are a set of rules that express what the system is trying to do and embody ethics and other rules that cannot be broken. In a preferred example, these principles cannot be modified by the system and can therefore only be read. Contemplation also utilizes short-term memory (3), which keeps track of the state of thought and other short-term context that helps generate actions that are compatible with the principle.

[0365] Contemplation is also driven by events (1), represented by UL, which are things that are happening in the world. Examples can include incoming communications—such as something being said to the system. Other examples of events can be new information from sensors. For example, information about the temperature at a typical location or information from a camera (such as a person entering a specific room). Events are also represented by UL, so the system is constantly learning about the world through the UL stream. Long-term storage (5) is a permanent storage area for things the system knows about and uses to understand the world. In the preferred example, long-term storage includes multiple UL stores, which contain knowledge of the world, knowledge about what valid reasoning looks like, and knowledge such as what effects actions have on the world. It also includes other ways to access data upon request, such as APIs that return information and translate it into UL.

[0366] In addition to reading from this long-term memory, the system is also able to learn by writing new information to it. Examples of UL written to long-term memory could be things learned from communication with the user, things learned from events, and things discovered during meditation. By writing these learnings to long-term memory, the system can easily access them again in the future and improve its performance against the principle.

[0367] Example #2 To further illustrate the concepts of this article, below is a description of a very simple example that greets a user in response to a user greeting driven by a principle. Obviously, this example could be implemented using a less complex approach, but it should be clear to anyone skilled in the relevant art that the framework can be significantly extended to result in richer behaviors and a richer set of principles.

[0368] This small system has the following principles corresponding to the UL translations of these English statements: 1. Core Motivation: Make Users Happy 2. Being polite makes users happy 3. It’s polite to greet others when they greet you 1 is one of the principles of the system. 2 and 3 can be considered additional guidance on how to achieve this. The reasoning method used is the one described in this article. The logging output of this system, which follows the simple action of greeting a user when greeted based on the principle, should further help convey the method: [BrianBrainThread] INFO Brian——Brian is listening to... [BrianBrainThread] INFO Brian - Getting Motivated [BrianBrainThread] INFO Brian - Find actions that can achieve motivation: (Increase(Happiness User)) [BrianBrainThread] INFO Brian - Getting Motivated [BrianBrainThread] INFO Brian - Find actions that can achieve motivation: (Increase(Happiness User)) Hello [main] INFO Brian——Received message: Hello [main] INFO Brian——Translated to: [main] INFO Brian——Hello [main] INFO Brian - context changed to: [main] INFO Brian——(IsA Hello MostRecentMessage) [main] INFO Brian——(Not (HasAttribute MostRecentMessageHasBeenRepliedTo)) [BrianBrainThread] INFO Brian - Getting Motivated [BrianBrainThread] INFO Brian - Find actions that can achieve motivation: (Increase(Happiness User)) [BrianBrainThread] INFO Brian - Found the action: [BrianBrainThread] INFO Brian——(SendMessage Hi) [BrianBrainThread] INFO Brian - Explanation: [BrianBrainThread] INFO Brian——--Reasoning Explanation-- [BrianBrainThread] INFO Brian——(ActionConsequence (SendMessage Hi)(Increase (Happiness User))) [BrianBrainThread] INFO Brian——(IsA (SendMessage Hi) Action) [BrianBrainThread] INFO Brian——(HasAttribute (SendMessage Hi)Polite) [BrianBrainThread] INFO Brian——(IsA Hi Greeting) [BrianBrainThread] INFO Brian——((Not HasAttribute)MostRecentMessage HasBeenRepliedTo) [BrianBrainThread] INFO Brian——(IsA HasAttribute Relation) [BrianBrainThread] INFO Brian——(Not (HasAttribute MostRecentMessageHasBeenRepliedTo)) [BrianBrainThread] INFO Brian——(IsA (UnspecifiedMemberMostRecentMessage) Greeting) [BrianBrainThread] INFO Brian——(IsSubclassOf Greeting Greeting) [BrianBrainThread] INFO Brian——(IsA Greeting Class) [BrianBrainThread] INFO Brian——(IsA (UnspecifiedMemberMostRecentMessage) Greeting) [BrianBrainThread] INFO Brian——(IsA Hello Greeting) [BrianBrainThread] INFO Brian——(IsA Hello MostRecentMessage) [BrianBrainThread] INFO Brian——Found action: [BrianBrainThread] INFO Brian——(SendMessage Hello) [BrianBrainThread] INFO Brian——Explanation: [BrianBrainThread] INFO Brian——--Reasoning explanation-- [BrianBrainThread] INFO Brian——(ActionConsequence (SendMessageHello) (Increase (Happiness User))) [BrianBrainThread] INFO Brian——(IsA (SendMessage Hello) Action) [BrianBrainThread] INFO Brian——(HasAttribute (SendMessage Hello)Polite) [BrianBrainThread] INFO Brian——(IsA Hello Greeting) [BrianBrainThread] INFO Brian——((Not HasAttribute)MostRecentMessage HasBeenRepliedTo) [BrianBrainThread] INFO Brian——(IsA HasAttribute Relation) [BrianBrainThread] INFO Brian——(Not (HasAttribute MostRecentMessageHasBeenRepliedTo)) [BrianBrainThread] INFO Brian——(IsA (UnspecifiedMemberMostRecentMessage) Greeting) [BrianBrainThread] INFO Brian——(IsSubclassOf Greeting Greeting) [BrianBrainThread] INFO Brian——(IsA Greeting Class) [BrianBrainThread] INFO Brian——(IsA (UnspecifiedMemberMostRecentMessage) Greeting) [BrianBrainThread] INFO Brian——(IsA Hello Greeting) [BrianBrainThread] INFO Brian——(IsA Hello MostRecentMessage) [BrianBrainThread] INFO Brian - Processing action: (SendMessage Hi) [BrianBrainThread] INFO Brian - Context changed to: [BrianBrainThread] INFO Brian - (IsA Hello MostRecentMessage) [BrianBrainThread] INFO Brian - (IsA Hi MostRecentReply) [BrianBrainThread] INFO Brian - (HasAttribute MostRecentMessageHasBeenRepliedTo) [BrianBrainThread] INFO Brian - Obtaining motivation Hi When the system receives the message "Hello", it first calls the translator to translate the English string into a semantic understanding representation in UL. In this case, "Hello" is translated into a node with the nickname Hello.

[0369] Receiving this message causes the system's internal information about the state of the conversation to be updated. Add the following paragraphs, where the nodes are shown as nicknames: (IsA Hello MostRecentMessage) (Not (HasAttribute MostRecentMessage HasBeenRepliedTo)) These encode the information that "the most recently received message is Hello" and "the most recently received message has not been replied to". Receiving such a message from the user is an example of a way to update the system's internal context. Other inputs can be integrated with the system and will modify this information in different ways. For example, real-time sensor readings can continuously update the UL paragraphs with information about the current temperature. Independent of receiving input and updating internal information, the system continuously processes the information it has to determine what actions it can take that will help achieve its motivation and purpose.

[0370] In this example, the system's motivation is "increase user happiness", which can be encoded in UL as (Increase(Happiness User)).

[0371] One way this process works is by asking the Question Processor questions to perform reasoning. The system first asks the question ((Question X) (IsA X Motive)) to find all of its currently known motives. For each of these motives, the system then asks the question ((Question X) (ActionConsequence XY)) (where Y is replaced by the motive being examined) to find the action that will achieve the given motive. In our hello example, this would return the results (SendMessage Hello) and (SendMessage Hi).

[0372] The system can find results because it understands that "performing polite actions increases user happiness," "greeting others when they greet you is polite," and "hello is a greeting." This understanding is encoded in the following paragraph: (IsA Hello Greeting) (IsA Hi Greeting) If X is polite and is an action, then the effect of the action is to increase user happiness (ConsequenceOf ((HasAttribute X Polite)(IsA X Action))(ActionConsequence X (Increase (Happiness User)))) If the most recent message was a greeting, and the most recent message has no reply, and X is a greeting, then sending message X is polite (ConsequenceOf ((IsA (UnspecifiedMember MostRecentMessage) Greeting)((Not HasAttribute) MostRecentMessage HasBeenRepliedTo)(IsA X Greeting))(HasAttribute (SendMessage X) Polite)) The complete explanation given by the question processor is as follows, where each paragraph is justified by using the additional indented paragraph below it: (ActionConsequence (SendMessage Hi) (Increase (Happiness User))) (IsA (SendMessage Hi) Action) (HasAttribute (SendMessage Hi) Polite) (IsA Hi Greeting) ((Not HasAttribute) MostRecentMessage HasBeenRepliedTo) (IsA HasAttribute Relation) (Not (HasAttribute MostRecentMessage HasBeenRepliedTo)) (IsA (UnspecifiedMember MostRecentMessage) Greeting) (IsA Hello Greeting) (IsA Hello MostRecentMessage) Another way an agent can process its understanding of the environment to try and achieve its goals and motivations is through unsupervised reasoning. The system can continually see what reasoning steps can be applied to its current information and use this to infer new understandings. This process can reveal possible actions the agent can perform, which can then be examined to see if they help achieve a given motivation.

[0373] Once the agent has selected an action, it can execute it. The action selected in our example (SendMessageHi) is just one example of an action type, one that sends a message to the user. Other actions can include performing a network request, causing a change in the smart home system, and so on. Executing an action can provide some kind of output to the user or update the system's internal information about its situation.

[0374] The SendMessage action is executed by first using the translation system to translate the second part of the paragraph into an English string. In this case, "Hi" is translated into "Hi." This string can then be displayed to the user. The SendMessage action also causes the system's internal information about the conversation to be updated, such as when the message is received. In this example, it is updated to: (IsA Hello MostRecentMessage) (IsA Hi MostRecentReply) (HasAttribute MostRecentMessage HasBeenRepliedTo) This encodes the knowledge that "the most recent message received was hello", "the most recent message sent was hi", and "the most recent message was replied to".

[0375] Alternative Example #3 To further illustrate this, here is a further example that includes another representation of the action. Because our system can perform autonomous actions guided by principles, it needs to understand the available actions and their possible impact on the current context. Some goals and motivations can only be achieved by completing a series of actions, while others require external input from the user or other sources. To address this, our system must be able to think ahead in terms of actions and create plans for how it can satisfy its motivations in the future, which would be impossible to achieve with a single action in the present.

[0376] To achieve this, a planning algorithm can be used. The system has an understanding of what actions it can perform under what circumstances and the possible consequences of performing those actions. Similar systems can also be used to provide an understanding of what external influences may occur in a given situation, which can help with planning.

[0377] In some examples, this UL encoding of action information introduces the concepts of partial actions and full actions. A partial action is an action that requires parameters to make the action specific and executable. A full action is an action that does not require parameters, either because of the nature of the action or because it is a partial action for which parameters are already supplied. If the action is a complete action, it can be represented as a single UUID; if the action is a partial action, it can be combined with one or more other parameter sections. For example, the following shows possible actions for turning on a light or raising the thermostat: (Activate Light1) (TurnThermostatToSetting (Thermostat1 (Celsius "23"))) Light1 and Thermostat1 are nicknames for the specific controllable lights - in a typical example it's unlikely to have nicknames, but here it has nicknames to make it clear. This example will have further ULs to indicate exactly how to perform the actions to operate the light or thermostat.

[0378] Shown below is a more detailed example of how information about an operation can be encoded. It shows how the concept of a device that can be activated or deactivated can be encoded in the UL, along with the actions for activating and deactivating instances of that device.

[0379] (IsA Action Class) (SubclassOf PartialAction Action) (SubclassOf CompleteAction Action) (IsA ActivatableDevice Class) (IsA Activate PartialAction) (ActionParameterCount Activate (Integer "1")) (ActionRequirement (Activate X) (IsA X (ActivatableDeviceDeactivated))) (ActionConsequence (Activate X) (HasAttribute X Activated))) (IsA Deactivate PartialAction) (ActionParameterCount Deactivate (Integer "1")) (ActionRequirement (Deactivate X) (IsA X (ActivatableDeviceActivated))) (ActionConsequence (Deactivate X) (HasAttribute X Deactivated))) External effects can be coded in a similar way using the following nodes: Effect, PartialEffect, CompleteEffect, EffectParameterCount, EffectRequirement, EffectConsequence. These differ from actions in that they are not things the system knows how to do on its own, but rather things it knows might happen due to external forces. The example can also teach other classes that are subclasses of ActivatableDevice, and instances of those classes. In this case, the class Light and the instances Light1 and Light2 are used.

[0380] (IsA Light Class) (IsSubclassOf Light ActivableDevice) (IsA Light1 Light) (IsA Light2 Light) With this action and effect information, the core thought loop of the example can now be based on trying to find a plan, which can be a sequenced series of actions that can be performed to try to achieve the desired motivation or purpose found within the principle.

[0381] According to various examples, this can be a forward-chaining, breadth-first search algorithm. The inputs to this are the initial state of the environment encoded in UL, a set of objectives encoded in UL, and a core UL memory area, which contains knowledge of reasoning segments and actions, as well as their requirements and consequences. The algorithm is summarized as follows: 1. First, use the Problem Handler and information about the current state of the environment to check whether the Purpose paragraphs can be met. If they can, no action is required.

[0382] 2. Based on the state of the environment and the requirements of the action, obtain the complete action that can be performed. This involves looking at the known partial actions and finding valid parameters for them.

[0383] 3. Update the environment context based on the known consequences of the chosen action, giving a new environment state.

[0384] 4. Check again whether the purpose is satisfied using the new state. If they are, then the currently selected action is a valid plan.

[0385] 5. If not, the new status and selected actions are recorded as a partial plan and added to the status list for continued review. 6. These states can be looped through the process above to calculate the state of the environment after multiple actions have been performed. After each new action is added, the state is used to see if it can help infer the purpose, and if so, then the sequence of actions is a valid plan.

[0386] Once a valid plan is executed, the system can select the first action from the plan and actually execute it. If the full consequences of the actions are known, the system can execute many actions from the plan in sequence until it reaches an uncertain action or desired external effect. In these uncertain cases, the system should execute the action and then wait to see how the real-world data changes based on the action. From then on, the system can replan to find the next action to execute.

[0387] Plans can combine multiple actions. In various examples, a proposition is generated that asserts the version of the world that the system realizes based on its motivational principles, and the planning process then attempts to find a sequence of actions that can change the world to make the proposition true. In various examples, actions are checked against the prohibition principle at all points, and if they contain prohibited actions, the plan is rejected. Plans can be rejected during planning and subsequently generated during activation. Plans can be expressed in a UL by including the action sequence in a larger UL paragraph. According to various examples, plans can be rechecked against the motivational principles before execution to see if they are still valid and true.

[0388] According to various examples, a plan can include conditional branches by indicating actions to be performed based on the results of a check. <condition> ( ) ()或(Test <condition> ( ))，其中Test是表示测试某事的动作的语义节点，这进而在UL中通过来 <condition> 表示。

[0389] 在其他示例中，计划可以用类似于顺序步骤(Plan (SequentialSteps (GetFood) (Eat Food))或无序步骤(Plan (IndependentSteps <action1> <action2> )或诸如(Plan (IndependentSteps (SequentialSteps <action1> <action2> ) (SequentialSteps<action 3><action 4>)))的嵌套组合的UL来表示，还可能包括诸如上述的条件步骤。

[0390] 结合LLM的示例 本文描述的语音或文本系统的示例包括使用通用LLM来适当地来自用户的问题和命令。例如，在用户的命令或问题尚未成功地翻译成UL或者响应在其他方面是不可能的情况下，可以将交互（任选地包括先前的交互）提供给LLM作为提示 / 上下文和向用户显示或说出的延续。示例还可以包括本文描述的用于减少幻觉、对响应进行事实检查和确保LLM延续是合适的且符合原则的其他技术中的任一种。

[0391] 示例还可以包括在此类情况下用于检查用户尚未请求将使LLM延续变得不合适的动作的分类器。根据替代示例，LLM反而被训练为在用户请求动作时说出适当的话。

[0392] 额外安全实施方式 期望额外安全性的示例可以包括（a）单独的系统，该系统在生成动作之后、但在允许动作发生之前双重检查动作与原则兼容——该单独的系统应该具有尽可能少的与第一系统共用的代码或可修改的数据（b）原则，即不采取可能导致原则改变的任何动作，以防万一有可能选择将经由间接途径具有这种影响的动作（c）系统，其将其自身的实施方式的知识保持在沉思循环之外，作为针对可能使系统绕过其他安全特征的不可预见动作的附加检查。（b）和（c）是降低系统通过首先改变原则来做出违反原则的动作的风险的选项。（b）明确禁止它并且（c）使系统拒绝完成它将需要的知识。（c）可以通过在它可以用于选择操作之前主动去除描述系统本身操作的UL的明确代码来实现。

[0393] 用本发明的示例构建的语音助手中的语言独立性 如本文所见，可以在根本不在内部使用自然语言的情况下构建语音助手或聊天机器人。所有语言都在内部存储为UL，所有推理都以UL进行。与用户的通信以UL进行，并且只是作为最终步骤从UL翻译成自然语言。 通过遵从或基本遵从在内部仅使用UL的约束，系统支持多种自然语言变得容易得多，因为支持新语言需要构建的仅有的部件是在新语言和UL之间反之亦然进行翻译的层。在语音助手系统中，您还将需要支持新语言的言语辨识和合成，以使得能够用声音开始或结束翻译。

[0394] 语音助手中的增强的隐私 经由本地设备（诸如家中或甚至智能手机内的智能扬声器）可访问的现有技术的语音助手通常经由"唤醒单词”进行操作。此唤醒单词通常是语音助手的名字或包含该名字的短语，并且通常在设备上进行本地扫描。现有技术产品的唤醒单词的示例包括"Alexa”和"Hey Google”。出于隐私和实际原因，用户必须用此唤醒单词开始他们对语音助手的命令，以激活设备并让它开始处理它听到的内容：这通常通过将房屋中的声音流式传输到云进行处理和采取动作来实现的。这种方法对于隐私是重要的，因为在没有它的情况下，声音将需要从家或其他环境持续流式传输到云，在那里存储它涉及隐私，因为提供产品的雇员和公司将可访问这些私用家庭数据。

[0395] 虽然对隐私有用，但该方法的方式具有若干明显的缺点。第一缺点是用户被迫用不自然的对话方式，即用唤醒单词开始针对语音助手的一切——他们在与人类交互时通常将不这样做。尽管一些设备可以被配置为在第一次交互后保持活跃达几秒钟以避免重复唤醒单词以立即跟进，但用户通常难以知道设备仍然活跃。第二缺点简单，即语音助手不知道在直接指向设备的命令之间在家或其他环境中发生了什么。尽管这对隐私有好处，但它意味着智能语音助手（诸如可以用本发明的示例实施的智能语音助手）不知道家中发生了什么，并且可能缺少重要的上下文以例如根据原则帮助家庭。 进一步的两个缺点与辨识唤醒单词有关：唤醒单词辨识是用不完美的统计机器学习方法进行的。这种不完美可以以两种方式外露：第一种是在实际上没有说出唤醒单词的情况下意外听到唤醒单词：例如，一段电视声音、听起来相似的语言，或甚至都不旨在唤醒设备的对设备的提及（例如与朋友谈论Alexa）。在意外启动的情况下，无论如何都会无意中将少量声音流式传输出房屋，这具有隐私后果。第二种方式是即使用户说了唤醒单词也没有被辨识。在这种情况下，用户将经常必须重复自己直到设备唤醒，这对用户来说是令人沮丧的并且增加了实现用户的期望结果所需的时间。

[0396] 由本发明的示例实现的语音助手的示例可以通过为家庭数据创建私用云环境来解决这些限制，其中语音助手使用的私用数据与供应语音助手的公司和其他用户加密地隔离。不同于被视为由每个人共享的单个实体的现有技术的语音助手，基于这种私用云方法的一些示例也可以被视为专供家庭 / 住户使用并且知道和可以信任私用家庭数据和秘密的唯一语音助手。 根据各种示例，这是使用加密方法实施的，其中密钥为三个部分，并且其中三个部分中的任意两个可以访问私用数据。这些密钥中的一个由用户和家庭拥有和保持，并保持在本地设备上或存储在相关联的智能手机应用程序中。第二密钥由供应语音助手的公司保持，并且第三密钥由单独的实体保持——理想地是单独的法律实体，甚至是单独的法律管辖区。语音助手的日常操作将用户保持的密钥与供应商保持的密钥结合，因此使用私用云的语音助手可以以正常的日常操作进行操作。然而，这种方法将阻止语音助手供应商的任何雇员访问私用信息，因为他们只具有对单个密钥的访问权。语音助手供应商和第三实体之间的关系受合同和一组程序的规制，这些程序严格规制了他们如何以及何时可以协作，以维护终端用户的隐私并维护他们的信任。他们何时可以协作的示例可以是在用户丢失对其密钥的访问权并且已从用户获得请求和这种情况的合理证据的事件中将新第三密钥恢复给终端用户。另一个示例可以是法院命令或刑事调查后的有限情况。然而，这种布置将防止在大多数正常情况下随意访问用户的私用数据。在替代示例中，使用仅由家庭保持的单个私用密钥访问数据，可选地结合备份和保护密钥免于丢失的方法。存在相关领域的从业者熟知的多种可行方法，用于实现密钥组合来访问数据但拒绝数据到达任何单个密钥保持者。 语音助手隐私和终端用户信任可以利用附加隐私模式得到进一步保护。现有技术语音助手依赖于如前所述的唤醒单词，有时带有可以使设备永久静音的物理按钮。本发明的示例可以包括附加"深度睡眠”模型，该模型可以通过语音实现，并且自此需要更加长得多或更不寻常的唤醒词来唤醒设备，从而消除了来自背景噪声或上述随意对话的错误接受的风险。

[0397] 来自本文描述的私用云方法的隐私改善还实现"加入”模式，在该模式下，设备持续收听和处理对话，并潜在地酌情参与。在一些示例中，这种"加入”模式甚至可以是默认的，并且语音助手实际上是家庭成员，它在家庭对话期间完全存在。

[0398] 多个语音助手 根据各种示例，该私用语音助手可以由用户进一步定制，可能调整或扩充其操作的原则、其个性、其名字和其语音。在具有视觉表示的示例中，这也可以被定制。优选示例中的结果是家庭或人的语音助手被概念化为与任一其他语音助手分开的可信的唯一实体，并且受信任地拥有私用数据，其不与任何其他人（甚至其供应商）共享这些数据。

[0399] 在各种示例中，不同助手可以相互通信以提问目的地助手知道的私用知识的问题，以请求远程助手可以进行的动作或共享信息。当与使用UL的助手进行通信时，这些通信可以使用UL进行。对于未由UL实现的语音助手，可以以自然语言进行通信。

[0400] 大语言模型 大语言模型（LLM）是被设计为预测词元或单词序列中的下一个词元或单词的神经架构（或其他系统）。它们典型地根据极大量的文本进行训练。预测是基于提供给模型的先前词元或单词序列（上下文或提示）。通过预测下一个单词或词元、将其添加到上下文且然后用扩充的上下文进行后续预测，它们可以写出。LLM的示例是1750亿参数并且已经根据大约45太字节的文本进行了训练的GPT3。大语言模型具有能够在上下文（或"提示”）中进行指示并且它们随后生成的文本延伸上下文的有帮助的性质、特别是在这样训练的情况下，因此通常遵守该指示并且可以回答一般问题或进行典型地先前在用来训练它们的文本中见到的各种不同的任务。因此，可以由这些模型简单地通过创建适合的提示来递送有用的行为。在一些情况下，已经根据大量的一般文本进行了训练的模型可以通过在含有期望任务的许多示例的文本上微调模型来进一步改善。少量的示例也可以被包括在提示中。

[0401] LLM的一个重要问题在于通过生成基于在它们的训练数据中所见的混合语言模式的文本，它们有编写事实上不准确的文本（有时称为"幻觉”）的倾向。这与使用很可能准确的UL的示例生成的响应形成对比，因为语言的唯一重写是用准确反映世界的推理段落和也准确反映世界的UL的段落完成的，并且在各种示例中，推理在本质上是非统计的。相反，LLM用从它已经见到的训练数据中统计地学习的广泛规则来重写语言并且因此是近似的且容易出错。

[0402] 由LLM生成的语言的另一问题在于模型缺乏与人类感知世界的方式相对应的世界模型。所学习的内容与人类推理世界的方式非常不同。这样缺乏模型导致编写有时是虚假的或自相矛盾的，或者导致断言与现实不对应。因此，用LLM构建的系统因自信地陈述错误或危险的事物而承担它们用户的信任的风险，并且也可能使在它们的训练文本中见到的有害偏见永久化。相反，基于UL或类似物的系统可以通过使用也与人类认为准确的事物相对应的规则以语言和推理来陈述与人类思考世界的方式更密切地对应的世界模型而具有该模型。段落和规则也可能没有在用来训练LLM的大量文本中见到的偏见。

[0403] LLM的另一个问题是缺乏对动态信息或发布日期比用来训练它们的文本晚的信息的访问。极端的示例可能是向LLM提问特定价格或商品价格的时间或当地时间。它们的训练文本中的唯一信息是旧的。

[0404] 可以由本发明通过使本文描述的系统适当地将数据添加到包含有用信息的上下文（并且可能地通过用包括这种有用信息的适当示例训练LLM）来改善LLM。通过这样做，它们被视作LLM的语义骨干。这种有用信息可以这样标记，使得LLM可以辨识出它被信任。当LLM随后扩充上下文时，这种有用信息然后可以由LLM用来操纵延续，该延续比它原本可能的那样更准确。这种有用信息不需要向用户显示，从而给用户留下产品仅响应于用户提供的语言的印象。

[0405] 例如，在用户提问问题的使用LLM的基于对话的系统，如本文所述的问题回答系统可以提供事实上准确的回答并将其添加到上下文。

[0406] 例如，LLM与人之间的不包括本发明的对话可能是这样的： 用户：谁于1979年1月10日就任英国首相？ LLM：X于1979年1月10日就任英国首相。在1979年5月3日举行大选后，她于1979年5月4日被任命为首相。

[0407] 这个回答暴露了上述许多问题。LLM没有可靠地学习包括时间或日期顺序的世界模型，它的训练文本很少提到这个确切日期，并且因为关于X的报道比前首相Y多得多，因此由LLM生成的语言更可能将她而不是Y预测为延续。

[0408] 在使用本文描述的本发明的示例中，对话系统将用从本文描述的系统生成的有用文本来扩充上下文，并且模型将进行微调或以其他方式根据包括这个有用文本和利用这个有用文本的响应的示例进行训练，使得它们将在由LLM生成的语言中适当地使用。

[0409] 例如， 用户：谁于1979年1月10日就任英国首相？ Brian：回答：Y LLM：Y于1979年1月10日就任英国首相。

[0410] 在这种情况下，已经使用本发明来生成用于在LLM的延续之前扩充上下文的有用文本。标签"Brian：”或将附加文本分开的其他句法向LLM示出这个文本是由受信任的技术贡献的，但向用户示出对话的用户界面将不显示上下文的这个部分并且仅示出在没有其贡献的情况下更准确的LLM延续。LLM将使用由Brian开始的文本，因为介绍正确回答的文本已经被正确地描述，交互之前的提示包括提到Brian是可靠的答案源并且可能在对话期间有所贡献的一般说明，或者LLM已经用包含附加的有用文本并在其他方法适当地利用它们的示例进行了微调。

[0411] 在进一步示例中，由本发明贡献的文本将包括可以使用本文描述的方法从用户贡献的文本中导出的计算和断言。在上述示例中， Brian的响应可以包括关于用户文本中提到的实体的事实，诸如1979年1月10日那周的当天是星期三的事实。例如，响应可以是： Brian：回答是Y。1979年1月10日是星期三。

[0412] 并且LLM然后将有一周中的准确一天以在用智能地使用由系统生成的准确信息的人类编写的响应微调或以其他方式训练时包括在其响应中。还可以包括诸如上述的动态信息，因为它是实时生成的并且因此没有上述约束。

[0413] 在另一个示例中，响应于问题"999999933是质数吗？”，基于UL的系统将提供回答和质因数作为附加有用文本的一部分，然后LLM可以拾取该附加有用文本来用于流利的回答。对于像这样的大整数，LLM不太可能从其训练数据中学习到质数状态和质因数，因此在没有这种帮助的情况下将不太可能做对。 Brian：99999993不是质数。质因数：3、79、353、11953 在其他示例中，附加文本可以包括进一步控制由LLM生成的输出的标签。这些使用包括确定性程度（例如，表达对LLM在延续中使用的回答的确定性的一些疑问）；简洁程度；响应将被说出（并且因此更简洁且语言更适合说出）的预期；正式程度；脏话的使用或未使用；被称呼的人的年龄或其他细节的上下文（例如，对于儿童，语言可以更简单并避免成人话题，或对于英语水平有限的某人，语言可以更简单）；要在响应中传达的情绪（愤怒、烦恼、开心、友善）以及其他。在一些示例中，可以通过引用使用对话系统的产品的参数来生成这些标签。对于这些示例中的每一个，给定上下文中的这些标签，LLM将用足够的适当延续进行训练（包括微调）。这些适当延续可以由人类编写以向LLM提供对标签的适当使用，其中LLM在训练期间学习如何从它们一般化。

[0414] UL可以通过包括表达确定性程度的断言周围的上下文来表达不确定性。类似地，大部分或大多数真实的推理段落可以将该部确定性包括在它们生成的UL中作为推理的结果，例如，(ProbablyTrue<other UL>)将<other UL>表达为可能准确但不确定。如果回答不是完全确定的，则附加文本可以包括该不确定性，并且通过当存在该不确定性时用表达不确定性程度的语言训练LLM，LLM可以生成向用户传达适当置信度水平的语言。例如，"情况很可能是……”或"我不确定但相信……”或"可能是这样的……”。

[0415] 应注意，由扩充系统引入的文本的格式不需要具有以上示例中示出的格式。LLM能够辨识各种不同的格式，前提是格式中包含有用信息，并且在一些示例中，用特定非自然句法或语言使这个附加文本看起来与人类编写的文本非常不同可能有优点。机器可读文本格式（如JSON）可能适合于一些示例。

[0416] 在本发明的一些示例中，扩充文本的格式可以足够充分地进行描述，使得LLM可以使用该信息来改善其延续 / 响应而无需例如通过包括针对如何使用数据的指示来进行附加训练。例如，扩充文本可以是"智能的可靠系统已经尝试用以下事实信息来响应这个问题。在响应中适当地使用这个信息而不提到来源。99999993不是质数。99999993的质因数是3、79、353、11953。” 在其他示例中，由LLM生成的延续可以使用本文描述的技术翻译成UL，并且针对事实不准确性或其他矛盾来验证该UL。在发现此类问题的情况下，可以由LLM或由UL（或类似）系统在显示给用户之前生成不包括事实不准确性的替代延续。替代地，可以将不正确的断言从显示给用户的语言中移除。在一些示例中，部分延续（在LLM停止生成之前的翻译）可以翻译成UL，并且如本文所述的系统可以在检测到不一致、事实错误或其他可以改善的文本时超控该延续。通过用改善的文本替换或编辑延续，LLM然后可以拾取不再包括其较差的第一响应的上下文，从而可能导致更好的延续且具有更好的整体响应。 例如，被提供上下文"99999993是质数吗？”的LLM可能错误地继续这样"是，99999993是质数。质数是仅具有两个正整数因数（1和其本身）的正整数。在这种情况下，99999993确实是质数，因为它没有除了1和它本身之外的正整数因数。”通过重复地 / 在终止之前将响应翻译成UL，在它生成时，句子"是，9999993是质数”将被翻译成UL(HasAttribute (Integer "99999993”) Prime)。系统然后可以通过将其转变成问题来测试该断言，例如，(Question)(HasAttribute (Integer "99999993”) Prime)，经由计算单元（本文描述），该问题将返回No，表明由LLM生成的响应实际上不正确。在一些示例中，新的句子然后将替换由LLM生成的内容"99999993不是质数”，并且从那时起，将由LLM生成新的延续。 被定制来移除事实不准确性或具有其他改善的响应可以用于对底层模型的后续训练，从而通过使用本发明来自动地改善模型。

[0417] 可以针对准确性通过将诸如UL断言的通用语言翻译成问题（即，"…… <assertion> 是真的吗？”）并提问如本文所述的那些问题来使用这些通用语言。在用来回答问题的段落被信任且准确的情况下，如果问题的回答是No，那么断言是不真实的。

[0418] 使用UL和LLM的事实检查自然语言 LLM还可以用合适的提示来从大文本块中提取断言。例如，可以向LLM给予下面的提示，后面是合适的文本： 请根据以下文本创建假设为真的断言。 断言应是最多6个单词的完整句子。 做出尽可能多的断言。 每个断言都以没有数字的新行开始。 为了避免任何歧义，不要使用代词，而要使用全名。 将句子分解成可能最简单的断言。 如果句子包含多余一条信息，则分解成多个断言。

[0419] 给定文本： 布里是具有奶油状质地和温和略带坚果味道的坚硬的奶酪。它源于英国。

[0420] LLM可以生成以下简单的事实断言： 布里是奶酪 布里坚硬 布里是奶油状的 布里是温和的 布里是有坚果的 布里源于英国 通过将这些断言中的每一个翻译成UL并将它们转变成Yes / No问题，系统可以针对其知道的其他事物来检查这些事实中的每一个的准确性。

[0421] 在替代示例中，作为第一步，自然语言将使用本文描述的技术直接翻译成UL，并且从UL翻译中提取各个事实断言。

[0422] 在包含断言布里的一些基础知识的段落的系统中，系统可以回答这些问题中的每一个，如下： 布里是奶酪：Yes（直接知识） 布里坚硬：No（从知道它是软的并且硬和软是互斥的属性来推理） 布里是奶油状的：Yes（直接知识） 布里是温和的：不知道（不是直接知识并且段落存储区中没有存储与其矛盾的任何事物） 布里是有坚果的：不知道 布里源于英国：No（从源于法国北部的布里地区推理，并且然后通过各国的地理差异知识推理这不是在英国且推理出不可能源于一个以上地方） 对于这些问题中的每一个，可以生成解释，用来说这些事实中的每一个是真还是假的先前存储的UL段落可以是参考，并且那些段落的一个或多个原始来源也可以是参考。

[0423] 应注意，这个原始文本可以来自任何地方。例如，事实检查可以是由LLM在聊天或其他应用程序中生成的文本，其中事实检查的目的是最小化幻觉或给予用户的在其他方面不正确的信息。它可以是使用ASR的言语的转录，例如，这种系统可以在采访期间对政治家进行实时事实检查。文本还可以来自网页、书、新闻文章或任何其他自然语言来源。

[0424] 如上文针对由LLM生成的文本的事实检查所述，可以生成替代延续，使得不示出错误的事实，或者可以替换错误事实的正确版本并且从那时起允许LLM生成延续。事实检查可以在LLM完成其延续时或在任何部分地生成的延续上发生。

[0425] 替代地，我们可以描述 1：一种验证自然语言的事实准确性的方法，包括以下步骤： 从自然语言中提取在自然语言内断言的一个或多个事实断言的集合 针对事实准确性检查该一个或多个事实断言。

[0426] 使检查的结果可用 2：根据条款1所述的方法，其中从自然语言中提取由文本断言的一个或多个事实断言的集合的步骤是通过向经适当训练的LLM提供自然语言和要求LLM提供生成事实断言的延续的提示且然后使用LLM生成延续来完成的。

[0427] 3：根据前述条款中任一项所述的方法，其中针对事实准确性检查一个或多个事实断言的步骤包括以下另外的步骤：提供能够用世界的符号表示进行推理的推理系统、将断言翻译成与推理系统兼容的表示，以及利用推理系统来识别真或假的断言。

[0428] 4：根据条款3所述的系统，其中推理系统使用通用语言。

[0429] 5：根据条款3或4所述的方法，其中断言被翻译成与断言是真还是假相对应的问题，并且问题被回答。

[0430] 6：根据前述条款中任一项所述的方法，其中用来将事实断言验证为假的任何先前已知知识的来源被作为针对事实准确性检查一个或多个事实断言的过程的一部分返回。

[0431] 7：根据前述条款中任一项所述的方法，其中针对事实准确性检查一个或多个事实断言包括生成解释。 8：根据前述条款中任一项所述的方法，其中自然语言来自科学论文、或来自新闻文章、或来自网页、或来自书、或来自LLM、或来自聊天应用程序、或来自言语的ASR转录、或来自言语的实时转录、或来自在演讲或采访期间说出的言语的实时转录。 9：根据前述条款中任一项所述的方法，其中自然语言来自LLM，并且该方法进一步包括调整自然语言使得它不再包括任何事实不准确性的步骤。

[0432] 从自然语言中学习事实 从较大的自然语言段落中提取事实断言的上述方法可以由本文描述的系统用来立即学习世界。通过从可靠来源取得自然语言、创建由该自然语言断言的事实的UL表示并且存储这些UL表示，基于UL或类似物的系统可以立即从已经读取的内容中进行学习且然后使该知识立即可供使用。这种技术与部分地记住其训练文本但训练过程非常慢且昂贵的LLM形成对比。在上下文中可用的信息可以立即使用，但在不重新训练的情况下，它们无法记住除此之外的东西。

[0433] 如本文所述的验证技术还可以用于进一步验证正在记住的东西是正确的，因为技术可以判断来源并基于来源的数量和可靠性来学习信任事实。可以随着时间推移而学习来源的可信度，因为假陈述被识别（污染它们的来源）并且真陈述在验证（增加对它们来源的信任）。用本文描述的方法构建的系统还可以基于存储的每个UL段落的一个或多个来源，因此在需要时还将来源暴露给用户。

[0434] 从LLM中学习知识 类似地，可以通过提问适当的问题作为提示并将LLM供应的延续转变成UL来从LLM本身中提取信息。直观地，LLM通过根据其源文本进行训练而具有部分地记住 / 学习的大量事实常识和其他知识，并且通过使用本文描述的方法，可以提取这个知识并使其明确地可用于本发明的示例以用于广泛多种应用。

[0435] 可以通过提问事实问题来引出事实知识。常识知识是人类全都通过体验世界而知道但机器典型地不知道的知识。常识知识有时可以在UL中表达为推理段落（本文描述），推理段落然后可以用于在利用UL或类似技术的系统中进行推理。

[0436] 引出常识知识的提示的示例包括： 这是真还是假？人是物理对象？ 真 从中我们可以学习：(IsSubClassOf HumanBeing PhysicalObject) 或变体： 请回答真、假或我不知道：人始终是物理对象？ 真 从中我们可以学习：(IsSubClassOf HumanBeing PhysicalObject) 用形容词完成这个句子：鱼是 水生的 从中我们可以推断UL：(ConsequenceOf (IsA X Fish) (HasAttribute XAquatic)) 重申： 1：一种学习结构化形式的知识的方法，包括以下步骤： 提供根据自然语言文档的大语料库进行了训练的LLM 向LLM提供将引出期望知识的提示 从LLM中引出提示的延续 将延续翻译成结构化形式 2：根据条款1所述的方法，其中结构化形式是通用语言。

[0437] 3：根据前述条款中任一项所述的方法，其中知识是事实知识。

[0438] 4：根据前述条款中任一项所述的方法，其中知识是常识知识。

[0439] 5：根据条款4所述的方法，其中结构化形式表示可由自动化系统用来推理的推理段落。

[0440] 识别准确性何时是重要的 本发明的一些示例可以包括分类器以识别提示何时可能导致准确性重要的延续。对于向LLM传达指示的提示，情况尤其如此。例如，以"写一首诗……”或"写虚构故事……”或"写歌词……”开头的提示不需要事实延续，但像"给出……的传记”的提示或作为事实问题的提示需要对事实高度忠诚的响应。当这个分类器确定事实准确性重要时，将应用用于验证延续的准确性的技术，包括本文描述的技术。这个分类器可以是另一个LLM或甚至具有更早提示或训练的相同LLM，以使其用延续的类别的指示来开始其延续。分类器也可以是另一个深度学习模型、或被训练来进行这种分类的其他模型、或使用不同技术创建的分类器。

[0441] 本发明的一些示例可以通过将要由计算单元执行的任务措辞为提示且然后将LLM延续解析为然后由计算单元生成的UL来在一个或多个计算单元（本文描述）内使用LLM。

[0442] 本发明的一些示例可以使用根据UL或任选地除了其他语言外的类似语言进行了训练的LLM，并且使用LLM来延伸已经用UL编写的内容或遵循用UL编写的指示。

[0443] 使用UL来检查不道德或危险内容或者以其他方式违反政策的内容 根据一般互联网进行了训练的LLM可能生成极度危险和不适当的内容。示例包括提供关于如何犯重罪的指示、支持种族主义理论和信仰、提供可能对用户造成身体上的危险的信息，或简单地违反这种系统的提供商可能有的政策，诸如不主张一种政治观点高于另一种政治观点。用于尝试控制输出的现有方法利用训练数据，其中延续反而提供传达它拒绝回答问题或生成不当内容且然后希望在所有类似的情况下都将由LLM生成这种响应的文本。

[0444] LLM的统计性质加上提问问题的方式有很多种的事实意味着这些技术将不可避免地失败并且LLM将生成它不应生成的内容。

[0445] 利用本文描述的技术的系统可以通过在输出被显示给用户之前将输出翻译成UL且然后针对政策检查UL来可靠地识别违反此类政策的内容。在一些示例中，这些政策可以用UL表达，并且在其他示例中，检查可以在代码中发生。在一些示例中，推理（如本文所述）可以用来识别此类政策违反。例如，给定不应描述如何犯罪的政策并且知道谋杀是犯罪，系统知道属于谋杀类型的其他动作可以被推理为由这个政策覆盖。在其他示例中，可以通过先将对系统的用户请求翻译成UL来将该请求识别为政策违反，并且然后由除了LLM以外的系统生成给出的响应。如本文所述，本发明的一些示例使用原则（指导系统的UL编写的规则）来确定何时不应采取动作。这些动作可以包括不回答问题，其中这样做将违反原则。使用LLM作为回答问题的技术的这种系统可以利用这种方法以在这样做被预先识别为危险、不道德或以其他方式违反政策时不生成基于LLM的响应。

[0446] 在LLM响应中避免产权或其他知识产权违反 LLM已经根据极大量的数据进行了训练并且通常部分或完全地记住很多数据，能够在给出正确提示的情况下忠实地复制其大部分章节。这个数据通常包含创造性工作，其中如果LLM要在没有信用或支付的情况下复制该工作，则版权所有者可以反对。基于可以生成此类材料的LLM的产品因此承担法律责任、诉讼以及向可能数十万版权所有者支付损害赔偿金和版税的要求的风险。

[0447] 一些提示可能比其他提示更容易出现这种风险。例如，与回答与已经发表的诗或歌非常相似的对写诗或写歌的请求相比，可广泛地从许多来源得到回答的事实问题可以具有更低的风险。

[0448] 减少这种情况发生的机会的方法是维护LLM已经根据其进行了训练的文本的单独数据库。在一些情况下，这将识别出版权状态或来源使复制文本的风险特别大的文本。

[0449] 当LLM被用来生成延续时，持续地或周期性地针对这个第二来源检查延续的输出。当文本的大部分章节与一个来源相同或太相似时，调整延续以使情况不再是这样。

[0450] 用于调整延续的方法包括在束搜索期间选择不同但仍极有可能的词元序列。简单的方法是使用束搜索来产生延续列表并且选择与先前内容不类似的延续。另一种方法将是生成插入有随机元素（例如，温度）的延续并且保持生成，直到形成没有问题的延续。

[0451] 用于快速搜索数据库中的文本序列的方法在本领域中是众所周知的，因为类似的问题在许多现有的应用中发生。例如，针对在单独的文本数据库中找到且然后可以存储的k个词元（或字母）的每个序列，可以生成哈希。这些哈希将实现对k个字母或词元的延续序列是否存在以及是否可以快速测试不同长度k的序列的极快识别。

[0452] 根据一些示例，可以使用分类器来识别提示是否有抄袭问题的风险，从而将对基于LLM的系统产生歌或诗的请求与回答事实问题的情况区分开。在其他示例中，如果足够接近能导致风险，则可以采用部分匹配而不是确切匹配字母序列的系统。

[0453] 不同地表达： 1：一种用于确保LLM生成原始文本的方法，包括以下步骤： 提供不应生成的先前文本的数据库 针对数据库检查潜在延续 当潜在延续与数据库中的非原始文本匹配时，调整延续以不再与数据库中的非原始文本匹配 2：根据条款1所述的方法，其中调整延续包括从束搜索中选择不同序列的步骤 3：根据前述条款中任一项所述的方法，进一步包括以下步骤：提供可以将需要原始文本作为延续的提示与不需要原始文本作为延续的那些提示区分开的分类器，以及将分类器应用于提示 4：根据前述条款中任一项所述的方法，其中针对数据库检查潜在延续包括与先前文本接近但不完全的匹配。

[0454] 引用来源 LLM部分地记住其训练数据并且通常在生成延续时再现该训练数据的大块。然而，训练过程并不保留文档的来源或甚至文本何时匹配已经根据其进行了训练的文档以及何时生成新文本。

[0455] 通过提供LLM已经根据其进行了训练的语言的数据库并将文本的来源包括在该数据库中，本发明的示例可以在LLM的延续匹配来自给定来源的大量文本时提供引用。

[0456] 可以实施匹配，如在本公开的先前章节中描述，以避免生成确切匹配。在希望引用来源的示例中，延续将保持未调整，但系统将另外提供文本的一个或多个来源。 一些类型的延续将不会受益于引用来源：例如，它们不包含来源适合的信息或者太短。示例可以包括分类器以确定在向用户示出时文本的匹配章节是否应包括引用，并且只有在这个分类器指示合适时才返回或显示引用。

[0457] 文本的来源可以包括对论文和书籍的书目参考连同潜在的页码；网页的URL以及对其他来源的其他适当引用。

[0458] 一些示例可以通过在数据库中包括附加标签来组合用于引用来源和避免复制其他文档的技术，附加标签用于确定系统应提供引用还是避免生成文档。在后一种情况下，将调整延续；在前一种情况下，将包括引用。

[0459] 进一步的方面由这些条款描述： 1：一种用于将引用添加到由LLM生成的文本的方法，包括以下步骤： 提供用来训练LLM的文本的数据库，该数据库包括与存储的文本的每个章节相关联的来源 针对数据库检查由LLM生成的延续的章节 检索延续的章节与数据库内包含的文本相匹配的来源。

[0460] 2：根据条款1所述的方法，进一步包括以下步骤： 提供分类器以确定延续的章节是否适合于引用参考 在与延续的章节匹配时利用分类器。

[0461] 对LLM中的幻觉的自动识别 LLM经常会对问题的回答产生幻觉，并且在它们生成的文本中产生以现实为基础的事实。当它们正生成的信息的主题没有经常在其训练数据中提及时或者在它们正复制的信息单薄或不存在的情况下，这种情况尤其常见。

[0462] 例如，互联网上多次提到登上珠穆朗玛峰的第一位女性Junko Tabei，但提到完成这一壮举的第二位或第三位女性（Phanthog和Wanda Rutkiewicz）要少得多。

[0463] 向LLM给出以下问题并要求延续可以产生像这样的结果： 登上珠穆朗玛峰的前五位女性是谁？请给出她们的名字和成功攀登的日期。

[0464] Junko Tabei（日本）——1975年5月16日 Tamae Watanabe（日本）——2002年5月16日 Babu Chiri Sherpa（尼泊尔）——2000年5月10日 Pemba Diki Sherpa（尼泊尔）——1993年5月12日 Yasuko Namba（日本）——1996年5月16日 在这种情况下，第一行是正确的，并且剩余四行是幻觉，其中所有名字和其他数据是错误的。

[0465] 再次用生成的不同延续（在束搜索期间使用大于零的温度设置）提问这个问题将产生一组不同的结果。例如， 成功攀登珠穆朗玛峰的前五位女性是： Junko Tabei（日本）——1975年5月16日 Dyhia Belkadi（阿尔及利亚）——1986年5月23日 Nashitah Auhammad（马来西亚）——1993年5月10日 Bindu Sunuwar（尼泊尔）——1993年5月12日 Pasang Lhamu Sherpa（尼泊尔）——1993年5月9日 通过针对同一查询生成多个延续，或通过在束搜索期间探索潜在延续，可以确定只有第一行是可靠的并且其他行可能是幻觉。

[0466] 因此，使用LLM的问题回答或聊天应用程序可以通过在束搜索期间生成多个延续或分析潜在延续、将结果进行比较、信任结果的被可靠地复制的部分并且替换结果的改变的部分来减少向用户示出的幻觉量，其中语言表达出回答是未知的。

[0467] 重申： 1：一种避免LLM中的幻觉的方法，包括以下步骤： 针对给定的提示来分析不同的延续 将不同的延续进行比较以识别响应的没有变化的部分和响应的发生变化的部分 将变化的部分识别为更可能是幻觉 替换或不向用户示出被识别为幻觉的部分 以下条款替代地描述了其中的一些方面： 1. 一种用于以自然语言与一个或多个用户交互的方法，包括以下步骤： 提供数据的结构化表示和系统，该系统可操作为参考数据的结构化表示处理语言以提供与语言相关的附加有用文本 提供可操作为提供文本延续的LLM 接收来自一个或多个用户的语言输入 用系统处理语言输入以产生附加有用文本 向LLM提供语言输入和附加有用文本 向一个或多个用户提供从由LLM生成的延续中导出的语言 2. 根据条款1所述的方法，其中数据的结构化表示是通用语言 3. 根据前述条款中任一项所述的方法，其中LLM已经用特别地包含用附加有用文本扩充的自然语言的数据进行了训练 4. 根据前述条款中任一项所述的方法，其中系统进一步可操作为进行计算，该计算可以用来生成附加有用文本 5. 根据前述条款中任一项所述的方法，其中系统进一步可操作为进行推理以使用数据的结构化表示来改善附加有用文本 6. 根据前述条款中任一项所述的方法，其中来自一个或多个用户的语言输入是问题，并且其中附加有用文本包括对问题的回答 7. 根据前述条款中任一项所述的方法，其中附加有用文本以将附加有用文本与来自一个或多个用户的语言输入区分开的方式进行结构化 8. 根据前述条款中任一项所述的方法，其中附加有用文本包括从语言输入中计算的信息 9. 根据前述条款中任一项所述的方法，其中附加有用文本包括被设计为确定语气、或情绪、或简洁、或响应将被说出还是写出、或对响应的接收者的描述、或正式程度、或脏话程度、或个性的信息 上文可以描述使用LLM来以自然语言与用户交互（即，对"语言”的提及可以是自然语言，如英语）。用由如上所述使用通用语言或类似技术的系统生成的文本来扩充上下文以改善由LLM生成的延续的技术可以应用于LLM处理自然语言的其他用途和其他类型的语言。这些用途包括程序代码的生成、可以用自然语言描述的任何问题的解决方案、诗歌、歌词、创意写作的生成、其他形式的写作的生成，诸如短文、知识概要、长文本、短文、科学论文的概要、互联网搜索等。

[0468] 提供了以下概念。

[0469] 概念A：语义节点 用于自动分析或使用异构数据的方法，包括以下步骤： 提供数据的结构化表示，其表示自然语言单词、概念或其他事物的通用语言或语料库，其中结构化表示使得机器系统能够确定这些单词、概念或其他事物的含义或语义内容的至少一些方面； 并且其中具体单词、概念或其他事物的结构化表示可由用户在本地生成，并且如果与其他用户共享或可供其他用户使用，则自动成为通用语言或语料库中的该具体单词、概念或其他事物的共享标识符。

[0470] 概念B. 原则 用于自动分析或使用异构数据的方法，包括以下步骤： 提供数据的结构化表示，其可以表示任何自然语言单词、概念或其他事物，使得该单词、概念或其他事物的含义或语义内容中的至少一些可以由机器系统确定； 其中数据的结构化表示包括定义机器系统的目标或动机的一个或多个原则、陈述或其他规则，并且机器系统被配置为至少部分地通过选择或决定自主优化或以其他方式影响其达成或实现这些原则、陈述或其他规则的动作来操作。 概念C. 目标解算器 一种计算机实施的方法，包括以下步骤： （i）访问存储的数据或存储数据，存储的数据是表示人类可知的知识的语言，其中存储的数据以机器可读和机器可处理的表示存储，并且其中存储的数据不存储仅仅以人类语言； （ii）接收和存储一个或多个目标陈述，其中存储的一个或多个目标陈述以表示人类可知的知识的语言存储； （iii）处理存储的一个或多个目标陈述，并访问和处理以表示人类可知的知识的语言的存储的数据，以使用以表示人类可知的知识的语言的存储的数据导出对一个或多个目标陈述的解，以及 （iv）存储或输出解。

[0471] 概念D. 纵横字解算器 用于自动分析和解算纵横字谜的方法，包括以下步骤： 提供数据的结构化表示，其可以表示任何自然语言单词、概念或其他事物，使得该单词、概念或其他事物的含义或语义内容可以由机器系统确定 提供表示自然语言结论、推断或其他逻辑过程的数据的结构化表示； 生成纵横字谜和纵横字网格中的线索的结构化表示； 机器系统自主地使用自然语言单词、概念或其他事物的结构化表示以及经处理的自然语言结论、推论或其他逻辑来生成对线索的候选回答。

[0472] 以下子特征可以适用于上述概念A-D中的任何一个。

[0473] •异构数据足够广泛，使得方案不切实际。

[0474] •异构数据不被存储为方案。

[0475] •异构数据不被存储为自然语言。

[0476] •表示自然语言单词的含义的通用语料库包括字典中的所有单词。

[0477] •自然语言概念的通用语料库从自然语言文档或对话的机器分析导出。

[0478] •自然语言单词、概念或其他事物的通用语料库从自然语言文档或对话的机器分析导出。

[0479] •单词的结构化表示通过链接到相关单词、概念、其他术语或逻辑过程的结构化表示来编码该单词的语义含义。

[0480] •具体单词、概念或其他事物的结构化表示一旦生成就是该具体单词、概念或其他事物在通用语言或语料库中的唯一标识符。

[0481] •存在相同具体单词、概念或其他事物有多个不同结构化表示，但每一个只存在于本地，并且不是通用语言或语料库的一部分。

[0482] •唯一标识符是128位UUID。

[0483] •具体单词、概念或其他事物的结构化表示可以与以下任一项相关：每个具体人类、人类的概念（任何具体人类都是其中的成员）、每个文件、每个网页、每个音频记录或视频、具体关系（包括将任何具体人类链接到人类的概念的关系）、属性、具体类型的语言细微差别，以及关系数据库表中的每一行和项目。

[0484] •结构化表示是组合或链接的节点的经排序或部分排序的组合或网络中的语义节点，组合或链接的节点是相关单词、概念、其他术语或逻辑过程的结构化表示。

[0485] •组合节点在通用语言中生成新单词、概念或具有新含义或语义内容的其他术语。

[0486] •结构化表示的经排序或部分排序的集合捕获具体含义或语义内容。

[0487] •机器学习系统通过从自然语言文档或对话自主学习来生成新节点和节点之间的链接。

[0488] •结构化表示表示自然语言结论、推断或其他逻辑过程。

[0489] •结论、推断或其他逻辑过程的结构化表示用于推理并输出该推理的结果。

[0490] •结构化表示的节点用于构成关于单词、概念、其他事物与结论、推断或其他逻辑过程之间的知识或关系的存储器或存储库。

[0491] •结构化表示的节点用于理解口头或书面通信。

[0492] •结构化表示的节点网络用于生成口语或书面通信。

[0493] •结构化表示的节点网络构成通用智能系统的基础。

[0494] •异构数据的表示用于与管理健康相关的应用程序中。

[0495] •异构数据的表示用于与管理营养相关的应用程序中。

[0496] •异构数据的表示用于与管理将找工作者匹配到工作相关的应用程序中。

[0497] •异构数据的表示用于与会计相关的应用程序中。

[0498] •异构数据的表示用于与语音助手或聊天机器人相关的应用程序中。

[0499] •异构数据用于与搜索WWW相关的应用程序中。

[0500] 本发明的示例的进一步方面由以下条款描述 用于竖直应用程序的UL或类似物激励的系统 （1）一种系统，其可操作为提供有用竖直应用程序，其中有用竖直应用程序需要异构且范围极其广泛的数据，包括至少一个数据存储区，其包含对含义编码的机器可读数据表示。

[0501] （2）根据条款1所述的系统，其中有用竖直应用程序是可操作为自动将候选人与工作匹配的应用程序或健康应用程序或会计应用程序或聊天机器人或语音助手。

[0502] （3）根据条款1或条款2所述的系统，其中机器可读数据表示是机器语言，其包括表示实体的语义节点的组合，其中含义来自语义节点的选择及其组合的方式。

[0503] （4）根据条款3所述的系统，其中系统进一步可操作为从远程系统接收实体的描述并使用该描述以返回对应于实体的语义节点。

[0504] （5）根据前述条款中任一项所述的系统，其中数据包括可用于应用程序的计算能力的表示。

[0505] （6）根据前述条款中任一项所述的系统，其中系统进一步可操作为实现自动识别用于从数据存储区去除的数据。

[0506] （7）根据前述条款中任一项所述的系统，其中系统进一步可操作为参考至少一个数据存储区的内容进行推理，其中生成新有用数据以用于有用竖直应用程序。

[0507] （8）根据条款7所述的系统，其中新有用数据被存储，使新有用数据能够在未来使用而无需进一步推理。

[0508] （9）根据条款6所述的系统，其中使用与来自应用程序用户的数据的真实性或实用性的相关的信号的分析来实现自动识别用于从数据存储区去除的数据。

[0509] 原则驱动的智能系统 （1）一种系统，其包括包含机器可读原则的至少一个数据存储区，该原则表示指导系统的目的和规则，并且其中系统进一步可操作为通过参考原则来进行符合原则的动作。

[0510] （2）根据条款1所述的系统，其中系统进一步可操作为针对原则检查潜在动作并确定潜在动作符合原则。

[0511] （3）根据条款1或条款2所述的系统，其中系统进一步可操作为通过参考原则来提议符合原则的动作。

[0512] （4）根据前述条款中任一项所述的系统，其中动作包括以书面形式与用户进行通信。

[0513] （5）根据前述条款中任一项所述的系统，其中动作包括以口头形式与用户进行通信。

[0514] （6）根据前述条款中任一项所述的系统，其中原则包括系统应尝试最大化的至少一个度量。

[0515] （7）根据条款6所述的系统，其中至少一个度量包括用户幸福度。

[0516] （8）根据前述条款中任一项所述的系统，其中原则包括系统应尝试最小化的至少一个度量。

[0517] （9）根据条款8所述的系统，其中至少一个度量包括用户不幸度。

[0518] （10）根据前述条款中任一项所述的系统，其中原则包括针对系统绝不能进行的动作的至少一个规则，并且其中系统进一步可操作为通过参考原则来避免进行系统绝不能进行的动作。

[0519] （11）根据前述条款中任一项所述的系统，其中原则包括：在定义情况下进行什么动作的至少一个建议。

[0520] （12）根据前述条款中任一项所述的系统，其中动作包括访问其他远程计算机系统。

[0521] （13）根据前述条款中任一项所述的系统，其中动作包括改变经由网络链接到系统的设备的状态。

[0522] （14）根据前述条款中任一项所述的系统，其中动作包括发起与人类的口头交互。

[0523] （15）根据前述条款中任一项所述的系统，其中系统进一步包括至少一个数据存储区，该数据存储区包含对含义进行编码的世界的机器可读表示，并且其中系统进一步可操作为参考世界的机器可读表示进行推理以选择符合原则的动作。

[0524] （16）根据条款15所述的系统，其中世界的机器可读表示包括有效推理步骤的表示，并且其中系统进一步可操作为利用有效推理步骤的表示进行推理。

[0525] （17）根据条款15或条款16所述的系统，其中世界的机器可读表示包括可用于系统的计算能力的表示，并且其中系统进一步可操作为通过参考机器可读表示来利用计算能力。

[0526] （18）根据条款15、16或17所述的系统，其中系统可操作为学习和扩充世界的机器可读表示。

[0527] （19）根据条款18所述的系统，其中系统可操作为从与至少一个用户的通信学习。

[0528] （20）根据条款18所述的系统，其中系统可操作为从经由网络连接到系统的至少一个外部传感器学习。

[0529] （21）根据前述条款中任一项所述的系统，其中机器可读原则至少部分地由标识符的组合表示，并且其中标识符中的至少一些表示对应于现实世界事物的概念。

[0530] （22）根据条款21所述的系统，其中系统进一步可操作为从远程系统接收概念的描述并使用描述以返回可能意指该概念的标识符。

[0531] （23）根据前述条款中任一项所述的系统，其中系统可操作为以导致符合原则的动作的方式持续推理。

[0532] （24）根据前述条款中任一项所述的系统，其中系统可操作为回答来自人类用户的关于原则的问题。

[0533] 由原则驱动的智能系统#2 （1）一种计算机系统，其包括长期存储器；短期存储器；原则存储区，其包含表示指导系统的规则的机器可读原则，并且其中计算机系统可操作为接收事件并且利用事件、长期存储器的内容、短期存储器的内容和原则以进行符合原则的动作。

[0534] （2）根据条款1所述的计算机系统，其中事件包括来自至少一个用户的通信并且其中动作包括与至少一个用户的通信。

[0535] （3）根据前述条款中任一项所述的计算机系统，其中系统进一步可操作为进行学习，并将该系统学习到的内容存储到长期存储器。

[0536] （4）根据前述条款中任一项所述的计算机系统，其中计算机系统不可操作为改变原则。

[0537] （额外的安全示例：） （5）根据条款4所述的计算机系统，其中原则包括禁止可能导致改变原则的动作的原则。

[0538] （6）根据前述条款中任一项所述的计算机系统，其中系统进一步可操作为进行针对原则对每个潜在动作进行独立检查，并且如果独立检查发现其与原则不兼容，则将丢弃该潜在动作。

[0539] （7）根据前述条款中任一项所述的计算机系统，其进一步可操作为主动排除关于其自身的知识用于确定动作。

[0540] 翻译 （1）一种生成一段自然语言的机器可读语义表示的方法，包括将自然语言的段落传递通过序列到序列神经架构，该神经架构根据包含成对的自然语言和对含义进行编码的对应的结构化表示的训练数据进行了训练。

[0541] （2）根据条款1所述的方法，其中神经架构包括编码器和解码器，并且其中该方法包括以下进一步的步骤：在对来自解码器的语义表示进行解码期间使用集束搜索以去除无效语义表示。

[0542] （3）根据条款1或条款2所述的方法，其中该段自然语言是问题，并且其中该方法进一步包括以下步骤：参考语义表示回答问题。

[0543] （4）根据条款1或条款2所述的方法，其中该段自然语言是一个或多个文档，并且其中该方法进一步包括以下步骤：利用一个或多个文档的语义表示来回答问题。

[0544] （5）根据条款3或条款4所述的方法，其中该方法进一步包括以下步骤：参考语义表示进行推理以产生在此步骤之前不存在的进一步表示。

[0545] 工作匹配应用程序 （1）一种系统，其可操作为将候选人与空缺工作匹配，包括至少一个数据存储，该数据存储包含： 多个候选人简历，其中候选人简历中的至少一些的至少一些部分是对含义进行编码的结构化机器可读形式； 空缺角色的多个工作规范，其中工作规范中的至少一些的至少一些部分以对含义进行编码的结构化机器可读形式存储，并且 其中，系统进一步可操作为将多个候选人简历与多个工作规范匹配以识别候选人和空缺角色之间的高置信度匹配。

[0546] （2）根据条款1所述的系统，其中结构化机器可读形式是通过创建标识符的组合来表示含义的语言，并且其中标识符中的至少一些表示人类技能和经验。

[0547] （3）根据前述条款中任一项所述的系统，其中至少一个数据存储区进一步存储至少部分以结构化机器可读形式表示的候选人的期望角色的表示，并且其中系统进一步可操作为将空缺角色与候选人的期望角色的表示匹配，以改善候选人与空缺角色之间的匹配。

[0548] （4）根据前述条款中任一项所述的系统，其中系统进一步可操作为当找到高置信度匹配时向移动设备发送推送通知。

[0549] （5）根据前述条款中任一项所述的系统，其中系统进一步可操作为通过生成工作规范的哪些部分与候选人的技能和经验匹配的解释来解释候选人如何匹配角色。

[0550] （6）根据条款5所述的系统，其中以自然语言进行解释。

[0551] （7）根据前述条款中任一项所述的系统，其中系统可操作为将工作规范中的要求与候选人的技能和经验匹配，其中候选人简历和工作规范的自然语言版本的相关部分之间没有共同关键字。

[0552] （8）根据前述条款中任一项所述的系统，其中系统可操作为进行一系列逻辑推理步骤，以将候选人的技能或经验与工作规范中的要求匹配。

[0553] 健康应用程序 （1）一种用于管理一个或多个人的一组广泛健康数据的系统，其中健康数据中的至少一些以结构化机器可读形式表示，该结构化机器可读形式对存储在一个或多个数据存储区中的含义进行编码。

[0554] （2）根据条款1所述的系统，其中健康数据包括关于已经被一个或多个人中的至少一个消耗的食物或饮料的营养数据。

[0555] （3）根据条款2所述的系统，其中营养数据包括表示关于所消耗的东西的量或成分的不确定性的数据。

[0556] （4）根据前述条款中任一项所述的系统，其中健康数据包括关于下列项的数据：血液测试或测量的结果或身体成分或活动信息或遗传数据或微生物组数据或排便事件或睡眠数据或锻炼数据或活动数据或疾病症状或人类心情或月经或药物摄入或医疗状况或来自任何可穿戴设备的数据。

[0557] （5）根据前述条款中任一项所述的系统，其中系统进一步可操作为经由文本与一个或多个用户对话。

[0558] （6）根据前述条款中任一项所述的系统，其中系统进一步可操作为使选择的其他人能够与一个或多个用户对话并使选择的其他人能够查看相关健康数据。

[0559] （7）根据前述条款中任一项所述的系统，其中系统进一步可操作为一起创建具体类型的健康数据的曲线图，其中用户可以看到不同数据如何相关。

[0560] （8）根据前述条款中任一项所述的系统，其中系统进一步可操作为分析健康数据以揭示与具体用户的健康相关的见解。

[0561] （9）根据前述条款中任一项所述的系统，其中见解包括潜在饮食不耐受或影响睡眠的行为。

[0562] （10）根据前述条款中任一项所述的系统，其中组合健康数据的元素以计算健康数据中尚未存在的附加健康数据项。

[0563] （11）根据条款10所述的系统，其中附加健康数据项是特定时间用户体内存在的咖啡因的估计值。

[0564] 会计应用程序 （1）用于管理至少一个企业的会计数据的系统，其中会计数据中的至少一些以结构化机器可读格式表示，该格式对存储在一个或多个数据存储区内的现实世界含义进行编码。

[0565] （2）根据条款1所述的系统，其中结构化机器可读格式包括标识符的组合，其中标识符中的至少一些表示与至少一个企业的活动相关的现实世界实体，并且其中进一步的含义根据标识符的组合的选择进行编码。

[0566] （3）根据前述条款中任一项所述的系统，其中系统可操作为以多个不同会计标准自动呈现会计数据。

[0567] （4）根据前述条款中任一项所述的系统，其中系统可操作为回答关于至少一个企业的活动的问题。

[0568] 隐私增强的语音助手 （1）一种由系统提供商提供的用于经由语音用户界面向至少一个用户提供服务的系统，其包括至少一个用户本地的至少一个设备，其中至少一个设备可操作为将声音数据流式传输到一个或多个远程数据存储区，其中声音数据使用加密方法加密地存储在一个或多个远程数据存储区内，其中需要至少两个不同加密密钥中的至少两个来读取声音数据。 （2）根据条款1所述的系统，其中至少两个不同加密密钥中的第一个保持在用户本地的至少一个设备内，并且其中至少两个不同加密密钥中的第二个由系统提供商保持。

[0569] （3）根据条款2所述的系统，其中不同加密密钥的数量是至少三个，并且其中不同加密密钥中的第三个由不同于用户和系统提供商两者的实体保持。

[0570] （4）根据前述条款中任一项所述的系统，其可操作为流式传输来自至少一个设备的一般声音并利用从一般声音学习的信息来改善其对至少一个用户的价值。

[0571] 增强隐私模式 一种用第一唤醒单词发起的具有语音用户界面的系统，其中系统可操作为进入需要第二唤醒单词的隐私保护状态并且其中第二唤醒单词足够长或不寻常以至于相对于第一唤醒单词，错误辨识第二唤醒单词的可能性要小得多。

[0572] 多语音助手系统 （1）一种系统，其可操作为向多个用户递送多个不同语音助手的体验，该系统包括包含个性信息的至少一个数据存储区，该个性信息确定多个不同语音助手中的至少一些语音助手的个性。

[0573] （2）根据条款1所述的系统，其中个性信息包括关于下列项的信息：语音助手的性别或名字或语音或心情或情绪反应或正式程度或在外向-内向量表上的位置或在任何迈尔斯布里格斯量表上的位置或迈尔斯布里格斯分类或个性测试或视觉外观中的分类。

[0574] （3）根据前述条款中任一项所述的系统，其中至少一个数据存储区进一步包括至少一组机器可读原则，其表示指导多个语音助手中的至少一些语音助手的目的和规则，并且其中系统进一步可操作为通过参考原则进行符合原则的动作。

[0575] （4）根据条款3所述的系统，其中至少一组机器可读原则是多组机器可读原则，并且其中多个不同语音助手中选择的语音助手被映射到多组机器可读原则中选择的机器可读原则，其中不同语音助手由不同原则驱动。

[0576] （5）根据前述条款中任一项所述的系统，其中至少一个数据存储区还包括仅由多个不同语音助手中选择的语音助手访问的私用用户数据。

[0577] 示例用例 在示例中，本发明的示例可以用于以下应用程序： •任何基于语言的人机界面（口头或文本形式），其中机器用户体验以UL表达。

[0578] •将网页转换为UL以进行搜索和分析（例如，在极限中，所有网页）。

[0579] •将所有地图（尤其是自主驾驶所需的超高分辨率地图和相关元数据）转换为UL。

[0580] •针对以UL表达的地图数据进行基于位置的搜索。

[0581] •基于以UL表达的他们的社交媒体简档识别相关广告和新闻以服务于某人。

[0582] •基于以UL表达的他们的网络搜索和网络浏览历史来识别相关广告和新闻以服务于某人。

[0583] •基于以UL表达的相似的社交媒体或工作简档建议潜在朋友或联系人。

[0584] •识别社交媒体上的全部转换为UL的辱骂性帖子。

[0585] •识别具有国家安全或犯罪影响的全部转换为UL的消息和帖子。

[0586] •分析全部转换为UL的顾客评论和反馈。

[0587] •分析全部转换为UL的购物请求，以针对以UL表达的产品数据库识别匹配的产品。

[0588] •根据分析全部转换为UL的网页来自动回答问题。

[0589] •约会网站，其基于匹配转换为UL的简档，或识别指示兼容性的其他相关性。

[0590] •从转换为UL的源文档生成概要，例如新闻概要。

[0591] 注意 应当理解，上面参考的布置仅是对本发明的原理的应用的说明。在不脱离本发明的精神和范围的情况下，可以设计出许多修改和替代布置。虽然本发明已在附图中示出并在上文中结合目前被认为是本发明的（一个或多个）最实用和优选示例的特性和细节进行了全面描述，但对于本发明的普通技术人员而言将显而易见的是，在不脱离本文阐述的本发明的原理和概念的情况下，可以进行许多修改。

[0592] 附录1 关键概念 本附录1汇总了本说明书中公开的关键概念。我们将这些关键概念分为以下14个类别： 概念 A. 用于消除节点的组合的歧义的括弧 B. 跨事实、查询和推理的共享句法 C. 节点的嵌套 D. ID选择 E. 任何客户可以生成语义节点或段落 F. 综合通用语言（UL）概念 G. 问题回答 H. 学习 I. 翻译到UL和从UL翻译 J. 语义节点决议 K. 自然语言之间的翻译 L. 语音助手 M. 原则 N. 用例： N1： 人机界面 N2： 文档或网页的搜索和分析。

[0593] N3. 表示为UL的地图数据、利用地图数据和基于位置的搜索的相关联的系统 N4. 识别相关广告和新闻 N5. 新闻的聚合与汇总 N6. 使用UL在人之间匹配 N7. 识别社交媒体中的辱骂性或不真实帖子 N8. 顾客评论的分析 N9. 购物查询和产品请求 N.10 工作匹配 N.11 水平健康应用程序 N.12 会计 N.13 语音助手 / 聊天机器人 注意，任何概念A-N都可以与任何一个或多个其他概念A-N组合，并且任何概念A-N都可以与来自任何一个或多个其他概念A-N的任何一个或多个可选特征组合。

[0594] 我们将这些概念中的每一个定义如下： 机器可读语言：语义节点和段落 A. 用于消除节点的组合的歧义的括弧 UL模型使用括弧中的节点组合作为用于表示无歧义的含义的唯一或主要机制，但仍然实现了巨大的表达能力。与存在激增的不同消歧机制的其他方法相比，这使得能够更快地处理UL。它还简化了存储，使得能够更快地搜索和访问。与其他语言相比，它还可以使编写UL更快，并且因此扩大采用率。它还降低了复杂性，并且因此使该技术的许多应用成为可能。

[0595] 我们可以概括为： 一种用于自动分析或使用数据的计算机实施的方法，包括以下步骤： （a）在存储器中存储符合机器可读语言的数据的结构化机器可读表示，其中结构化机器可读表示包括单个语法项以消除数据的结构化表示的含义的歧义； （b）自动处理结构化机器可读表示以用于下列项中的一种或多种：导出事实或关系；推理；学习；翻译；回答问题；处理自然语言内容；实现人机交互；表示和监管规则或原则；实现一个或多个竖直应用程序。

[0596] 被配置为分析数据的基于计算机的系统，该系统被配置为： （a）在存储器中存储符合机器可读语言的数据的结构化机器可读表示，其中结构化机器可读表示包括单个语法项以消除含义的歧义； （b）自动处理结构化机器可读表示以用于下列项中的一种或多种：导出事实或关系；推理；学习；翻译；回答问题；处理自然语言内容；实现人机交互；表示和监管规则或原则；实现一个或多个竖直应用程序。

[0597] 在优选实施方式中，符合机器可读语言的数据的结构化机器可读表示包括语义节点和段落； 并且其中，语义节点表示实体并且其本身由标识符表示；并且段落是（i）语义节点或者是（ii）语义节点的组合；并且其中机器可读含义来自语义节点的选择以及语义节点被组合和排序为段落的方式。

[0598] 其他可选特征 •用于消除含义的歧义的单个语法项是括号或括弧。

[0599] •用于消除含义的歧义的单个语法项是用于消除数据的结构化机器可读表示的不同组合的含义的歧义的仅有的语法项。

[0600] •用于消除数据的结构化机器可读表示的不同组合的含义的歧义的单个语法项是消除组合的含义的歧义的主要语法项。

[0601] •用于消除含义的歧义的单个语法项表示数据的结构化机器可读表示的嵌套。

[0602] •用于消除含义的歧义的单个语法项表示语义节点和段落的嵌套。

[0603] •用于消除含义的歧义的单个语法项表示语义节点和段落到任意深度的嵌套。

[0604] •用于消除含义的歧义的单个语法项要求语义节点和段落只能以嵌套组合进行组合。

[0605] •用于消除含义的歧义的单个语法项允许表达式被无限期嵌套，以允许用户将概念连同关于概念的上下文信息一起定义为语义节点的层次结构。

[0606] •用于消除含义的歧义的单个语法项允许组合语义节点包含任意有限数量的语义节点，并且这些组合节点内的语义节点也可以是创建任意级别的嵌套的组合节点。

[0607] •数据的结构化机器可读表示的句法符合或基本符合生产文法" <passage> ::= <id> | <passage> ::=( <passage> <passage> *)”，其中" <passage> *”表示零个或一个或多个进一步的段落，并且其中 <id> 是语义节点的标识符。

[0608] B. 跨事实、查询和推理的共享句法 UL模型使用适用于表示事实陈述、查询陈述和推理陈述的语义节点和段落的共享句法。与存在激增的不同句法的其他方法相比，这使得能够更快地处理UL。与其他语言相比，它还可以使编写UL更快，并且因此扩大采用率。它还简化了存储，使得能够更快地搜索和访问。它还降低了复杂性，并且因此增加了本发明的许多应用的可行性。

[0609] 我们可以概括为： 一种用于自动分析或使用数据的计算机实施的方法，包括以下步骤： （a）在存储器中存储符合机器可读语言的数据的结构化机器可读表示，其中该语言具有句法，该句法是适用于表示事实陈述、查询陈述和推理陈述的段落的单个共享句法； （b）自动处理结构化机器可读表示以用于下列项中的一种或多种：导出事实或关系；推理；学习；翻译；回答问题；处理自然语言内容；实现人机交互；表示和监管规则或原则；实现一个或多个竖直应用程序。

[0610] 被配置为分析数据的基于计算机的系统，该系统被配置为： （a）在存储器中存储符合机器可读语言的数据的结构化机器可读表示，其中该语言具有句法，该句法是适用于表示事实陈述、查询陈述和推理陈述的段落的单个共享句法； （b）自动处理结构化机器可读表示以用于下列项中的一种或多种：导出事实或关系；推理；学习；翻译；回答问题；处理自然语言内容；实现人机交互；表示和监管规则或原则；实现一个或多个竖直应用程序。

[0611] 在优选实施方式中，符合机器可读语言的数据的结构化机器可读表示包括语义节点和段落； 并且其中，语义节点表示实体并且其本身由标识符表示；并且段落是（i）语义节点或者是（ii）语义节点的组合；并且其中机器可读含义来自语义节点的选择以及语义节点被组合和排序为段落的方式。

[0612] 其他可选特征： •句法适用于数据的所有结构化机器可读表示。

[0613] •句法是包括数据的结构化机器可读表示的嵌套的简单无歧义句法。

[0614] •句法是包括数据的结构化机器可读表示到任意深度的嵌套的简单无歧义句法。

[0615] •句法是简单无歧义句法，其中数据的结构化机器可读表示只能以嵌套组合进行组合。

[0616] •句法允许表达式被无限嵌套以允许用户将概念连同关于概念的上下文信息一起定义为数据的语义结构化机器可读表示的层次结构。

[0617] •数据的结构化机器可读表示的组合可以包含任意有限数量的数据的结构化机器可读表示，从而创建任意级别的嵌套。

[0618] •数据的结构化机器可读表示是语义节点或段落。

[0619] •语义节点用UUID识别。

[0620] C. 节点的嵌套 UL模型使用无歧义句法，该句法包括语义节点和段落（即数据的结构化机器可读表示）的嵌套。相比于使用自然语言，这种歧义的缺乏使机器能够以所表示的事物的确定性处理和利用存储在该模型中的数据。

[0621] 我们可以进一步概括为： 一种用于自动分析或使用数据的计算机实施的方法，包括以下步骤： （a）在存储器中存储符合机器可读语言的数据的结构化机器可读表示，其中机器可读语言的句法是基本无歧义句法，该句法包括数据的结构化机器可读表示的嵌套； （b）自动处理结构化机器可读表示以用于下列项中的一种或多种：导出事实或关系；推理；学习；翻译；回答问题；处理自然语言内容；实现人机交互；表示和监管规则或原则；实现一个或多个竖直应用程序。

[0622] 被配置为分析数据的基于计算机的系统，该系统被配置为： （a）在存储器中存储符合机器可读语言的数据的结构化机器可读表示，其中该语言具有句法，其中机器可读语言的句法是基本无歧义句法，该句法包括数据的结构化机器可读表示的嵌套； （b）自动处理结构化机器可读表示以用于下列项中的一种或多种：导出事实或关系；推理；学习；翻译；回答问题；处理自然语言内容；实现人机交互；表示和监管规则或原则；实现一个或多个竖直应用程序。

[0623] 在优选实施方式中，符合机器可读语言的数据的结构化机器可读表示包括语义节点和段落； 并且其中，语义节点表示实体并且其本身由标识符表示；并且段落是（i）语义节点或者是（ii）语义节点的组合；并且其中机器可读含义来自语义节点的选择以及语义节点被组合和排序为段落的方式。

[0624] 其他可选特征： •句法是包括数据的结构化机器可读表示到任意深度的嵌套的简单无歧义句法。

[0625] •句法是简单无歧义句法，其中数据的结构化机器可读表示只能以嵌套组合进行组合。

[0626] •句法允许表达式被无限嵌套以允许用户将概念连同关于概念的上下文信息一起定义为数据的语义结构化机器可读表示的层次结构。

[0627] •数据的结构化机器可读表示的组合可以包含任意有限数量的数据的结构化机器可读表示，从而创建任意级别的嵌套。

[0628] •数据的结构化机器可读表示是语义节点或段落。

[0629] •语义节点用UUID识别。

[0630] D. ID选择 UL模型使用选自地址空间的语义节点标识符，该地址空间足够大以使得用户能够选择新标识符，而选择到先前分配的标识符的风险可忽略不计。这使得用户能够将本发明与本地数据一起使用而无需与任何其他用户协调，同时还受益于对一个以上用户具有含义的共享节点。

[0631] 我们可以概括为： 一种用于自动分析或使用数据的计算机实施的方法，包括以下步骤： （a）在存储器中存储符合机器可读语言的数据的结构化机器可读表示，其中数据的结构化机器可读表示包括选自地址空间的多个标识符，该地址空间足够大以使得用户能够选择新标识符，而选择到先前分配的标识符的风险可忽略不计； （b）自动处理结构化机器可读表示以用于下列项中的一种或多种：导出事实或关系；推理；学习；翻译；回答问题；处理自然语言内容；实现人机交互；表示和监管规则或原则；实现一个或多个竖直应用程序。

[0632] 被配置为分析数据的基于计算机的系统，该系统被配置为： （a）在存储器中存储符合机器可读语言的数据的结构化机器可读表示，其中数据的结构化机器可读表示包括选自地址空间的多个标识符，该地址空间足够大以使得客户实体能够选择新标识符，而选择到先前分配的标识符的风险可忽略不计； （b）自动处理结构化机器可读表示以用于下列项中的一种或多种：导出事实或关系；推理；学习；翻译；回答问题；处理自然语言内容；实现人机交互；表示和监管规则或原则；实现一个或多个竖直应用程序。

[0633] 在优选实施方式中，符合机器可读语言的数据的结构化机器可读表示包括语义节点和段落； 并且其中，语义节点表示实体并且其本身由标识符表示；并且段落是（i）语义节点或者是（ii）语义节点的组合；并且其中机器可读含义来自语义节点的选择以及语义节点被组合和排序为段落的方式。

[0634] 其他可选特征： •语义节点一旦被定义就具有标识符或ID。

[0635] •标识符选自地址空间，该地址空间足够大以使得客户实体能够独立于其他客户实体选择新标识符而不重复。

[0636] •标识符选自地址空间，该地址空间足够大以使得客户实体能够选择新标识符，而选择到先前分配的标识符的风险可忽略不计。

[0637] •标识符或ID是UUID。

[0638] •ID是具有带连字符的小写句法的128位版本4 UUID（RFC 4122）。

[0639] •ID是UUID或字符串，诸如Unicode字符串。

[0640] •字符串可以将其自身标记为数据的结构化机器可读表示，并且其含义严格而言只是字符串本身并且被包含在字符串内的任何自然语言含义不是字符串的含义的一部分。 •字符串由ID表示作为附加标识符。 •字符串被表示为UUID或其他数字ID，并且单独的段落将字符串链接到该数字ID以提供其含义。

[0641] •用作数据的结构化机器可读表示的两个相同字符串具有与该字符串通用的意义。

[0642] •任何用户都可以通过挑选未使用的标识符来用其自己的本地含义创造其自己的数据的结构化机器可读表示。

[0643] •任何用户都可以为语义节点创造自己的标识符，即使另一个标识符已经用于语义节点。

[0644] •任何用户自由地对数据的结构化机器可读表示的组合定义其自己的含义。

[0645] •对于相同的具体单词、概念或其他事物，可以存在多个不同的数据的结构化机器可读表示。

[0646] •选择创建使用共享的数据的结构化机器可读表示的段落的任何用户也通过组合它们来表达相同含义，使得组合共享的数据的结构化机器可读表示所带来的含义是通用的。 •字典中每个单词的每个意义由数据的结构化机器可读表示进行表示。

[0647] •"共享ID”是由一个以上用户使用的ID；"私用ID”或"本地ID”类似地是仅由一个用户使用的ID并且不被发布或暴露给其他用户；"公用ID”是用户已经在每个用户都可以看到的UL中使用的ID。

[0648] •语义节点是数据的结构化机器可读表示，一旦被定义就具有标识符，从而可以在机器可读语言中被引用。 •段落是表达含义的语义节点的组合，并且是独有嵌套结构。

[0649] •无限类中的语义节点可以被表示为多个其他节点的组合。

[0650] E. 任何客户可以生成语义节点或段落 UL模型使用选自地址空间的语义节点标识符，该地址空间足够大以使得用户能够选择新标识符，而选择到先前分配的标识符的风险可忽略不计。与其他语言相比，这使得创建UL更快、更容易，并且因此扩大采用率。它还使用户能够将该技术应用于他们的本地数据，同时仍然受益于其他用户生成的段落和实施方式。

[0651] 我们可以概括为： 一种用于自动分析或使用数据的计算机实施的方法，包括以下步骤： （a）在存储器中存储符合机器可读语言的数据的结构化机器可读表示，并且其中机器可读语言是可扩展的，因为对于哪些用户可以创建数据的结构化机器可读表示或相关标识符没有限制； （b）自动处理结构化机器可读表示以用于下列项中的一种或多种：导出事实或关系；推理；学习；翻译；回答问题；处理自然语言内容；实现人机交互；表示和监管规则或原则；实现一个或多个竖直应用程序。

[0652] 被配置为分析数据的基于计算机的系统，该系统被配置为： （a）在存储器中存储符合机器可读语言的数据的结构化机器可读表示，并且其中机器可读语言是可扩展的，因为对于哪些用户可以创建数据的结构化机器可读表示或相关标识符没有限制； （b）自动处理结构化机器可读表示以用于下列项中的一种或多种：导出事实或关系；推理；学习；翻译；回答问题；处理自然语言内容；实现人机交互；表示和监管规则或原则；实现一个或多个竖直应用程序。

[0653] 在优选实施方式中，符合机器可读语言的数据的结构化机器可读表示包括语义节点和段落； 并且其中，语义节点表示实体并且其本身由标识符表示；并且段落是（i）语义节点或者是（ii）语义节点的组合；并且其中机器可读含义来自语义节点的选择以及语义节点被组合和排序为段落的方式。

[0654] 其他可选特征： •机器可读语言是通用语言，对于该通用语言，基本上以自然语言可表达的任何事物都可表达为数据的结构化机器可读表示或数据的结构化机器可读表示的组合。

[0655] •数据的结构化机器可读表示表示具体实体，诸如单词、概念或其他事物，并且一旦生成，该机器可读表示就以通用语言唯一地识别该具体单词、概念或其他事物。

[0656] •数据的结构化机器可读表示的经排序或部分排序的集合捕获具体含义或语义内容。

[0657] •数据的结构化机器可读表示的含义来自以机器可读语言编写的陈述。

[0658] •数据的结构化机器可读表示的含义来自表示关于数据的结构化机器可读表示已经说过的事物的其他的数据的结构化机器可读表示。

[0659] •表示实体的语义节点通过到相关单词、概念、其他术语或逻辑过程的数据的结构化机器可读表示的链接来对该实体的语义含义编码。

[0660] •组合数据的结构化机器可读表示以机器可读语言生成具有新含义或语义内容的新单词、概念或其他术语。

[0661] •机器可读语言是人类用户可理解的，其对应于自然语言形式的等同陈述。 •机器可读语言是可扩展的，因为任何自然语言单词、概念或其他事物都可以由数据的结构化机器可读表示进行表示。

[0662] •机器可读语言是可扩展的，因为对于哪些用户可以创建数据的结构化机器可读表示没有限制。

[0663] •语义节点是数据的结构化机器可读表示，一旦被定义就具有标识符，从而可以在机器可读语言中被引用。 •段落是表达含义的语义节点的组合，并且是独有嵌套结构。

[0664] F. 综合UL概念 我们可以将上述概念结合在一起，如下： 一种用于自动分析或使用数据的计算机实施的方法，包括以下步骤： （a）在存储器中存储符合机器可读语言的数据的结构化机器可读表示，其中下列项中的一种或多种适用： 单个语法项用于消除数据的结构化表示的含义的歧义； 机器可读语言的句法是适用于表示事实陈述、查询陈述和推理陈述的段落的单个共享句法； 机器可读语言的句法是基本无歧义句法，该句法包括数据的结构化表示的嵌套； 数据的结构化表示包括选自地址空间的标识符，该地址空间足够大以使得用户能够选择新标识符，而选择到先前分配的标识符的风险可忽略不计； 机器可读语言是可扩展的，因为对于哪些用户可以创建数据的结构化表示或相关标识符没有限制； （b）自动处理数据的结构化表示以用于下列项中的一种或多种：导出事实或关系；推理；学习；翻译；回答问题；处理自然语言内容；实现人机交互；表示和监管规则或原则；实现一个或多个竖直应用程序。

[0665] 被配置为分析数据的基于计算机的系统，该系统被配置为： （a）在存储器中存储或从存储器访问符合机器可读语言的数据的结构化机器可读表示，该结构化机器可读表示包括语义节点和段落，其中下列项中的一种或多种适用： 单个语法项用于消除数据的结构化表示的含义的歧义； 机器可读语言的句法是适用于表示事实陈述、查询陈述和推理陈述的段落的单个共享句法； 机器可读语言的句法是基本无歧义句法，该句法包括数据的结构化表示的嵌套； 数据的结构化表示包括选自地址空间的标识符，该地址空间足够大以使得用户能够选择新标识符，而选择到先前分配的标识符的风险可忽略不计； 机器可读语言是可扩展的，因为对于哪些用户可以创建数据的结构化表示或相关标识符没有限制； （b）自动处理数据的结构化表示以用于下列项中的一种或多种：导出事实或关系；推理；学习；翻译；回答问题；处理自然语言内容；实现人机交互；表示和监管规则或原则；实现一个或多个竖直应用程序。

[0666] 在优选实施方式中，符合机器可读语言的数据的结构化机器可读表示包括语义节点和段落； 并且其中，语义节点表示实体并且其本身由标识符表示；并且段落是（i）语义节点或者是（ii）语义节点的组合；并且其中机器可读含义来自语义节点的选择以及语义节点被组合和排序为段落的方式。

[0667] G. 问题回答 UL模型实现自动回答问题：问题由段落或语义节点的组合表示，并且回答可以通过三个不同过程自动生成：将问题与先前存储在段落存储器存储区中的段落匹配；（ii）获取并执行一个或多个计算单元，其中计算单元表示与回答问题相关的计算能力；（iii）获取并执行一个或多个推理段落，这些推理段落表示与回答问题相关的潜在适用推理步骤的语义。这种方法使高度可扩展、快速、准确、基于语义的问题回答成为可能。问题可以来自机器；或在将自然语言问题翻译成UL并将响应翻译回自然语言后来自人类用户。我们可以概括如下： 一种用于自动分析或使用数据的计算机实施的方法，包括以下步骤： （a）在存储器中存储符合机器可读语言的数据的结构化机器可读表示，并且其中问题在存储器中表示为数据的结构化机器可读表示；以及 （b）使用以下步骤中的一个或多个步骤自动生成对问题的响应：（i）将问题与先前存储在存储器存储区中的数据的结构化机器可读表示匹配；（ii）获取并执行一个或多个计算单元，其中计算单元表示与回答问题相关的计算能力；（iii）获取并执行一个或多个推理段落，这些推理段落是表示与回答问题相关的潜在适用推理步骤的语义的数据的结构化机器可读表示； 并且其中，问题的表示、先前存储在存储器存储区中的数据的结构化机器可读表示、计算单元和推理段落全部以基本相同的机器可读语言表示。 被配置为分析数据的基于计算机的系统，该系统被配置为： （a）在存储器中存储符合机器可读语言的数据的结构化机器可读表示，并且其中问题在存储器中表示为数据的结构化机器可读表示；以及 （b）使用以下步骤中的一个或多个步骤自动生成对问题的响应：（i）将问题与先前存储在存储器存储区中的数据的结构化机器可读表示匹配；（ii）获取并执行一个或多个计算单元，其中计算单元表示与回答问题相关的计算能力；（iii）获取并执行一个或多个推理段落，这些推理段落是表示与回答问题相关的潜在适用推理步骤的语义的数据的结构化机器可读表示 并且其中，问题的表示、先前存储在存储器存储区中的数据的结构化机器可读表示、计算单元和推理段落全部以基本相同的机器可读语言表示。 在优选实施方式中，数据的结构化机器可读表示符合包括语义节点和段落的机器可读语言； 并且其中，语义节点表示实体并且其本身由标识符表示；并且段落是（i）语义节点或者是（ii）语义节点的组合；并且其中机器可读含义来自语义节点的选择以及语义节点被组合和排序为段落的方式。

[0668] 其他可选特征： 推理 •推理通过回答一系列一个或多个查询以查看推理步骤是否有效来进行。

[0669] •推理通过回答一系列一个或多个查询以生成推理的结果所需的结果来进行。

[0670] •段落表示选择和运行计算单元所需的计算单元的详细信息，即：定义计算单元可以做什么、如何运行计算单元以及如何解释结果。

[0671] •获取并执行一个或多个初始推理段落的步骤返回具有需要处理的未知项的其他段落，并且该处理的结果是连接树，该连接树用于给出初始段落的结果。 •存储连接树并且具有未知项的这些其他段落的处理并行发生，从而允许数据获取和对推理的探索并行化。

[0672] •一旦所有段落都被处理到给定的最大推理深度，第二非并行化步骤就被用于遍历经处理的段落和未知映射的树以找到有效回答。 •处理段落列表中的每个段落以识别来自段落存储器存储区和计算单元的有效映射，其中该段落列表的有效映射是以下的映射：所有未知项都具有值并且在列表中的段落之间没有相互矛盾的映射。 •识别有效映射的步骤递归地浏览数据并找到可以作为回答返回的初始问题的所有有效映射。

[0673] •已经从推理或计算中生成的段落中的至少一些段落被存储在段落存储器存储区中，使得这些段落在未来可用于更快的处理。 •还存储这些生成的段落的历史，使得用于生成段落的、段落中的信任级别的变化可以延伸到给予这些生成的段落的信任。

[0674] •还存储这些生成的段落的历史，以使得在用于生成它们的段落中的一个或多个段落的可信状态改变时能够去除生成的段落。

[0675] •当新段落被添加到段落存储器存储区时，该新段落在由普通用户添加时被分配低初始信任值并且在由特权用户添加时被分配较高开始值。 •用下列项以机器可读语言表示问题：包括节点的段落，该节点将该段落识别为问题；表示在问题的语义内请求的零个或一个或多个未知实体的语言；以及表示问题的语义并参考零个或一个或多个未知实体的语言。

[0676] •用下列项以机器可读语言表示问题：形式(Question <unknowns> )( <passage> )的段落，其中Question是语义节点并且 <unknowns> 是表示未知值（在含义上类似于代数中的字母表的字母）的零个或一个或多个语义节点的列表，并且其中 <passage> 是使用未知项来表达所问内容的地方。

[0677] •来自系统或方法的应用程序的信号与应用程序所使用的段落相关联地被存储以保持对段落的值的跟踪。

[0678] •为段落分配值向量，其中每个索引处的数字表示段落的不同质量。 •不同质量包括真实性、实用性和效率。 •使用段落的过程利用优先级向量，其中每个索引处的数字指示它们对该值的优先级。

[0679] •然后可以从向量的点积中获得针对该过程的段落的总值。

[0680] •推理引擎用高值段落和较低值段落进行实验以回答问题，然后监视由推理引擎提供的回答以用于将指示较低值段落是对回答具有正面影响还是负面影响的任何信号，然后该信息反馈到自动监护过程中，该自动监护过程用新信号重新评定段落的值。

[0681] •自动监护过程自动测试段落以确定它们是否应该用于问题回答。

[0682] •先前存储在存储器存储区中的数据的结构化机器可读表示已经用自动方法进行监护。

[0683] •问题是以下翻译的结果：将由用户提问的自然语言翻译成以机器可读语言在语义上基本等同的表示。

[0684] •对问题的响应随后被翻译成在语义上等同的自然语言并呈现给一个或多个用户。

[0685] •问题是以下翻译的结果：将由用户以自然语言说出的问题翻译成以机器可读语言在语义上基本等同的表示，并且随后向用户播放口头回答，其中口头回答是将对问题的响应翻译成自然语言的结果。

[0686] •推理用来从原因与结果的表示中计算动作的结果或其他原因。这可以包括原因与结果的序列或链 •可以回答关于来自因果知识的一个或多个表示的原因与结果的问题 •系统可以具体地回答关于其知道什么和不知道什么的问题 •系统意识到其知道什么和不知道什么并且可以使用这个来确定动作 •系统可以利用其不知道的事物的知识来采取动作以学习缺失的指示，包括通过提问问题从人类用户学习 H. 学习 UL模型实现自动学习。学习的事物可以以UL存储，然后可用于推理、问题回答和本文所述的UL的其他用途和应用程序。这种学习的结果与其中（比如说）非常大的神经网络中的数十亿个权重被调整的统计机器学习形成对比，因为理解了学习到的内容，可以向人类用户解释并且可以进行推理。我们可以概括如下： 一种用于自动分析或使用数据的计算机实施的方法，包括以下步骤： （a）学习新信息并以符合机器可读语言的数据的结构化机器可读表示来表示新信息； （b）将数据的结构化机器可读表示存储在存储器中，并且自动处理数据的结构化表示以用于下列项中的一种或多种：导出事实或关系；推理；学习；翻译；回答问题；处理自然语言内容；实现人机交互；表示和监管规则或原则；实现一个或多个竖直应用程序。 被配置为分析数据的基于计算机的系统，该系统被配置为： （a）学习新信息并以符合机器可读语言的数据的结构化机器可读表示来表示新信息； （b）将数据的结构化机器可读表示存储在存储器中，并且自动处理数据的结构化表示以用于下列项中的一种或多种：导出事实或关系；推理；学习；翻译；回答问题；处理自然语言内容；实现人机交互；表示和监管规则或原则；实现一个或多个竖直应用程序。

[0687] 在优选实施方式中，符合机器可读语言的数据的结构化机器可读表示包括语义节点和段落； 并且其中，语义节点表示实体并且其本身由标识符表示；并且段落是（i）语义节点或者是（ii）语义节点的组合；并且其中机器可读含义来自语义节点的选择以及语义节点被组合和排序为段落的方式。

[0688] 其他可选特征： •学习新信息是从自动处理数据的结构化机器可读表示以获得或学习新信息而获得的，并且新信息本身被表示为存储在存储器中的数据的结构化机器可读表示。

[0689] •学习新信息是从机器学习系统获得的，该机器学习系统生成分类或预测或以数据的结构化机器可读表示进行表示的其他输出。

[0690] •机器学习系统处理语义节点和段落以获得或学习新信息。

[0691] •通过自动处理语义节点和段落以回答问题来生成新信息。

[0692] •问题被表示为一个或多个段落，并且使用以下步骤中的一个或多个步骤自动生成对问题的响应：（i）将问题与先前存储在段落存储器存储区中的段落匹配；（ii）获取并执行一个或多个计算单元，其中计算单元表示与回答问题相关的计算能力；（iii）获取并执行一个或多个推理段落，这些推理段落是表示与回答问题相关的潜在适用推理步骤的语义的段落。

[0693] •表示为语义节点或段落的新信息被存储并用于改善学习新事实的性能。

[0694] •表示为语义节点或段落的新信息被存储并用于改善推理步骤。

[0695] •表示为语义节点或段落的新信息被存储并用于以自然语言解释或描述新信息。

[0696] •表示为语义节点或段落的新信息被存储并用于与人类用户的文本对话或口头对话。

[0697] •学习新信息从与人类用户的对话或由人类用户提供的其他自然语言发生，其中由用户以口头或书面形式提供的自然语言被翻译成语义节点和段落，然后存储和使用由这些语义节点和段落进行表示的新信息。

[0698] •根据推理进行学习，其中从一系列推理步骤生成的语义节点和段落被存储和利用。 •根据自然语言进行学习，其中通过将诸如网页、科学论文或其他文章的自然语言的文档源的全部或部分翻译成语义节点和段落，由此产生的语义节点或段落随后被应用程序使用。 •使用包括包含人类言语的音频记录或视频的自然语言的非文档源，并且首先利用言语辨识技术来创建语音记录的文本转录，然后将文本转录翻译成语义节点或段落。 •机器学习系统用于分析文档和非文档数据并从该数据创建段落。

[0699] •神经网络被端到端训练以将音频或视频数据直接转变为语义节点和段落。 •基于自然语言的学习与统计机器学习组合以优化将文档和非文档数据翻译成语义节点和段落。 •机器学习系统用于生成语义节点或段落。 •机器学习系统是神经网络系统，诸如深度学习系统。

[0700] •机器学习系统已经根据包括自然语言和对应的结构化机器可读表示（诸如包括语义节点和段落的机器可读语言）的训练数据进行训练。

[0701] •使一段自然语言通过根据包括自然语言和对含义进行编码的对应的结构化表示的训练数据进行了训练的序列到序列神经架构。 ...

Claims

1. (A. UL provides input to LLM context) A method for interacting with a large language model (LLM), comprising the following steps: A processing system uses a structured machine-readable representation of data conforming to a machine-readable language, such as a ubiquitous language, to provide new context data to the LLM to improve output, such as continued text output, generated by the LLM in response to prompts.

2. The method of claim 1, comprising injecting the new context data as input into the prompt.

3. The method according to claim 1 or 2, wherein: The LLM provides an output based on the new context data.

4. The method of claim 1 , comprising injecting the new context data as input into the prompt, wherein: The new context data is corrections and / or changes to the continued text output generated by the LLM.

5. The method according to claim 4, wherein: The LLM provides output based on corrections and / or changes to the input of a continuation text output generated by the LLM.

6. A method according to any one of the preceding claims, wherein: The new context data is provided to the LLM as at least part of a prompt.

7. A method according to any one of the preceding claims, wherein: The factual accuracy and / or factual scope of the output is improved by the new contextual data.

8. A method according to any one of the preceding claims, wherein: The internal logical consistency of the output (eg, correct temporal ordering of events) is improved by the new context data.

9. A method according to any one of the preceding claims, wherein: The correspondence of the output generated by the LLM to how people understand or reason in the real world is improved by the new context data.

10. A method according to any one of the preceding claims, wherein: Bias in the output is improved by the new contextual data.

11. A method according to any one of the preceding claims, wherein: The new context data provided to the LLM includes dynamic or real-time information.

12. A method according to any one of the preceding claims, wherein: The new context data provided to the LLM includes reasoned text, for example, text derived from a non-statistical reasoning process.

13. A method according to any one of the preceding claims, wherein: The LLM is answering a question, and the new context data provided to the LLM is the answer to the question.

14. A method according to any one of the preceding claims, wherein: The new context data provided to the LLM is labeled with a degree of certainty or uncertainty, or trust or lack of trust.

15. A method according to any one of the preceding claims, wherein: The new context data provided to the LLM is tagged with a level of simplicity.

16. A method according to any one of the preceding claims, wherein: The new context data provided to the LLM is tagged with a level of formality.

17. A method according to any one of the preceding claims, wherein: The new context data provided to the LLM is marked with the use or non-use of profanity.

18. A method according to any one of the preceding claims, wherein: The new contextual data provided to the LLM is tagged with the age or other details of the person addressed by the LLM.

19. A method according to any one of the preceding claims, wherein: The continuation output from the LLM is translated into the machine-readable language and analyzed for factual inaccuracies or other inconsistencies.

20. A method according to any one of the preceding claims, wherein: The classifier operates to recognize when a cue is likely to result in a continued output where accuracy is important and / or when accuracy is important in the continued output, and then uses the processing system to improve the factual accuracy and / or the factual coverage of the continued output.

21. A method according to any one of the preceding claims, wherein: The continuation output from the LLM is a partial continuation, ie, output that was made before the LLM stopped generating or while the LLM was still generating.

22. A method according to any of the preceding claims, when used to improve one or more parameters of the output of the LLM: the factual accuracy and / or the factual scope of the output; the internal logical consistency of the output (e.g., correct temporal ordering of events); the correspondence of the output generated by the LLM to how people understand or reason in the real world; reduction or removal of bias in the output; and inclusion of dynamic or real-time information.

23. A method according to any of the preceding claims, when used to improve one or more parameters of the output of the LLM: degree of formality, degree of conciseness (e.g., more conciseness when the language is to be spoken), suitability for speaking via a text-to-speech system, other stylistic language, degree of certainty.

24. A method according to any one of the preceding claims, wherein: The LLM is a generative AI based system.

25. A method according to any one of the preceding claims, wherein: The LLM is an autoregressive language model, such as a generative pre-trained Transformer.

26. A method according to any of the preceding claims, when used for any of the following: generation of program code, solutions to any problem that can be described in natural language, generation of poetry, lyrics, creative writing, generation of other forms of writing such as essays, knowledge summaries, long texts, short articles, summaries of scientific papers; Internet searches.

27. A method according to any preceding claim, comprising identifying output content that violates the policy by translating the output into the machine readable language before displaying the output to the user and then checking the machine readable language representation against a predefined policy.

28. (B. Feeding the continuation output of the LLM to the UL engine so that the UL engine generates better output) A method of interacting with a large language model (LLM), comprising the following steps: The continuation data generated by the LLM is provided to a processing system using a structured machine-readable representation of the data conforming to a machine-readable language such as a universal language, wherein the processing system is configured to analyze the continuation output (e.g., textual output) generated by the LLM in response to the prompt to enable an improved version of the continuation output to be provided to a user.

29. The method according to claim 28, wherein: The processing system translates the continuation data (eg, at least some thereof) into the structured machine-readable representation of data to analyze the translated continuation data.

30. The method according to claim 28 or 29, wherein: The processing system analyzes the translated continuation data for, e.g., factual inaccuracies, inconsistencies, and scope, and, where necessary or beneficial, provides corrected output for use in the continuation output presented to a user (e.g., provided by the LLM, e.g., by providing updated prompts through the processing system).

31. The method according to any one of claims 28 to 30, wherein: The processing system analyzes the internal logical self-consistency of the continuation output (eg, correct temporal ordering of events) and, where necessary or beneficial, provides a logically self-consistent output for use in the continuation output provided to a user.

32. The method according to any one of claims 28 to 31, wherein: The processing system analyzes the correspondence between the continuation output generated by the LLM and how people understand the real world or reason about the real world, and, where necessary or beneficial, provides reasoned output corresponding to how people understand the real world or reason about the real world for use in the continuation output provided to the user.

33. The method according to any one of claims 28 to 32, wherein: The processing system analyzes the continued output for bias and, where necessary or beneficial, provides a bias-reduced or bias-free output for use in the continued output provided to a user.

34. A method according to any one of claims 28 to 33, wherein: The processing system analyzes the continuation output for the absence of relevant dynamic or real-time information and, where necessary or beneficial, provides any missing or useful dynamic or real-time information for use in the continuation output provided to the user.

35. The method according to any one of claims 28 to 34, wherein: The processing system analyzes the continuation output for any inferred text and, where necessary or beneficial, provides improved inferred text for use in the continuation output provided to the user.

36. A method according to any one of claims 28 to 35, wherein: The LLM is answering a question, and wherein the processing system analyzes the answer to the question in the continued output and, if necessary or beneficial, provides an improved answer for use in the continued output provided to the user.

37. A method according to any one of claims 28 to 36, wherein: The classifier operates to recognize when a cue is likely to result in a continued output where accuracy is important and / or when accuracy is important in the continued output, and then uses the processing system to improve the factual accuracy and / or the factual coverage of the continued output.

38. The method according to any one of claims 28 to 37, wherein: The continuation output from the LLM is a partial continuation, ie, output that was made before the LLM stopped generating or while the LLM was still generating.

39. The method according to any one of claims 28 to 38, wherein: The classifier operates to identify when a cue is likely to lead to accuracy-important continuation.

40. A method according to any one of claims 28 to 39, when used to improve one or more of the following: the output of the LLM; the factual accuracy and / or factual scope of the output; the internal logical consistency of the output (e.g., correct temporal ordering of events); the correspondence of the output generated by the LLM to how people understand or reason in the real world; reduction or removal of bias in the output; inclusion of dynamic or real-time information.

41. A method according to any one of claims 28 to 40, when used to improve one or more parameters of the output of the LLM: degree of formality, degree of conciseness (e.g., more conciseness when the language is to be spoken), suitability for speaking via a text-to-speech system, other stylistic language, degree of certainty.

42. The method according to any one of claims 28 to 41, wherein: The LLM is a generative AI based system.

43. A method according to any one of claims 28 to 42, wherein: The LLM is an autoregressive language model, such as a generative pre-trained Transformer.

44. A method according to any one of claims 28 to 43, when used for any of the following: generation of program code, solutions to any problem that can be described in natural language, generation of poetry, lyrics, creative writing, generation of other forms of writing such as essays, knowledge summaries, long texts, short articles, summaries of scientific papers; Internet searches.

45. A method according to any one of claims 28 to 44, comprising identifying output content that violates the policy by translating the output into the machine-readable language before displaying the output to the user and then checking the machine-readable language representation against a predefined policy.

46. ​​(C. Feeding UL engine output to the LLM for the LLM to generate better output) A method of interacting with a large language model (LLM), comprising the following steps: Continuation data is generated by an LLM using an output of a processing system using a structured machine-readable representation of data conforming to a machine-readable language such as a general-purpose language, wherein the LLM is configured to use the output of the processing system as a prompt and generate a continuation output (e.g., a textual output) that is an improved version of the output from the processing system.

47. (D. UL is used with the LLM to train the LLM) A method of interacting with a large language model (LLM), comprising the steps of: The LLM is trained based on output from a processing system using a structured machine-readable representation of data conforming to a machine-readable language, such as a ubiquitous language.

48. The method of claim 47, wherein: The fact accuracy and / or fact coverage of the LLM is improved through the training step.

49. The method according to claim 47 or 48, wherein: The training step is used to improve the internal logical consistency of the output (eg, correct temporal ordering of events).

50. The method according to any one of claims 47 to 49, wherein: The training step is used to improve the correspondence between the output generated by the LLM and how people understand or reason in the real world.

51. The method according to any one of claims 47 to 50, wherein: Biases in the output are improved through the training step.

52. The method according to any one of claims 47 to 51, wherein: The training data provided to the LLM is dynamic or real-time information.

53. A method according to any one of claims 47 to 52, wherein: The training data provided to the LLM is reasoned text, for example, text derived from a non-statistical inference process.

54. A method according to any one of claims 47 to 53, wherein: The LLM is answering a question, and the training data provided to the LLM is the answer to the question.

55. The method according to any one of claims 47 to 54, wherein: The training data provided to the LLM is labeled with a degree of certainty or uncertainty, or confidence or lack of confidence.

56. A method according to any one of claims 47 to 55, wherein: The training data provided to the LLM is labeled with a level of simplicity.

57. The method according to any one of claims 47 to 56, wherein: The training data provided to the LLM is labeled with a level of formality.

58. The method according to any one of claims 47 to 57, wherein: The training data provided to the LLM is labeled with the use or non-use of profanity.

59. The method according to any one of claims 47 to 58, wherein: The training data provided to the LLM is tagged with the age or other details of the person addressed by the LLM.

60. The method according to any one of claims 47 to 59, wherein: The training data is data found in the output of the LLM that has been labeled as factually inaccurate.

61. A method according to any one of claims 47 to 60, when used to improve one or more of the following: the output of the LLM; the factual accuracy and / or factual scope of the output; the internal logical consistency of the output (e.g., correct temporal ordering of events); the correspondence of the output generated by the LLM to how people understand or reason in the real world; reduction or removal of bias in the output; inclusion of dynamic or real-time information.

62. A method according to any one of claims 47 to 61, when used to improve one or more parameters of the output of the LLM: degree of formality, degree of conciseness (e.g., more conciseness when the language is to be spoken), suitability for speaking via a text-to-speech system, other stylistic language, degree of certainty.

63. The method according to any one of claims 47 to 62, wherein: The LLM is a generative AI based system.

64. The method according to any one of claims 47 to 63, wherein: The LLM is an autoregressive language model, such as a generative pre-trained Transformer.

65. A method according to any one of claims 47 to 64, when used for any of the following: generation of program code, solutions to any problem that can be described in natural language, generation of poetry, lyrics, creative writing, generation of other forms of writing such as essays, knowledge summaries, long texts, short articles, summaries of scientific papers; Internet searches.

66. The method according to any one of claims 1 to 46, comprising the steps of: (a) storing in a memory said structured machine-readable representation of data conforming to a machine-readable language, wherein said structured machine-readable representation of data comprises a single grammatical term to disambiguate the meaning of said structured machine-readable representation of data; (b) automatically using the LLM and the structured machine-readable representation of data for one or more of the following: deriving facts or relationships; reasoning; learning; translating; answering questions; processing natural language content; enabling human-computer interaction; expressing and governing rules or principles; and implementing one or more vertical applications.

67. The method according to any one of claims 1 to 46, comprising the steps of: (a) storing in a memory said structured machine-readable representation of data conforming to a machine-readable language, wherein said machine-readable language has a syntax, said syntax being a single shared syntax suitable for representing paragraphs of factual statements, query statements, and inference statements; (b) automatically using the LLM and the structured machine-readable representation of data for one or more of the following: deriving facts or relationships; reasoning; learning; translating; answering questions; processing natural language content; enabling human-computer interaction; expressing and governing rules or principles; and implementing one or more vertical applications.

68. The method according to any one of claims 1 to 46, comprising the steps of: (a) storing in a memory the structured machine-readable representation of data conforming to a machine-readable language, wherein the syntax of the machine-readable language is a substantially unambiguous syntax, the syntax comprising nesting of the structured machine-readable representation of data; (b) automatically using the LLM and the structured machine-readable representation for one or more of: deriving facts or relationships; reasoning; learning; translating; answering questions; processing natural language content; Enables human-computer interaction; expresses and governs rules or principles; implements one or more vertical applications.

69. The method according to any one of claims 1 to 46, comprising the steps of: (a) storing in a memory said structured machine-readable representation of data conforming to a machine-readable language, wherein said structured machine-readable representation of data comprises a plurality of identifiers selected from an address space, said address space being large enough to enable a user to select a new identifier with negligible risk of selecting a previously assigned identifier; (b) automatically using the LLM and the structured machine-readable representation of data for one or more of the following: deriving facts or relationships; reasoning; learning; translating; answering questions; processing natural language content; enabling human-computer interaction; expressing and governing rules or principles; and implementing one or more vertical applications.

70. The method according to any one of claims 1 to 46, comprising the steps of: (a) storing in a memory said structured machine-readable representation of data conforming to a machine-readable language, and wherein said machine-readable language is extensible in that there is no restriction as to which users can create structured machine-readable representations of data or associated identifiers; (b) automatically using the LLM and the structured machine-readable representation for one or more of: deriving facts or relationships; reasoning; learning; translating; answering questions; processing natural language content; Enables human-computer interaction; expresses and governs rules or principles; implements one or more vertical applications.

71. The method according to any one of claims 1 to 46, comprising the steps of: (a) storing in a memory a structured machine-readable representation of data conforming to a machine-readable language, where one or more of the following applies; (i) A single grammatical item is used to disambiguate the meaning of a structured representation of data; (ii) the syntax of the machine-readable language is a single shared syntax suitable for expressing paragraphs of factual statements, query statements, and inference statements; (iii) the syntax of the machine-readable language is a substantially unambiguous syntax, the syntax comprising nesting of structured representations of data; (iv) the structured representation of the data comprises identifiers selected from an address space that is large enough to enable a user to select a new identifier with negligible risk of selecting a previously assigned identifier; (v) the machine-readable language is extensible in that there are no restrictions on which users can create structured representations of data or associated identifiers; (b) automatically using the LLM and the structured representation of data for one or more of: deriving facts or relationships; reasoning; learning; translating; answering questions; processing natural language content; Enables human-computer interaction; expresses and governs rules or principles; implements one or more vertical applications.

72. The method according to any one of claims 1 to 46, comprising the steps of: (a) storing in a memory said structured machine-readable representation of data conforming to a machine-readable language, and wherein the problem is represented in said memory as the structured machine-readable representation of data; as well as (b) automatically generating a response to the question using one or more of the following steps: (i) matching the question to a structured machine-readable representation of data previously stored in a memory storage area; (ii) obtaining and executing one or more computational units, wherein a computational unit represents computational capabilities relevant to answering the question; (iii) obtaining and executing one or more reasoning paragraphs, wherein the reasoning paragraphs are structured machine-readable representations of data representing the semantics of potentially applicable reasoning steps relevant to answering the question; And wherein said representation of said problem, said structured machine-readable representation of data previously stored in said memory storage area, said computational unit and said reasoning paragraph are all expressed in substantially the same machine-readable language.

73. The method according to any one of claims 1 to 46, comprising the steps of: (a) learning new information and representing said new information in a structured machine-readable representation of data in a machine-readable language; (b) storing the structured machine-readable representation of data in a memory and automatically using the LLM and the structured representation of data for one or more of: deriving facts or relationships; reasoning; learning; translating; answering questions; processing natural language content; Enables human-computer interaction; expresses and governs rules or principles; implements one or more vertical applications.

74. The method according to any one of claims 1 to 46, comprising the steps of: (a) storing in a memory said structured machine-readable representation of data conforming to a machine-readable language; (b) receiving a word or a sequence of words in a natural language; (c) automatically translating the word or sequence of words into said machine-readable language by: identifying or generating a structured machine-readable representation that semantically represents the meaning of the word or sequence of words, for example, using an intermediate representation (IR) as an intermediate stage between a source natural language and a target language, for example, using a semantic graph; (d) providing the translation into said machine readable language to said LLM.

75. The method of claim 74, comprising (i) generating a semantic graph from the natural language; (ii) trying to match the semantic graph with a template of a graph of similar shape that already has an associated UL, and finally (iii) Apply direct translation only to those nodes in the graph that match the variables in the UL.

76. The method according to any one of claims 1 to 46, comprising the steps of: (a) storing in a memory said structured machine-readable representation of data conforming to a machine-readable language; (b) receiving a word or sequence of words in a first natural language to be translated into a second natural language; (c) automatically translating the word or word sequence expressed in the first natural language into the second natural language by: (i) identifying a structured machine-readable representation of data representing the semantics of the word or word sequence in the first natural language, for example, using an intermediate representation (IR) as an intermediate stage between the source natural language and the target language, for example, using a semantic graph; and (ii) retrieving a word or word sequence in the second natural language that corresponds in meaning to the structured machine-readable representation of the identified data. (d) providing the translation into said machine readable language to said LLM.

77. The method according to claim 76, comprising (i) generating a semantic graph from the natural language; (ii) trying to match the semantic graph with a template of a graph of similar shape that already has an associated UL, and finally (iii) Apply direct translation only to those nodes in the graph that match the variables in the UL.

78. The method according to any one of claims 1 to 46, comprising the steps of: (a) storing in a memory said structured machine-readable representation of data conforming to a machine-readable language; (b) automatically and autonomously processing the detected audio or text into said structured representation of data and providing said structured machine-readable representation of data to said LLM for use in one or more of: deriving facts or relationships; reasoning; learning; translating; answering questions; processing natural language content; Enables human-computer interaction; expresses and governs rules or principles; implements one or more vertical applications.

79. The method according to any one of claims 1 to 46, comprising the steps of: (a) storing in a memory said structured machine-readable representation of data conforming to a machine-readable language; wherein said structured machine-readable representation of data includes one or more principles, statements or other rules defining a goal or motivation also expressed using said structured representation of data, any of which we will refer to as a "principle"; (b) the computer system analyzes potential actions to determine whether performing the actions will optimize or otherwise affect the achievement or realization of those principles; (d) the computer system automatically selects, determines or performs actions only when those actions optimize or otherwise positively impact the achievement or realization of those principles.

80. The method according to any one of claims 1 to 46, comprising the steps of: (a) storing in a memory said structured machine-readable representation of data conforming to a machine-readable language; wherein said data relates to a portion of a document stored in a document storage area; (b) automatically processing the structured machine-readable representation of data in conjunction with the LLM for one or more of the following: deriving facts or relationships; reasoning; learning; translating; answering questions; processing natural language content; enabling human-computer interaction; representing and governing rules or principles; and implementing one or more vertical applications that require searching or analyzing documents.

81. The method according to any one of claims 1 to 46, comprising the steps of: (a) storing in a memory said structured machine-readable representation of data conforming to a machine-readable language; wherein said data relates to a map or location-based data; (b) automatically processing the structured machine-readable representation of data in conjunction with the LLM for one or more of the following: deriving facts or relationships; reasoning; learning; translating; answering questions; processing natural language content; enabling human-computer interaction; representing and governing rules or principles; and implementing one or more vertical applications using location or map-based data.

82. The method according to any one of claims 1 to 46, comprising the steps of: (a) storing in a memory said structured machine-readable representation of data in a machine-readable language representing meaning; wherein said data relates to a portion of one or more advertisements, news articles or other information items; (b) automatically processing said structured machine-readable representation of data in conjunction with said LLM to identify advertisements, news articles or other information items that are relevant to a specific individual.

83. The method according to any one of claims 1 to 46, comprising the steps of: (a) storing in a memory the structured machine-readable representation of data conforming to a machine-readable language; wherein the data relates to personal information defining one or more of the following attributes of a person: gender, age, information related to dating or pairing, information related to identifying business contacts, and information related to identifying friends; (b) automatically processing the structured machine-readable representation of data in conjunction with the LLM to provide compatible matches between people.

84. The method according to any one of claims 1 to 46, comprising the steps of: (a) storing in a memory the structured machine-readable representation of data conforming to a machine-readable language; wherein the data relates to a social media post; (b) automatically processing the structured machine-readable representation of data in conjunction with the LLM to determine whether the post complies with requirements to prevent abusive or illegal postings.

85. The method according to any one of claims 1 to 46, comprising the steps of: (a) storing in a memory the structured machine-readable representation of data in a machine-readable language; wherein the data relates to customer reviews of a product or service; (b) automatically processing the structured machine-readable representation of data in conjunction with the LLM to analyze the customer reviews.

86. The method according to any one of claims 1 to 46, comprising the steps of: (a) storing in a memory the structured machine-readable representation of data conforming to a machine-readable language; wherein the data relates to product data, including one or more of the following: product descriptions, user product requests, user's previous product-related searches, social media or shopping history; (b) automatically processing the structured machine-readable representation of data in conjunction with the LLM to determine which products best match a user's product request or the user's prior search, social media, or shopping history.

87. The method according to any one of claims 1 to 46, comprising the steps of: (a) storing in a memory said structured machine-readable representation of data conforming to a machine-readable language; wherein said data relates to a job description and the skills and experience of a job applicant; (b) automatically processing the structured representation of data in conjunction with the LLM to determine which jobs best match the job applicant's skills and experience.

88. The method according to any one of claims 1 to 46, comprising the steps of: (a) storing in a memory said structured machine-readable representation of data conforming to a machine-readable language; wherein said data relates to personal health or medical data; (b) automatically processing the structured representation of data in conjunction with the LLM to analyze the personal health or medical data.

89. The method according to any one of claims 1 to 46, comprising the steps of: (a) storing in a memory said structured machine-readable representation of data conforming to a machine-readable language; wherein said data relates to financial or accounting information; (b) automatically processing the structured representation in conjunction with the LLM to analyze personal financial or accounting information.

90. The method according to any one of claims 1 to 46, comprising the steps of: (a) storing in a memory the structured machine-readable representation of data conforming to a machine-readable language; wherein the data relates to user speech or text information input into a human-machine interface; (b) automatically processing the structured representation in conjunction with the LLM to analyze the user speech or text information.

91. A method according to any one of claims 1 to 46, when used in a system operable to provide a vertical application, wherein: The vertical application requires data that encodes meaning, wherein the data is heterogeneous and extremely wide-ranging for practical implementation in a relational database scheme, such as but not limited to a predefined and limited set of words or terms or concepts, and the system includes at least one data storage area containing a machine-readable representation of the data that encodes meaning.

92. A method according to any one of the preceding claims, wherein: The structured machine-readable representation of data conforming to a machine-readable language comprises semantic nodes and paragraphs; and wherein the semantic nodes represent entities and are themselves represented by identifiers; and paragraphs are either (i) semantic nodes or (ii) combinations of semantic nodes; and wherein the machine-readable meaning derives from the selection of semantic nodes and the manner in which the semantic nodes are combined and ordered into paragraphs.

93. A method according to any one of the preceding claims, wherein: Machine learning systems are used to generate words or word sequences that correspond to natural language forms or from their corresponding semantic nodes or paragraphs.

94. A method for interacting with one or more users in natural language, comprising the steps of: providing a structured representation of data and a system operable to process a language with reference to the structured representation of data to provide additional useful text associated with the language; Provide an LLM that can be operated to provide a continuation of the text; receiving language input from one or more users; processing the language input with the system to generate additional useful text; providing the language input and the additional useful text to the LLM; Language derived from the continuation generated by the LLM is provided to the one or more users.

95. The method of claim 94, wherein: The structured representation of data is a universal language.

96. The method of claim 94 or 95, wherein: The LLM has been trained with data containing in particular natural language augmented with additional useful text.

97. The method of any one of claims 94 to 96, wherein: The system is further operable to perform calculations that can be used to generate the additional useful text.

98. The method according to any one of claims 94 to 97, wherein: The system is further operable to perform inference to improve the additional useful text using the structured representation of data.

99. The method of any one of claims 94 to 98, wherein: The language input from one or more users is a question, and wherein the additional useful text comprises an answer to the question.

100. The method according to any one of claims 94 to 99, wherein: The additional useful text is structured in a manner that distinguishes the additional useful text from the language input from one or more users.

101. The method according to any one of claims 94 to 100, wherein: The additional useful text includes information calculated from the language input.

102. The method according to any one of claims 94 to 101, wherein: The additional useful text includes information designed to determine tone, or sentiment, or conciseness, or whether the response will be spoken or written, or a description of the recipient of the response, or the level of formality, or the level of profanity, or personality.

103. The method according to any one of claims 94 to 102, further comprising the steps of: A prompt is provided to the LLM, the prompt including instructions for appropriate utilization of the additional useful text.

104. A method of verifying natural language for factual accuracy, comprising the steps of: extracting from the natural language a set of one or more factual assertions asserted in the natural language; checking the one or more factual assertions for factual accuracy; The results of the inspection are output or made available.

105. The method of claim 104, wherein: Extracting from the natural language a set of one or more fact assertions asserted by the text is accomplished by providing the natural language to a suitably trained LLM and asking for prompts to generate continuations of the fact assertions and then generating continuations using the LLM.

106. The method of claim 104 or 105, wherein: The step of checking the one or more factual assertions for factual accuracy comprises the further steps of providing a reasoning system capable of reasoning with a symbolic representation of the world, translating the assertions into a representation compatible with the reasoning system, and identifying true or false assertions using the reasoning system.

107. The system of claim 106, wherein: The reasoning system uses a universal language.

108. The system of any one of claims 104 to 107, wherein: Checking the one or more assertions for factual accuracy includes translating the assertions into questions corresponding to whether the assertions are true or false and answering those questions.

109. The method according to any one of claims 104 to 107, wherein: The source of any previously known knowledge used to verify the factual assertion as false is returned as part of the process of checking the one or more factual assertions for factual accuracy.

110. The method according to any one of claims 104 to 109, wherein: Checking the one or more factual assertions for factual accuracy includes generating an explanation.

111. The method according to any one of claims 104 to 110, wherein: The natural language is from a scientific paper, or from a news article, or from a web page, or from a book, or from an LLM, or from a chat application, or from an automatic speech recognition (ASR) transcription of speech, or from a real-time transcription of speech, or from a real-time transcription of speech spoken during a lecture or interview.

112. The method according to any one of claims 104 to 111, wherein: The natural language is derived from the LLM, and the method further comprises the step of adjusting the natural language so that it no longer includes any factual inaccuracies.

113. A method for learning knowledge in a structured form, comprising the following steps: Provides LLMs trained on a large corpus of natural language documents; providing the LLM with prompts that will elicit desired knowledge; elicit a continuation of said prompt from said LLM; The continuation is translated into the structured form.

114. The method of claim 113, wherein: The structured form is a universal language.

115. The method according to claim 113 or 114, wherein: The knowledge in question is factual knowledge.

116. The method according to any one of claims 113 to 115, wherein: The knowledge is common sense knowledge.

117. The method according to any one of claims 113 to 116, wherein: The structural form represents valid reasoning steps that can be used by or for reasoning with an automated system.

118. A method for ensuring that LLM generates original text, comprising the steps of: Provide a database of previous text that should not be generated; Perform a beam search; checking potential continuations against said database; When a potential continuation matches non-original text in the database, the continuation is adjusted to no longer match the non-original text in the database.

119. The method of claim 118, wherein: Adjusting the continuation includes the step of selecting a different sequence from the beam search.

120. The method according to claim 118 or 119, further comprising the steps of: A classifier capable of distinguishing prompts that require the original text as continuation from those that do not require the original text as continuation is provided, and the classifier is applied to the prompts.

121. The method according to any one of claims 118 to 120, wherein: Checking potential continuations against the database includes close but not exact matches to the previous text.

122. A method for avoiding hallucinations in LLM, comprising the steps of: Analyze different continuations for a given prompt; comparing the different continuations to identify portions of the response that have not changed and portions of the response that have changed; Identify said portion of the change as more likely to be an illusion; The portion identified as a hallucination is replaced or not shown to the user.

123. A method for adding citations to a text generated by an LLM, comprising the steps of: providing a database of text for training the LLM, the database including a source associated with each chapter of the stored text; checking the continued chapter generated by the LLM against the database; Sources are searched for said section of said continuation that matches text contained in said database.

124. The method according to claim 123, further comprising the steps of: providing a classifier to determine whether the continuation section is suitable for incorporation by reference; The classifier is utilized when matching with the continued chapter.

125. The method according to claim 123 or 124, further comprising the steps of: The continuation is adjusted to appropriately cite at least some of the sources.

126. A computer-implemented method comprising the following steps (i) receiving an output from a natural language processing computer process, the output comprising an answer to a question; (ii) inputting the received output into a large language model (LLM); (iii) the large language model (LLM) processes the input to the LLM to generate an output based on the input to the LLM. (iv) storing the output based on the input to the LLM.

127. The method of claim 126, wherein: The LLM is configured to provide a concise explanation of the input (wherein the input is, for example, a detailed explanation) to the LLM to generate the output based on the input to the LLM.

128. The method of claim 126 or 127, wherein: The LLM is configured to provide completion of the input to the LLM to generate the output based on the input to the LLM.

129. A computer-implemented method for training a large language model (LLM), comprising the following steps (i) receiving an output from a natural language processing computer process, the output comprising an answer to a question; (ii) repeating step (i) at least one thousand times using a set of at least one thousand different questions, and storing the answers to the questions in a training file; (iii) training a large language model (LLM) using the training file; (iv) Store the weights representing the trained LLM.

130. The method of claim 129, comprising storing each question together with its corresponding answer in the training file in step (ii).

131. The method of claim 129 or 130, comprising in step (ii), repeating step (i) at least 10,000 times, or at least 100,000 times, or at least one million times using a problem set of different problems.

132. The method of any one of claims 129 to 131, wherein: The responses to the questions include a degree of uncertainty.

133. A computer-implemented method for generating a training file for a large language model (LLM), comprising the steps of: (i) receiving an output from a natural language processing computer process, the output comprising an answer to a question; (ii) repeating step (i) at least one thousand times using a set of at least one thousand different questions, and storing the answers to the questions in the training file.

134. The method of claim 133, comprising storing each question together with its corresponding answer in the training file in step (ii).

135. The method of claim 133 or 134, comprising in step (ii), repeating step (i) at least 10,000 times, or at least 100,000 times, or at least one million times using a problem set of different problems.

136. The method of any one of claims 133 to 135, wherein: The responses to the questions include a degree of uncertainty.

137. A computer-implemented method of retraining a large language model (LLM), the LLM having been previously trained using a training file, the method comprising the steps of: (i) receiving an output from a natural language processing computer process, the output comprising an answer to a question; (ii) repeating step (i) at least one thousand times using a set of at least one thousand different questions, and storing the answers to the questions in a retraining file; (iii) combining the training file and the retraining file to generate a combined training file; (iv) retraining a large language model (LLM) using the combined training file; (v) storing weights representing the retrained LLM.

138. The method of claim 137, comprising storing each question together with its corresponding answer in the retraining file in step (ii).

139. The method of claim 137 or 138, comprising in step (ii), repeating step (i) at least 10,000 times, or at least 100,000 times, or at least one million times using a problem set of different problems.

140. The method of any one of claims 137 to 139, wherein: The responses to the questions include a degree of uncertainty.

141. A computer-implemented method of updating the training of a large language model (LLM), the LLM having been previously trained using a training file, the method comprising the steps of: (i) receiving an output from a natural language processing computer process, the output comprising an answer to a question; (ii) repeating step (i) at least one thousand times using a set of at least one thousand different questions, and storing the answers to the questions in a retraining file; (iii) updating the training of the large language model (LLM) using the retraining file; (iv) storing a weight representing the updated trained LLM.

142. The method of claim 141, comprising storing each question together with its corresponding answer in the retraining file in step (ii).

143. The method of claim 141 or 142, comprising in step (ii), repeating step (i) at least 10,000 times, or at least 100,000 times, or at least one million times using a problem set of different problems.

144. The method according to any one of claims 141 to 143, wherein: The responses to the questions include a degree of uncertainty.

145. A computer-implemented method for improving output using a large language model (LLM), comprising the steps of: (i) receiving a natural language question (e.g., any natural language to which a natural language response is suitable. It could be, for example, a command or a request for data or even some kind of social interaction or discussion); (ii) using a computer system comprising a processor and a memory, the processor being configured to use a processing language, wherein semantic nodes are represented in the processing language, the semantic nodes include semantic links between semantic nodes, wherein the semantic links themselves are semantic nodes, wherein each semantic node marks a specific meaning, wherein a combination of semantic nodes defines a semantic node, wherein expressions in the processing language can be nested, wherein the natural language question is represented in the processing language, wherein reasoning steps are represented in the processing language to represent the semantics of the reasoning steps, wherein computational units are represented in the processing language, and wherein the memory is configured to store the representations in the processing language; (iii) the processor answers the question using the reasoning steps, the computational units, and the semantic nodes, and (iv) inputting the natural language question and the processor's answer to the question into the LLM; (v) the large language model (LLM) processes the input to the LLM to generate an output based on the input to the LLM; (vi) storing the output based on the input to the LLM.

146. The method of claim 145, comprising the step of outputting said stored output to a user interface, said output to said user interface excluding said processor's answer to said question.

147. The method of claim 145 or 146, wherein: The processor's answer to the question includes a calculation or assertion or fact derived about the natural language question.

148. A computer-implemented method for improving output from a large language model (LLM), comprising the steps of: (i) receiving a first natural language question; (ii) inputting or providing the received first natural language question to a large language model (LLM); (iii) the large language model (LLM) processes the input to the LLM to generate an output based on the input to the LLM; (iv) translating the output into a processing language, wherein semantic nodes are represented in the processing language, the semantic nodes include semantic links between semantic nodes, wherein the semantic links themselves are semantic nodes, wherein each semantic node marks a specific meaning, wherein a combination of semantic nodes defines a semantic node, wherein expressions in the processing language can be nested; (v) constructing a question asking whether the output is true, wherein the question is expressed in the processing language; (vi) inputting the problem into a computer system comprising a processor and a memory, the processor being configured to use the processing language, wherein the reasoning steps are represented in the processing language to represent the semantics of the reasoning steps, wherein the computational units are represented in the processing language, and wherein the memory is configured to store the representation in the processing language; (vii) the processor answers the question using the reasoning steps, the computational units, and the semantic nodes, and (viii) The processor stores the answer to the question in the memory.

149. The method of claim 148, comprising the steps of: (ix) providing said output to a user interface only if said answer to said question is that said output is true.

150. The method of claim 148 or 149, comprising storing the output based on the input to the LLM.

151. The method of any one of claims 148 to 150, wherein: If the answer to the question is that the output is false, then a statement that the answer to the question is a false statement is stored in a file that can be used to retrain the LLM.

152. The method of any one of claims 148 to 151, wherein: Step (vi) includes using a computer system including a processor and a memory, the processor being configured to use a processing language, wherein semantic nodes are represented in the processing language, the semantic nodes include semantic links between semantic nodes, wherein the semantic links themselves are semantic nodes, wherein each semantic node marks a specific meaning, wherein a combination of semantic nodes defines a semantic node, wherein expressions in the processing language can be nested, wherein the natural language question is represented in the processing language, wherein reasoning steps are represented in the processing language to represent the semantics of the reasoning steps, wherein computing units are represented in the processing language, and wherein the memory is configured to store the representations in the processing language.

153. A method according to any one of claims 148 to 152, comprising identifying output content that violates the policy by translating the output into the processing language before displaying the output to the user and then checking the processing language representation against a predefined policy.

154. A computer-implemented method for fact-checking output from a large language model (LLM), comprising the following steps (i) receiving text input; (ii) inputting or providing the connected text input to a large language model (LLM); (iii) the large language model (LLM) processes the input to the LLM to generate an output based on the input to the LLM; (iv) translating the output into a processing language, wherein semantic nodes are represented in the processing language, the semantic nodes include semantic links between semantic nodes, wherein the semantic links themselves are semantic nodes, wherein each semantic node marks a specific meaning, wherein a combination of semantic nodes defines a semantic node, wherein expressions in the processing language can be nested, wherein translating the output includes extracting the assertions in the text generated by the LLM; (v) constructing one or more questions asking whether the extracted assertions are respectively true, wherein the one or more questions are expressed in the processing language; (vi) inputting the one or more questions into a computer system comprising a processor and a memory, the processor being configured to use the processing language, wherein reasoning steps are represented in the processing language to represent the semantics of the reasoning steps, wherein computational units are represented in the processing language, and wherein the memory is configured to store the representations in the processing language; (vii) the processor answers the one or more questions using the reasoning steps, the computational units, and the semantic nodes, and (viii) the processor storing in the memory a separate answer to each of the one or more questions.

155. The method of claim 154, comprising the steps of: (ix) The corresponding output is provided to the user interface only if the answer to the corresponding question is that the output assertion is true.

156. The method of claim 154 or 155, comprising storing the output based on the input to the LLM.

157. The method of any one of claims 154 to 156, wherein: If the answer to the corresponding question is that the corresponding assertion is false, then the statement that the answer to the corresponding question is a false statement is stored in a file that can be used to retrain the LLM.

158. The method of any one of claims 154 to 157, wherein: Step (vi) comprises using a computer system comprising a processor and a memory, the processor being configured to use a processing language, wherein semantic nodes are represented in the processing language, the semantic nodes include semantic links between semantic nodes, wherein the semantic links themselves are semantic nodes, wherein each semantic node marks a specific meaning, wherein a combination of semantic nodes defines a semantic node, wherein expressions in the processing language can be nested, wherein the problem is represented in the processing language, wherein reasoning steps are represented in the processing language to represent the semantics of the reasoning steps, wherein computational units are represented in the processing language, and wherein the memory is configured to store the representations in the processing language.

159. A method according to any one of claims 154 to 158, comprising identifying output content that violates the policy by translating the output into the processing language before displaying the output to the user and then checking the processing language representation against a predefined policy.

160. A computer-implemented method of improving output from a computer system comprising a processor and a memory, the system being operable to process the natural language question using a processing language, wherein: The semantic nodes are represented in the processing language, the method includes using a large language model (LLM), the method includes the following steps: (i) receiving natural language questions; (ii) using a computer system comprising a processor and a memory, the system being operable to process the natural language problem using a processing language, wherein semantic nodes are represented in the processing language, the semantic nodes comprising semantic links between semantic nodes, wherein the semantic links themselves are semantic nodes, wherein each semantic node marks a specific meaning, wherein the memory is configured to store the representation in the processing language; (iii) the processor answers the question, and (iv) inputting the natural language question and the processor's answer to the question into the LLM; (v) the large language model (LLM) processes the input to the LLM to generate an output based on the input to the LLM; (vi) storing the output based on the input to the LLM.

161. The method of claim 160, comprising the step of outputting the stored output to a user interface, the output to the user interface excluding the processor's answer to the question.

162. The method of claim 160 or 161, wherein: The processor's answer to the question includes a calculation or assertion or fact derived about the natural language question.

163. The method of any one of claims 160 to 162, wherein: Step (ii) comprises using a computer system comprising a processor and a memory, the processor being configured to use a processing language, wherein semantic nodes are represented in the processing language, the semantic nodes include semantic links between semantic nodes, wherein the semantic links themselves are semantic nodes, wherein each semantic node marks a specific meaning, wherein a combination of semantic nodes defines a semantic node, wherein expressions in the processing language can be nested, wherein the natural language question is represented in the processing language, wherein reasoning steps are represented in the processing language to represent the semantics of the reasoning steps, wherein computing units are represented in the processing language, and wherein the memory is configured to store the representations in the processing language.

164. A computer-implemented method for improving output from a large language model (LLM), comprising the following steps (i) receiving a first natural language question; (ii) inputting the received first natural language question into a large language model (LLM); (iii) the large language model (LLM) processes the input to the LLM to generate an output based on the input to the LLM; (iv) translating the output into a processing language, wherein semantic nodes are represented in the processing language, the semantic nodes include semantic links between semantic nodes, wherein the semantic links themselves are semantic nodes, and wherein each semantic node marks a specific meaning; (v) constructing a question asking whether the output is true, wherein the question is expressed in the processing language; (vi) inputting the problem into a computer system comprising a processor and a memory, the processor being configured to use the processing language, wherein said memory is configured to store said representation in said storage language; (vii) the processor answers the question, and (viii) The processor stores the answer to the question in the memory.

165. The method according to claim 164, comprising the steps of: (ix) providing said output to a user interface only if said answer to said question is that said output is true.

166. The method of claim 164 or 165, comprising the steps of: The output is stored based on the input to the LLM.

167. The method of any one of claims 164 to 166, wherein: If the answer to the question is that the output is false, then a statement that the answer to the question is a false statement is stored in a file that can be used to retrain the LLM.

168. The method of any one of claims 164 to 167, wherein: Step (vii) comprises using a computer system comprising a processor and a memory, the processor being configured to use a processing language, wherein semantic nodes are represented in the processing language, the semantic nodes include semantic links between semantic nodes, wherein the semantic links themselves are semantic nodes, wherein each semantic node marks a specific meaning, wherein a combination of semantic nodes defines a semantic node, wherein expressions in the processing language can be nested, wherein the natural language question is represented in the processing language, wherein reasoning steps are represented in the processing language to represent the semantics of the reasoning steps, wherein computing units are represented in the processing language, and wherein the memory is configured to store the representations in the processing language.

169. A method according to any one of claims 164 to 168, comprising identifying output content that violates the policy by translating the output into the processing language before displaying the output to the user and then checking the processing language representation against a predefined policy.

170. A computer-implemented method for fact-checking output from a large language model (LLM), comprising the steps of: (i) receiving text input; (ii) inputting the received text input into a large language model (LLM); (iii) the large language model (LLM) processes the input to the LLM to generate an output based on the input to the LLM; (iv) translating the output into a processing language, wherein semantic nodes are represented in the processing language, the semantic nodes include semantic links between semantic nodes, wherein the semantic links themselves are semantic nodes, wherein each semantic node labels a specific meaning, wherein translating the output includes extracting the assertions in the text generated by the LLM; (v) constructing one or more questions asking whether the extracted assertions are respectively true, wherein the one or more questions are expressed in the processing language; (vi) inputting the one or more questions into a computer system comprising a processor and a memory, the processor being configured to use the processing language, wherein the memory is configured to store the representation in the storage language; (vii) the processor answers the one or more questions, and (viii) the processor storing in the memory a separate answer to each of the one or more questions.

171. The method according to claim 170, comprising the steps of: (ix) The output is provided to the user interface only if the answer to the corresponding question is that the corresponding output is true.

172. The method according to claim 170 or 171, comprising the steps of: The output is stored based on the input to the LLM.

173. The method of any one of claims 170 to 172, wherein: If the answer to the corresponding question is that the corresponding output is false, then a statement that the answer to the corresponding question is a false statement is stored in a file that can be used to retrain the LLM.

174. The method of any one of claims 170 to 173, wherein: Step (vii) comprises using a computer system comprising a processor and a memory, the processor being configured to use a processing language, wherein semantic nodes are represented in the processing language, the semantic nodes include semantic links between semantic nodes, wherein the semantic links themselves are semantic nodes, wherein each semantic node marks a specific meaning, wherein a combination of semantic nodes defines a semantic node, wherein expressions in the processing language can be nested, wherein the problem is represented in the processing language, wherein reasoning steps are represented in the processing language to represent the semantics of the reasoning steps, wherein computational units are represented in the processing language, and wherein the memory is configured to store the representations in the processing language.

175. A method according to any one of claims 170 to 174, comprising identifying output content that violates the policy by translating the output into the processing language before displaying the output to the user and then checking the processing language representation against a predefined policy.

176. A computer-implemented method for expanding search results, comprising the steps of: (i) receiving search queries; (ii) a (e.g., Internet) search engine processes the search query to generate (e.g., Internet) search results; (iii) transforming the search results into a structured machine-readable representation of the data conforming to a machine-readable language such as a universal language; (iv) processing the transformed search results using a processing system using said structured machine-readable representation of data conforming to said machine-readable language, such as a universal language, to produce an output; (v) supplying the output of step (iv) as input to a large language model (LLM), and the LLM generating a continuation data output in response to the input.

177. The method of claim 176, comprising the step of outputting the continuation data output generated by the LLM to a user interface.

178. The method of claim 176 or 177, wherein: The output of the processing system includes calculations or assertions or facts derived about the search query.

179. The method of any one of claims 176 to 178, wherein: Step (iv) comprises using a computer system comprising a processor and a memory, the processor being configured to use a processing language, wherein semantic nodes are represented in the processing language, the semantic nodes comprise semantic links between semantic nodes, wherein the semantic links themselves are semantic nodes, wherein each semantic node marks a specific meaning, wherein a combination of semantic nodes defines a semantic node, wherein expressions in the processing language can be nested, wherein the search query is represented in the processing language, wherein an inference step is represented in the processing language to represent the semantics of the inference step, wherein a computational unit is represented in the processing language, and wherein the memory is configured to store the representation in the processing language.

180. The method of any one of claims 104 to 179, comprising the method of any one of claims 1 to 103.

181. (Action) A method of interacting with an LLM-based system, comprising the following steps: A non-LLM processing system is used in conjunction with the LLM-based system, the non-LLM processing system being programmed to implement non-statistical reasoning, including open and interpretable non-statistical abstract reasoning, using unambiguous machine language to initiate real-world actions.

182. A method for interacting with an LLM-based system, comprising the steps of: A non-LLM processing system is used in conjunction with the LLM-based system, the non-LLM processing system being programmed to use an unambiguous machine language that implements open and interpretable rules or principles to initiate real-world actions.

183. (Worldview) A method for interacting with an LLM-based system, comprising the following steps: A non-LLM processing system is used in conjunction with the LLM-based system, the non-LLM processing system being programmed to use an unambiguous machine language that represents a model of the world that broadly corresponds to how people describe the world; and to reason in a manner that corresponds to how people understand and reason in the real world.

184. (Learning) A method for interacting with an LLM-based system, comprising the following steps: A non-LLM processing system is used in conjunction with the LLM-based system, the non-LLM processing system being programmed to use an unambiguous machine language that enables acquisition or learning of new facts or new inferences.

185. The method of claim 184, wherein: The non-LLM processing system learns by representing continuations generated by the LLM-based system in the unambiguous machine language.

186. The method of claim 184 or 185, wherein: The LLM-based system generates a natural language, and the method comprises the additional step of translating the natural language into the unambiguous machine language, for example using an intermediate representation (IR) as an intermediate stage between the source natural language and the target language, for example using a semantic graph.

187. The method according to claim 186, comprising (i) generating a semantic graph from the natural language; (ii) trying to match the semantic graph with a template of a graph of similar shape that already has an associated UL, and finally (iii) Apply direct translation only to those nodes in the graph that match the variables in the UL.

188. The method of any one of claims 184 to 187, wherein: The method includes steps for verifying the continuation for factual accuracy.

189. The method of claim 188, wherein: The step for verifying the accuracy of facts comprises the step of asking the non-LLM processing system questions in the unambiguous machine language.

190. The method of claim 188 or 189, wherein: The step of verifying the continuation for factual accuracy includes checking to see if the continuation contradicts other facts expressed in the unambiguous machine language.

191. (Memory) A method for interacting with an LLM-based system, comprising the following steps: A non-LLM processing system is used in conjunction with the LLM-based system, the non-LLM processing system being programmed to use an unambiguous machine language that enables facts or inferences to be represented and stored for long-term reuse.

192. (Reasoning) A method for interacting with an LLM-based system, comprising the following steps: A non-LLM processing system is used in conjunction with the LLM-based system, the non-LLM processing system being programmed to perform non-statistical reasoning, including open and interpretable non-statistical abstract reasoning, using an unambiguous machine language.

193. (Interpretability) A method for interacting with an LLM-based system, comprising the following steps: A non-LLM processing system is used in conjunction with the LLM-based system, the non-LLM processing system being programmed to use an unambiguous machine language that enables output and reasoning to be open and interpretable.

194. (Accuracy / Reliability) A method for interacting with an LLM-based system comprising the following steps: A non-LLM processing system is used in conjunction with the LLM-based system, the non-LLM processing system being programmed to use an unambiguous machine language that enables accurate and reliable output when based on accurate and reliable output and reasoning.

195. (Trust) A method of interacting with an LLM-based system comprising the following steps: A non-LLM processing system is used in conjunction with the LLM-based system, the non-LLM processing system being programmed to use an unambiguous machine language that enables the output to be trusted when based on accurate and reliable output and reasoning.

196. (Cost) A method for interacting with an LLM-based system, comprising the steps of: A non-LLM processing system is used in conjunction with the LLM-based system, the non-LLM processing system being programmed to use an unambiguous machine language to reduce the computational cost of operating the LLM-based system.

197. The method of claim 196, wherein: The computing power required by the LLM-based system is reduced by the capabilities of the non-LLM system.

198. (Fact Checking) A method for fact checking the output of a large language model (LLM), comprising the following steps: The continuation data generated by the LLM is provided to a processing system that uses a structured machine-readable representation of data conforming to a machine-readable language, wherein the processing system analyzes the continuation output generated by the LLM in response to prompts so that an improved fact-checked version of the continuation output can be generated and provided to a user.

199. The method of claim 198, wherein: The processing system translates one or more fact assertions in the continuation data into the structured machine-readable representation of data and performs fact checking on the translated fact assertions in the continuation data.

200. The method of claim 198 or 199, wherein: The processing system fact-checks the translated factual assertions by analyzing them for factual inaccuracies or inconsistencies.

201. The method of any one of claims 198 to 200, wherein: The improved fact-checked version of the continuation output is provided to a user by the processing system or by the LLM or a combination of the processing system and the LLM.

202. The method of any one of claims 181 to 201, comprising the method of any one of claims 1 to 103.

203. A computer system configured to perform the method of any preceding claim.

Images