Super intelligence via general language understanding

Abstract

Disclosed herein are computer-implemented methods of providing general language understanding, the computer-implemented methods comprising parsing an input in a language domain into an enriched tree data structure, wherein the enriched tree data structure comprises at least one of a unique identification, a classification, and a resolution of an entity; processing the enriched tree data structure by matching the enriched tree data structure to one or more dynamic language graphs, wherein the one or more dynamic language graphs store relationships between elements of the language domain, causal relationships of entities, and properties of entities; and upon determining that the enriched tree data structure does not match the one or more dynamic language graphs, inserting at least a portion of the non-matching enriched tree data structure into the one or more dynamic language graphs.

Description

[0001] Cross-references This application claims the benefit of U.S. Provisional Application No. 63 / 589829, filed October 12, 2023, and U.S. Provisional Application No. 63 / 559049, filed February 28, 2024, each of which is incorporated herein by reference in its entirety. Background Technology

[0002] A natural language understanding mechanism that provides verifiable, fundamental, and coherent output is fundamental to building reliable and trustworthy intelligent systems. Developing such a natural language understanding mechanism that follows the law of coherence is a significant challenge in the field of computational intelligence. Summary of the Invention

[0003] On the one hand, this paper discloses a computer-implemented method for providing general language understanding, the computer-implemented method comprising: (a) parsing input in a language domain into an enriched tree data structure, wherein the enriched tree data structure includes at least one of entity unique identifiers, classifications, and resolutions; (b) processing the enriched tree data structure by matching it with one or more dynamic language graphs, wherein the one or more dynamic language graphs store relationships between elements of the language domain, causal relationships between entities, and properties of entities; and (c) when it is determined that the enriched tree data structure does not match the one or more dynamic language graphs, inserting at least a portion of the mismatched enriched tree data structure into the one or more dynamic language graphs.

[0004] In some implementations, a relation is defined as a tuple of entities and relations. In some implementations, entities are fundamental elements of an ontology of the language domain. In some implementations, the computer-implemented method further includes segmenting the input into multiple chunks, at least in part based on a dictionary model of the language domain. In further implementations, the computer-implemented method further includes parsing the multiple chunks using initial grammar rules. In some implementations, at least a portion of the enrichment tree data structure inserted into one or more dynamic language graphs includes new grammar rules, new causal relationships between entities, new properties, or new relations.

[0005] On the one hand, this paper discloses a computer implementation method for coherent natural language understanding, comprising: (a) receiving input and generating one or more parsed inputs using a parsing and chunking engine, wherein the one or more parsed inputs include multiple entities, wherein the multiple entities include one or more words, one or more characters, or one or more sets of words, and wherein each of the one or more parsed inputs includes an enriched data tree structure; (b) matching at least one of the one or more parsed inputs with at least a portion of one or more dynamic language graphs, wherein the one or more dynamic language graphs are connected to zero or more graphs in the one or more dynamic language graphs; and (c) when it is not possible to match at least one of the one or more parsed inputs with one or more dynamic language graphs, inserting one or more portions of at least one of the one or more parsed inputs into one or more of the dynamic language graphs or generating a new dynamic language graph, the new dynamic language graph including one or more portions of the one or more parsed inputs.

[0006] In some implementations, one or more dynamic language graphs include representations of natural language, which include multiple entities or grammars, where the grammars include the organizational structure of multiple entities. In further implementations, the input provides new grammatical rules. In further implementations, the natural language representations are derived from a low-resource corpus. In even further implementations, the low-resource corpus includes human language, symbolic language, business documents, or aggregated text corpora. In some implementations, one or more dynamic language graphs include representations of one or more causal relationships for each of multiple entities, where the representations include the origin of each of multiple entities, the properties of each of multiple entities, or the relationships between each of multiple entities. In some implementations, one or more dynamic language graphs are implemented on an SQL server. In some implementations, the computation of maintaining one or more dynamic language graphs is performed using a compiler. In some implementations, one or more dynamic language graphs are optimized for large-scale, fast computation and memory usage. In some implementations, the parsing engine boosts and scales the multiple entities. In some implementations, one or more parsed inputs further include one or more syntactic, semantic, or pragmatic relationships between multiple entities. In some implementations, the computer-implemented method further includes providing a baseified response to the input. In a further implementation, the baseified response includes one or more validation sources. In some embodiments, the computer-implemented method further includes receiving input from one or more of a user device, an internal input device, an external input device, or machine-readable instructions. In some embodiments, the one or more dynamic language graphs include one or more systems and one or more transformations, wherein the one or more transformations include one or more change rules, wherein the one or more systems include one or more structures and one or more relations, wherein the one or more relations include one or more tuples of multiple entities and one or more connections, wherein the one or more structures include one or more sets, wherein the one or more sets include multiple entities and one or more properties, wherein the one or more properties include one or more attribute-value pairs. In some embodiments, the computer-implemented method further includes inserting one or more dynamic language graphs of the parsed input therein based on a TOE logical selection including three truth-value elements. In some embodiments, the computer-implemented method further includes generating a response to the input, wherein the response includes at least one of a baseified response to the input, a request for more information, an empty response, or an indication of an error in the input, the response being referenced and reproducible, and the baseified response being self-consistent with all previous responses to the input. In a further embodiment, the baseified response includes a reference to a verification source.

[0007] On one hand, this document discloses a computer system comprising: (a) a processor; (b) a display; and (c) a non-transitory computer-readable storage medium encoded with a computer program that causes the processor to perform any of the methods described in any of the preceding claims.

[0008] On one hand, this document discloses a non-transitory computer-readable storage medium encoded with a computer program including instructions executable by a processor to create an application configured to perform any of the methods described in any of the preceding claims.

[0009] On one hand, this document discloses a system comprising one or more computer processors and a computer-readable storage device including machine-executable code that, when executed by the one or more computer processors, implements a method for generating a baseified natural language response, the method comprising: (a) receiving natural language input by a computing device; (b) selecting a configuration from a database comprising a plurality of configurations for interpreting the natural language input, wherein the configuration is selected based on coherence between the natural language input and the configuration; and (c) generating a baseified natural language response upon determining the configuration for the natural language input, wherein the baseified natural language response includes a reference to at least one verification source.

[0010] In some implementations, at least one verification source is a website. In some implementations, at least one verification source is program documentation or a staff manual. In some implementations, the method further includes: (d) determining a truth value for the natural language input; (e) performing at least one action based on the truth value, including: (i) incorporating the natural language input into a database, or (ii) requesting more information about the natural language input. In a further implementation, determining the action performed in (e) includes evaluating the natural language input using TOE logic. In some implementations, the natural language input is processed by a parsing and chunking engine. In a further implementation, the parsing and chunking engine identifies multiple entities in the natural language input. In some implementations, the system is configured to obtain an overall score of at least 0.78 on the MMLU-Pro dataset. In some implementations, the system is configured to obtain scores on the MMLU-Pro dataset of at least 0.89 for Biology, at least 0.81 for Business, at least 0.80 for Computer Science, at least 0.84 for Economics, at least 0.64 for Engineering, at least 0.77 for Health Sciences, at least 0.64 for Law, at least 0.82 for Mathematics, at least 0.77 for Philosophy, at least 0.80 for Physics, and at least 0.81 for Psychology, or any combination thereof. In some implementations, generating a baseified natural language response includes determining the question style, theme, entity, domain, task, difficulty, time sensitivity, assumption, or a combination thereof of the natural language input. In some implementations, the baseified natural language response includes the source of at least one validation source assigned to the entity in the baseified natural language response. In a further implementation, the system further includes providing the baseified natural language response on a display of a computing device. In a still further implementation, the source of at least one validation source is presented on the display of the computing device. In an even further implementation, the source of at least one validation source includes a link to the source of at least one validation source. In some implementations, the baseified natural language response is a translation from a first language to a second language.

[0011] On one hand, this paper discloses a computer system comprising: (a) a game module that communicates with at least one database, the at least one database comprising a plurality of discourse domains, wherein each discourse domain comprises a dynamic language graph; (b) an import module configured to receive input via one or more input devices; and (c) a playing module configured to: (i) determine one or more discourse domains in which input is assimilated; and (ii) assimilate the input into one or more discourse domains, wherein assimilating the input includes adding at least one entity from the input to the dynamic language graph of the discourse domain in one or more discourse domains or generating a new discourse domain including the entity.

[0012] In some embodiments, the system further includes an indexing module configured to index the input into a dynamic language graph. In some embodiments, the system further includes a reshaping module configured to evaluate the input for input efficiency. In a further embodiment, the system further includes an improvement module configured to update a portion of multiple discourse domains based on input efficiency, wherein updating the discourse domain of a portion of the multiple discourse domains includes adding entities to that portion of the discourse domain or updating the relationship between at least two entities in that portion of the discourse domain. In some embodiments, the dynamic language graph includes data and metadata. In some embodiments, the import module includes a parsing and chunking engine configured to convert the input into a parse tree. In a further embodiment, the parse tree includes entities. In a further embodiment, (c)(ii) further includes adding the parse tree to the dynamic language graph. In some embodiments, (c)(ii) further includes associating entities with at least one verification source. In a further embodiment, the verification source is a website. In a further embodiment, the verification source is a program document or employee manual. In some embodiments, the game module is further configured to generate a basic natural language response. In some embodiments, the base natural language response includes at least one verification source assigned to an entity of the base natural language response. In some embodiments, the system further includes providing the base natural language response on a display of a computing device. In a further embodiment, the source of the at least one verification source is presented on the display of the computing device. In an even further embodiment, the source of the at least one verification source includes a link to the source of the at least one verification source. Attached Figure Description

[0013] The novel features of the invention are specifically set forth in the appended claims. A better understanding of the features and advantages of the invention will be obtained by referring to the following detailed description, along with the accompanying drawings, of illustrative embodiments in which the inventive principles are utilized, wherein: Figure 1 An example of a general learning mechanism in a game theory context is shown; Figure 2 An example of a general learning mechanism in a data flow context is shown; Figure 3 This illustrates the abstracted, basic input; Figure 4 The components of an input-output implementation of a general learning mechanism are shown; Figure 5 An exemplary computer system is shown; Figure 6A The search function using a common language mechanism is demonstrated; Figure 6B This demonstrates the categorization of entities within the text body; Figure 6C An exemplary parse tree for the text body is shown; Figure 7 An example of a basic input is shown; Figure 8 An example of a general learning mechanism for basic responses to user queries is shown; Figure 9 This shows the Google Bard response to the user's query; Figure 10 The ChatGPT-4 response to the user query is shown; Figure 11 The basic response with Wikipedia references is shown; Figure 12 An example of a general learning mechanism for translation is shown; Figure 13A The ULM response to the user query is shown; Figure 13B The ChatGPT-4 response to the user query is shown; Figure 13C This illustrates the categorization of various aspects of natural language queries; Figure 14A The ULM response to the user query is shown; Figure 14B The ChatGPT-4 response to the user query is shown; Figure 14C This illustrates the categorization of various aspects of natural language queries; Figure 15A This demonstrates ULM's performance on the MMLU-Pro leaderboard; Figure 15B This demonstrates ULM's performance on the MMLU-Pro leaderboard; Figure 15C This demonstrates ULM's performance on the MMLU-Pro leaderboard; and Figure 15D The performance of ULM on the MMLU-Pro leaderboard is shown. Detailed Implementation

[0014] While preferred embodiments of the invention have been shown and described herein, it will be apparent to those skilled in the art that such embodiments are provided by way of example only. Numerous variations, changes, and substitutions will now be conceived by those skilled in the art without departing from the invention. It should be understood that various alternatives to the embodiments of the invention described herein may be employed in carrying out the invention. The following claims are intended to define the scope of the invention and therefore cover the methods and structures within the scope of these claims and their equivalents.

[0015] The implementations of the technologies described herein can provide solutions to problems, including text enrichment, entity resolution, sentiment analysis, machine translation of low-resource languages, document analysis for compliance standards, security analysis, recruitment analysis, product compliance analysis, and foundational, accurate, and logical query-response models that provide interpretable and verifiable responses to user queries. Verifiable responses may include references to knowledge bases used to build query-response models or other implementations, or references to external reference sources (such as websites). In some implementations, the solutions may include providing rich parsing and dynamic language graphs for scalable natural language processing, which neither produces hallucinatory responses nor requires expensive dedicated hardware (e.g., GPUs, TPUs, etc.). The implementations of the solutions require no training or data cleaning, and all responses provided by the solutions are source-verified for user verification.

[0016] definition Intelligence: As defined in this paper, intelligence is the ability of a system to maintain and enforce the coherence of itself and its environment.

[0017] Grammar: Grammar is a structured list of constructions, which are basic units of language. Constructions have varying degrees of abstraction and possess both associated meaning and pattern. A syntactic-lexical continuum exists.

[0018] Language style sheets: Language style sheets include vocabulary, grammar, and subject areas.

[0019] Remodeling: In this paper, remodeling refers to modifying experience to ensure its optimal (efficient) representation.

[0020] Coherence: In this paper, coherence is defined as the maintenance of internal consistency and external relevance. Coherence can be viewed as consistency and integrity, and can have spatial, temporal, and structural components.

[0021] The Law of Coherence: The Law of Coherence can be defined by three statements. First, it guarantees that reality is coherent. Second, reality is the only thing that is coherent with all other things. Third, coherence guarantees possibility.

[0022] Domain of discourse (DD): A general domain canonical diagram capable of describing any domain, including domains with infinite relevance. DD can be additionally defined using equivalent terms, where DD is defined as a perspective structure.

[0023] Individual reality: the totality of DDs, where DDs can have non-overlapping, embedded, and overlapping relationships with each other.

[0024] Assimilation: Assimilation is a process that can be defined by a series of considerations. Assimilation requires always taking winning actions and never taking losing actions, taking the most efficient actions from continuously reshaped, improved and indexed experiences, and taking any legal actions or surrendering when there are no other options, which may result in another instance of the game in the same DD or an instance in a different DD, determined by compliance.

[0025] Adaptation: Adaptation is the process of determining the appropriate DD (Discovery Principle) to incorporate into the experience, including determining whether a suitable DD exists.

[0026] Background: Background is the set of things that cannot be changed for a given DD. Background includes hard-wired rules and change potentials, which include the boundary conditions for a given DD.

[0027] Rules: Rules are hard-coded rules (e.g., physical laws in the real world or the rules of chess in the form of computer software) that govern their relevant domains—the only rule that governs all domains is a coherence rule. Rules are binding rules, meaning they are self-enforcing.

[0028] Language instructions: In this paper, language instructions refer to inputs into a general learning mechanism. Language instructions may also be referred to as input, natural language input, discourse, or experience.

[0029] Dynamic Language Graph: In this paper, dynamic language graph refers to a data representation with a structure that can change over time. Dynamic language graphs can also be referred to as spatiotemporal graphs.

[0030] Universal Language and Language Game In some implementations, intelligence (or general intelligence) can be defined as the ability of a system to maintain and enforce coherence between itself and its environment. Coherence can include internal consistency and external relevance. Superintelligence (or superhuman intelligence) can be the result of the natural growth of intelligence.

[0031] Intelligence can be described by three dynamically intertwined aspects: perception (Sentio), which can be described as the way of perceiving, seeing, sensing, feeling, or receiving input; cognition (Cogito), which can be described as the way of thinking, knowing, understanding, or mental processing; and action (Facio), which can be described as the way of acting, performing, responding, making, actuating, creating, or influencing the environment.

[0032] Universal Language (UL) can be divided into Intuitive Language (IL) and Symbolic Language (SL). SL can be further divided into Fixed Language (FL) and Natural Language (NL). IL includes all types of sensory data, and the interpretation of IL (e.g., the mapping between surface structure and meaning) can be isomorphic. SL can include all other cases where the interpretation is not necessarily isomorphic. Therefore, IL can be considered a restricted case of SL. FL includes all mathematical languages, and the interpretation of FL can be fixed and universally accepted. NL can include all other cases. Therefore, FL can be considered a restricted case of NL.

[0033] Creating a superintelligent system is equivalent, both theoretically and practically, to creating a system that understands a universal language. In this paper, NL understanding can be equated with UL understanding. In short, the intelligence defined in this paper can be considered equivalent to natural language understanding.

[0034] High-level description Drawing insights from programming languages, language can be observed at three distinct levels: language form, language function, and language effect. Language form can include the outward manifestations of language: text, symbols, images, gestures, sounds, etc. Language function can include what language says: interpreted instructions that can be understood by their intended target (e.g., machine code). Language effect can include what language does: the causal consequences of its function. The effects of language provide the ultimate foundation for its meaning.

[0035] More specifically, the following may include novel perspectives on the problem of Natural Language Understanding (NLU): (1) Natural language can be viewed as a family of open systems that change with temporal and spatial mobility rather than as a single system with a fixed grammar and vocabulary. (2) Communication can be viewed as a means of transporting experience rather than an exchange of information, thereby enabling language instructions to be executed on the receiver to generate experience, which provides an ultimate foundation for its meaning. (3) Experience itself can be viewed as a rich continuum comprising direct or indirect, external or internal, detailed, generalized or abstract experiences. Thus, grammar and lexicon can be viewed as indirect, abstract experiences.

[0036] A comprehensive and coherent solution implementation may include the following core technologies: (1) a universal domain specification diagram (referred to herein as a discourse domain or DD) capable of describing any domain (including domains with infinite relevance); (2) a universal learning mechanism (ULM) capable of learning from experience in any domain and also from the domain specification itself; (3) a method for determining when and how to modify the underlying DD for language understanding (also referred to herein as TOE logic); and (4) specification of the language domain into language games with sufficient rich detail for implementation. These core technologies can be implemented using the computer systems described herein.

[0037] technology In some implementations of the ULM of NLU, the agent may need to possess the dual ability to understand the language within any particular domain and to understand in which domain the language should be understood. This disclosure provides a general domain specification diagram and a specification of a general language game (e.g., an implementation of decision making) with sufficient detail to successfully achieve these dual capabilities. In one aspect of this disclosure, a general domain specification diagram and a general learning mechanism may be provided to address each of the tasks described above.

[0038] A generalized domain specification diagram (DD) can be a self-driven, dynamic environment. In some implementations, a DD may include five sets of elements: entities, rules, context, participants, and objectives. In some cases, multiple sets of elements may also be referred to as pieces, game rules, the game board, game participants, and game objectives. Each instance of a game can be a direct, exhaustive experience corresponding to a DD. In some cases, other types of experience may also be introduced to further accelerate or supplement the methods presented herein.

[0039] In each DD, time is implemented as rhythm and space as background rather than auxiliary labels, making it ubiquitous. Time is generally incommensurable between different DDs unless overlap between two or more DDs requires synchronization and coordination. Causality can be implemented as a combination of the actions of the participants, their current state, timing, and all other elements in each DD. Initially, there can be three basic DDs: domain DDs (DD games), general language DDs, and the Generally Accepted Common Reality (GACR), which can be the objective world subjectively constructed by each agent. The totality of an agent's DDs (including their experience) can be called the agent's Individual Reality (IR). In some cases, IR can be represented by multiple dynamic language graphs arranged on multiple databases. Coherence, as the essence of intelligence, can be naturally maintained through the enforcement of each DD and further constrained by their overlap. In some implementations, there can be three aspects of coherence: spatial coherence, temporal coherence, and structural coherence. Different DDs can have overlapping, embedded, or non-overlapping relationships, and the overlapping part can be any of the five elements of a DD.

[0040] In some implementations, a Universal Learning Mechanism (ULM) can achieve universal learning through two intertwined processes: assimilation, which involves learning within a DD; and accommodation, which involves determining the correct DD for which assimilation occurs. In some implementations of assimilation, the ULM can take the current DD, all its experiences, and the current instance as input (e.g., experience, language instructions) to produce the next move within the current DD. In accommodation (which may occur in a DD game), the accommodation process can use the same input to produce a new DD, which can be a modification of an existing DD or a completely new DD. The TOE logic described below can be implemented to determine the dynamic interplay between assimilation and accommodation.

[0041] In some implementations, only assimilation may be required during learning in any particular domain, but ULMs that include unrestricted NLUs can leverage the dynamic interplay between these two processes, as the underlying topic changes frequently. Assimilation can be summarized by four considerations: (1) always take the winning move, (2) never take the losing move, (3) take the most efficient move from experience (experience can be continuously reshaped, improved, and indexed), and (4) take any legal move or surrender if nothing else, which may trigger another instance of the game in the same DD or in a different DD, determined by the compliance process defined below. In some implementations, the definitions of winning, losing, and legal moves can be determined by the current DD, where the DD itself can be part of the input parameters of the ULM. Note that taking the winning move can be analogous to taking the most efficient possible move—including inefficient moves or sets of moves does not constitute a win. In other words, if an move could have led to a win, then not taking that move can be considered a losing move (e.g., inefficient). This logic ensures that subsequent reasoning does not return incorrect winning strategies, because inefficient moves are not included.

[0042] In some implementations, compliance may include engaging in DD games, which can be summarized as follows: (1) DD games Reality body It can be any other DD, (2) a single DD game. Participants It can be oneself, (3) the background of DD game can be the law of coherence, (4) DD game Target It can generate with all existing experience coherent However, new DDs that produce non-failure outcomes for the current instance and (5) DD games can be subject to... law Constraints.

[0043] In some implementations, DD game law This can include: (1) trying different existing DDs within the agent's IR; (2) modifying, replacing, or adding elements of the current DD; (3) creating entirely new DDs; (4) asking clarifying questions about the current instance or suitable DDs and consulting other resources (such as websites); and (5) rejecting or modifying some of the existing experience or the current instance, which may be a key requirement for maintaining consistency. In some cases, efficient winning moves in DD games can be determined by TOE logic and can be learned through previous iterations of DD games.

[0044] In some implementations, the method for determining when and how to use the appropriate DD for input interpretation can be determined by TOE logic. TOE logic comprises a system of three truth elements: T (True), O (Otherwise), and E (Otherwise), and eight truth values, each a subset of {T, O, E}. When any utterance is interpreted in DD, its truth value can be defined as its conformity to the agent's IR. In understanding, a utterance (e.g., input, language instruction, experience) can first be interpreted and then accepted or rejected by the listener. If accepted, the utterance is executed on the agent's IR. Depending on the type of utterance (declarative, interrogative, imperative, exclamatory) and the truth value, the agent's IR produces four possible types of reasoning and other related actions in TOE: built-in reasoning, creative reasoning, declarative reasoning, and clarifying reasoning. The process of enforcing rules in DD can be considered built-in reasoning. This process can be considered creative reasoning when the structure of the agent's IR is altered. This process can be considered declarative reasoning when the agent evaluates the truth value of a statement against its IR. The process of imploding the possibility of assimilating experience can be considered clarifying reasoning. The relationship between the type, truth value, and execution of any accepted statement (e.g., input, language instruction) can be summarized in Table 1 below: Table 1 In some implementations, the specification of language games connects the game with general language understanding for ULM. Details of the implementation include grammar, pragmatic supremacy, and language games. (1) Grammar, which can be a structured list of constructions, which can include basic linguistic units. Constructions have varying degrees of abstraction and have both meaning and pattern associated with them. A syntactic-lexical continuum can exist. (2) Pragmatic supremacy: the meaning of language can be transformed by its use. Language knowledge of construction forms can be discovered and learned through use. (3) There can be two types of language games. Both can be single-player games. Understanding games can be played by the listener, and generating games can be played by the speaker. Language games can be played in the context of other DDs, which can serve as their background. The goal of understanding games can be the effective interpretation of utterances, which, if accepted by the listener, is performed on the listener in the background DD. The goal of generating games can be the intention statement that the speaker wants to make. Entities in language games can be constructions. The constraint rules in language games can be the validity of the interpretation, which can include pattern matching between the chosen construction, the current utterance, and all prior experiences.

[0045] Understanding game theory (which can also be viewed as the implementation rules for coherent interpretation of language instructions in other ways) can follow the following format: (1) Given the context DD and the current utterance, select a construction from the current list of constructions. (2) If a valid interpretation exists using the construction, decide whether to accept the interpretation; if not, select another construction, reject the statement, or change the context DD; if accepted, perform the interpretation according to the TOE logic. (3) If no valid interpretation exists, select another construction, reject the statement, or change DD.

[0046] Generative games can also be viewed as implementation rules for defining the coherence of experience (relative to the generator's IR) output in other ways, which can be done as follows: (1) Given the intentional experience to be conveyed in the current DD and the speaker's DD (model) to the listener, the speaker selects a construction from the list and constructs a statement using the experience. (2) The statement is interpreted in the speaker's DD (model). If the interpretation using the current construction is invalid, the process returns to the construction selection step; otherwise, the interpretation is performed in the speaker's DD (model) to generate the experience and is compared with the intentional experience. If they match, a decision is made whether to say the statement. If the decision is not to say the statement, the process returns to the construction selection step.

[0047] General learning mechanism In some implementations, the Universal Learning Mechanism (ULM) can be used... Figure 1 The diagram illustrates this. In this diagram, the discourse domain game module (referred to herein as the DD game module) is shown to include multiple discourse domains (referred to herein as DDs). Each DD can include a meta-level and a data level, where the meta-level can consist of rules, entities, context, participants, and objectives. The data level of a given DD can include experience, which can include direct or indirect, external or internal, detailed, generalized, or abstract information that has been incorporated into a given DD. Experience can be incorporated into one or more DDs via a process of accommodation and assimilation, where the DD game module selects appropriate DDs to coherently interpret the experience through accommodation, then assimilates the experience and maintains coherence within the DD. In some cases, incoming experience may be found to lack coherence with any of the DDs in the DD game module and may be rejected as meaningless. All DDs can be governed by a coherence law, where any experience that is ultimately assimilated can be added in a manner that maintains coherence between DDs (e.g., maintaining self-consistency and external relevance).

[0048] The incorporation of external experience can be viewed as an attempt to assimilate external experience into one or more DDs within the DD game module. Initially, external experience may be received by the import module. The import module may be responsible for importing external experience and providing it to the reshaping module. Before experience can be accepted into DDs (e.g., stored in a database), the reshaping module may be responsible for reshaping all imported experience. The reshaping module may include evaluating actions for efficiency before incorporation into one or more DDs. The improvement module may be responsible for improving existing experience in the DD game module (e.g., updating experience based on newly learned grammatical rules or ensuring that only the most efficient actions are retained in the DD). The indexing module may be responsible for indexing existing experience. The game module may be responsible for making decisions regarding assimilation and accommodation based on the current state of the DDs. The DD game module and the game module may require one or more DDs to fully incorporate the imported experience.

[0049] The reshaping process may include operations that reshape one or more past experiences to ensure an efficient representation of the experience. Efficient experiences may conform to one or more rules of the DD (Discussion Domain), may be complete, and may not include inefficient actions. In some implementations, an inefficient representation of an experience may be a representation that requires more computation than the experience within the interpretation domain or compared to other domains. Any experience found to be inefficient can be reshaped, which may include improving the efficiency of the experience representation. Ultimately, the original experience can be replaced by the reshaped experience.

[0050] In some implementations, existing experience can be made more efficient (reshaped) by selecting any existing experience with a total of n steps and evaluating it backward from step (n-1). Given the updated definition of DD, if a more efficient representation of the experience exists, the experience can be reshaped, and the reshaped experience can replace the original experience in the past experience database. As more external experience can be imported into the DD game module and the updated rules can be applied to DD in the DD game module, more efficient experiences can be generated iteratively.

[0051] In some implementations, the reshaping module, the improvement module, and the indexing module operate continuously within the context of a general learning mechanism, ensuring that new experiences learned by the general learning mechanism can be incorporated and that coherence can be maintained across the various DDs.

[0052] In some implementations, the logic governing the assimilation and accommodation process between the various DDs can be referred to as TOE logic, where TOE is an acronym for truth values ​​corresponding to true {T}, otherwise {O}, and elsewhere {E}. TOE logic involves a given understanding of all combined DDs, which together can be coherent / compliant with coherence rules. The value {T} indicates that the incoming language instruction (e.g., external experience) conforms to the knowledge base of each DD. The value assigned to {T} conforms to at least one of the DDs in one or more DDs that define the knowledge base, which is the source of the DDs for the DD game module. Alternatively, the incoming language instruction may be reasonable but does not conform to the current knowledge base, and is therefore assigned the value {O}. Finally, the value of {E} may correspond to an incoming language instruction that may not be understood within the context of a given DD but can be understood within a different DD. The value of {E} represents the input language instruction that may be illogical and inconsistent with the current knowledge base (DD), but may be illogical and consistent with another DD (e.g., a DD related to US history might not consider the input "1 + 1 = 2" illogical, but it would be illogical in a math-related DD). While each of these truth values ​​can have its own unique definition, the input language instruction can be defined by various combinations of the three basic truth values. Depending on the current knowledge base, the evaluation of the input language instruction can produce the following ultimate truth values: {}, which can be interpreted as impossible; {T}, which can be interpreted as true; {O}, which can be interpreted as otherwise true; {E}, which can be interpreted as true elsewhere; {T, O}, which can be interpreted as true; {T, E}, which can be interpreted as true somewhere; {O, E}, which can be interpreted as false; {T, O, E}, which can be interpreted as possible. In summary, the ultimate truth values ​​{}, {T}, {O}, and {E} can be considered as deterministic truth values ​​that do not require further clarification. The remainder can be categorized as uncertain truth values. This logic and its various effects on ULM functionality can be further generalized through statement types, which can be categories of incoming language instructions. Incoming language instructions can each lead to various actions that demonstrate the causal effect of the TOE logic output. Some incoming statement types do not require incorporating experience into the knowledge base or reconstructing experience within it, and may simply probe the existing knowledge base, generating a response (as resolved later in this paper through generative games), similar to interrogative and exclamatory incoming language instructions, or generating an action (which will depend on the association between the ULM and the hardware system), similar to imperative incoming experience. For an integration of the concepts in this paragraph, see the tables in the Summary of the Invention section.

[0053] While traditional concepts of reasoning may not apply in a ULM, and a ULM may not have a separate reasoning engine, in a sense, a ULM can be viewed as an automated reasoning system with only one built-in universal meta-rule (the coherence rule). All rules in a DD can be viewed as similar to the A→B rule, except that they are self-enforcing. Whenever A becomes true, B automatically becomes true. This process can be viewed as built-in reasoning or built-in inference. There is no universal A→B rule outside of any DD. This process can also be viewed as reasoning when the ULM changes its set of DDs to maintain coherence. When the ULM accepts a statement as true and adjusts its set of DDs to ensure that the statement conforms to reality, the direction of this reasoning can be from the description of reality (the statement) to reality. This type of reasoning can be viewed as creative reasoning or creative inference. Therefore, DDs can be dynamic. DDs change as DDs are learned. Similarly, the process of measuring the truth of a statement according to the ULM's DDs can also be viewed as reasoning. The direction of this reasoning is from reality to the description. This type of reasoning can be viewed as declarative reasoning or declarative inference. This can also be viewed as a process of imploding the possibility of reasoning by assimilating experience as a basis for reasoning. For example, if one accepted experience tells ULM that a person is either male or female, and another accepted experience tells ULM that the person is not female, then through reasoning, ULM knows that the only remaining possibility is that the person is male. This reasoning can be lateral: a clarification of previous possibilities. This type of reasoning can be considered clarifying reasoning or clarifying inference.

[0054] The rules of DD games can be viewed as implementation rules for the implementation of ULM. The purpose of DD games can be to use ULM to try to understand the other party's DD, with the ultimate goal of modifying or creating new DDs (assuming reasonable input) that are consistent with the previous states / experiences of all DDs (coherent) to generate an understanding of linguistic signals (e.g., linguistic instructions). The implementation rules can be as follows: (1) Always take efficient moves if efficient moves exist (e.g., moves with efficient results that will lead to the immediate termination of the game). (2) Never take inefficient moves: Before taking any move other than an efficient move, always calculate whether taking the considered move would lead to an efficient move by the opponent. If the considered move would lead to an efficient move by the opponent, reject the proposed move and consider another move that may be known from past experience to apply to the same process (but exclude moves that have already been considered). (3) Take the move with the highest efficiency index. If the current game configuration matches experience (e.g., an experience database includes one or more experiences in which games were played in the same way in the past and the current configuration was reached), take the move with the highest efficiency index in all next forward configurations. In at least some implementations, a “match” can be defined as (a) an exact match, plus (b) a configuration that is equivalent to the current configuration when one or more invariant transformations can be applied. Regarding the latter, the definition of an invariant transformation depends on the specific game but can include transformations such as rotations, translations, etc. (4) If no match is found with experience, take any efficient action. If no efficient action from past experience is available, attempt to take any new efficient action unknown from past experience. At this step, any heuristic rule (if any) can be applied to select the next action. Heuristic rules can be a combination of two types: a “match” heuristic and an “evaluation” heuristic. A “match” heuristic can evaluate the proximity of a match so that the system can use step (3) to make an action. An “evaluation” heuristic can evaluate action suggestions without invoking an index. In some implementations, heuristic rules can provide efficient computation.

[0055] As the system gains more experience (e.g., learns and updates its DD), there may be more instances of matching, resulting in fewer opportunities to use heuristic rules. Heuristic rules can be imported (learned via instructions) and can be used when there are no currently configured matches in the experience. (5) If no new efficient moves are available, surrender. It should be understood that in actual games, "surrender" means that the system has "lost" the current game, but in other DDs, "surrender" simply means that the system has decided that it cannot achieve its goal (e.g., "win") within the current DD, which likely means that a new DD is needed. For example, in general language comprehension, surrender simply means that it cannot be understood in the current DD, which leads the DD game to determine a new DD to try for new comprehension.

[0056] During a DD game, permitted actions may include the following: (1) The incoming linguistic instruction (e.g., linguistic signal, experience) may be interpreted using different DDs within the DD. (2) The ULM may attempt to modify the current DD, provided that the linguistic instruction remains coherent as it is assimilated into the current DD. To maintain coherence, some linguistic instructions or experiences may be rejected, and new entities may be added to the DD to generate a successful interpretation of the incoming linguistic instruction. New entities may be added first as placeholders for the first necessary instance as a possible action to modify the current DD in compliance. Experiences may be enriched and reshaped by further experiences (use, observation, contemplation, etc.) through assimilation. Rules, players, the board, or the objective of the current DD may also be modified to attempt to generate understanding. (3) If any part of the DD or input is found to be unreasonable or ambiguous, clarification questions may be asked about any part of the DD or input. (4) In cases where the source of the incoming linguistic instruction may not be available for clarification (e.g., incorporation of previously written text), the website may be consulted. (5) A completely new DD can be added to an existing set of DDs, wherein the new DD may include at least a portion of at least one existing DD. (6) If an incoming language instruction is found to be uninterpretable, the correctness of the incoming language instruction and the experience can be questioned.

[0057] In some implementations, the highest efficiency index can be determined for a DD game between two agents. This determination can be described as follows: For an experience with at least n+2 steps indexed on efficient experiences, the efficiency index at step (n+2) is always equal to or higher than the efficiency index at step n. In other words, for any matching configuration with n steps and an efficiency index of index(n), the maximum efficiency index of all forward configurations with n+2 steps can be equal to or higher than index(n). This can be proven as follows. Assume index(n) = Y / X, where X is the total number of matching experiences and Y is the number of efficient matching experiences. Also assume that all indices at step n+2 are: Y1 / X1, Y2 / X2, Y3 / X3… Y… Z / X Z If all exponents at n+2 are less than Y / X, then But that's impossible, because and , making This also leads to the conclusion that if there exists any Y < Y / X... i / X i Then there is another Y > Y / X. j / X j , making Therefore, either all exponents in the n+2 steps are equal to Y / X, or there exists an exponent greater than Y / X. All exponents for all previous steps in all experiences are 100%. Using these points, the length of all experiences can be normalized to the length of the longest experience by adding 100% to the winning side and 0% to the losing side after the experience terminates normally. If the system has all possible efficient experiences, the ULM can give the agent using the ULM the most efficient move available at any time. In some implementations, only efficient experiences can be considered in this determination. This is because any inefficient move by the opponent will only increase the agent's efficiency exponent from that point. In the case of the opponent wasting a move, the agent can take another step with a higher efficiency exponent. If the improvement process turns an inefficient move into an efficient move, it can increase the exponent of the initial configuration. If the improvement process delays failure, it may not change the exponent immediately, but it can provide more possible existing or future efficient matches, potentially increasing the future exponent of the initial configuration. For all matching efficient configurations (where the agent taking the next move from that configuration ultimately wins through increased experience), the configuration adds 1 to both the denominator and numerator of the exponent, making the exponent higher and potentially increasing the highest winning exponent for the matching configuration. For all matching unsuccessful configurations, the configuration does not decrease the highest winning exponent. For any configuration with n moves, experience improvements and additional efficient experience can increase, but never decrease, the maximum efficiency exponent for all forward configurations with n+1 moves, where n+1 moves are the next moves the agent can choose from the current configuration.

[0058] In some implementations, the ULM can be represented by a generic ontology diagram, which can be abstract, language-independent, and based on a global ID representing the ontology. In some implementations, the generic ontology diagram can enforce the coherence of the ULM. In the generic ontology diagram, (1) entities can be basic dynamic elements, (2) sets can be groupings of entities and properties, where properties can include attribute-value pairs, some of which can be objective (like measures that can remain unchanged with measurement) and some can be subjective (like evaluations that can change with evaluators), (3) structures can be groupings of sets and relations, where relations can be defined as tuples of entities and relationships between entities, (4) systems can be groupings of structures and transformations, where transformations can be defined as rules of change (such as "if A then B"), and (5) organisms can be the most comprehensive components of the ontology and can include groupings of systems and objectives, where objectives can be defined as statements, descriptions, and claims about reality.

[0059] In some implementations, the ULM can be represented by a universal worldview diagram. The universal worldview diagram can represent a knowledge base that includes various discourse domains, and the DD dependency structure that enforces perspectives in the context of each discourse domain. The meaning can change depending on the DD being considered, where the meaning can be made precise in a given DD by the following elements: (1) the goal, which provides the definition of winning in the current DD and the claim to reality; (2) the rule, which provides the rules of change, logical potential and consequences (e.g., "if A then B") in a given DD; (3) the participant, which can be defined as the external entity that initiates change under the constraints of the rule; (4) the context, which can be defined as the hard-wired constraints (claims) of reality in a given DD; and (5) the entity, which can be defined as the element in a given DD.

[0060] In some implementations, the knowledge base that forms the initial basis for the DD of the ULM may include the inclusion of a language style sheet, which may include a large information corpus (e.g., Wikipedia). In some cases, the validation source for this document may include a large information corpus. The language style sheet may include a vocabulary (e.g., words and phrases used in the corpus), grammar (e.g., idiomatic usages of the vocabulary), and subject areas (e.g., some category representations of knowledge, such as Wikipedia page titles).

[0061] In some implementations (examples of which are in) Figure 2(As described in the text), the general learning mechanism can perform many operations. In some implementations, internal instruments and external sensors can include means of acquiring external information (e.g., experience, language instructions), which can be in the form of language sent to the agent, instrument, or environment. The ULM can authorize and / or authenticate content data and metadata (e.g., enforcement of coherence) and subsequently determine the relevant metadata of the input. In the case of unreasonable input, the input can be rejected at the authorization / authentication stage. The ULM can interpret the input (e.g., confirm that the input type is audio, video, etc.) to understand the structure of the signal (e.g., filter noise). The ULM can employ a parsing and chunking engine to build a parse tree of the input and assist in literalization (e.g., check if chunks are meaningful), where the chunks can have different sizes, moving from larger chunks to smaller chunks as necessary. During parsing chunks, ULM's parsing and chunking engine can analyze chunks for use in attaching (e.g., assigning basic linguistic functions, such as in nouns, verbs, etc.), coordination (e.g., fit in the XOR parse tree of nouns and objects), reference (e.g., preserving contextual meaning), and ellipsis (e.g., evaluating omitted terms whose identity is to be resolved). Coordination can further include grammatical concepts of conjunctions or the structure of conjunctions in the input (e.g., and, or, neither, but, if, because, etc.). Reference can further include relational basising of pronouns. Relational basising of pronouns can provide context for their usage in the input (e.g., what does "he" refer to in the context). In some implementations, pronouns can include pronouns, verbs, or adjectives. In some implementations, ellipsis can be easily recovered or detected by the interlocutor. ULM can ultimately assign meaning to the input via the accommodation and assimilation processes discussed elsewhere in this document. The accommodation process can provide appropriate directives (DDs) that interpret the input based on its fundamentalized context, where fundamentalization includes entity fundamentalization (nouns), relational fundamentalization (adjectives), and causal fundamentalization (verbs). At the metadata determination stage, signal structure understanding stage, and meaning assignment stage, the ULM can request additional information from the sending agent, instrument, or environment.

[0062] Layered analysis and foundationalization of language In some implementations, incoming data (e.g., language instructions, experience) can be parsed by a parsing and chunking engine that transforms raw input (e.g., text) into rich, hierarchical parsing of natural language for both structured and unstructured inputs. The parsing engine can parse the input into distinct sets of chunks, and these sets may vary in size, at least in some of the elements comprising the chunks. In some implementations, a chunk comprises one or more basic elements, including characters, words, sets of words, or entire sentences. The parsing and chunking engine can dynamically boost and increase the size of the basic elements. The basic elements can be organized into a parse tree (e.g., a tree data structure). The parse tree can be overlapping and replicates syntactic, semantic, and pragmatic relationships between the basic elements via baseification, and each of the chunks comprising the parse tree can be resolved and appropriately tagged (e.g., nouns, verbs, adjectives, ellipses). Parsing and chunking engines can use natural language models (e.g., language style sheets) as a foundation to enrich the raw input by identifying, classifying, and dissolving legitimate chunks, which can then be fundamentalized and treated as a whole as a representation of the input's meaning. Fundamental elements are used to provide the basis for the fundamentalization of meaning within the actual ontology. In some implementations, the ontology can be a unique identifier used to label the individual fundamental elements within the parsed input data. The fundamentalization of meaning provides at least contextualization, disambiguation, and resolution of word and concept-to-reference for each fundamental element. For example, parsing and chunking engines facilitate ULM's understanding of synonyms such as "global economy" and "world economy." Furthermore, the parsing operations described herein provide a means of providing accurate, detailed, interpretable, and reliable interpretation of incoming data (and generating outgoing responses), even on sparse datasets (e.g., system documents, contracts, historical documents).

[0063] In some implementations, natural language models can be generated from knowledge bases such as Wikipedia, news articles, online articles, expert engineering (e.g., linguists and language experts), and social media websites. In some cases, the validation source for this article may include a knowledge base. The basic components of a knowledge base may include a vocabulary, grammar, and subject domains (e.g., relevant topics). One or more natural language models used in a specific context may be built using a custom knowledge base (as mentioned in the staff handbook or Wikipedia). Additionally, the use of a given knowledge base can ensure that the interpretation of incoming data and the derivation of outgoing data (e.g., the experience being interpreted and the experience being conveyed) can be based on the given knowledge base and will not produce illusions (e.g., incorrect responses generated based on the probability of the next word).

[0064] In some implementations, the natural language model (ULM) underlying the parsing and chunking engine can be adapted. The language model can incorporate new languages ​​and their usage into its understanding of language. This incorporation can be crucial because, as languages ​​change, the ULM may need to be able to learn over time, since the meaning of a language is defined by its use rather than by a static interpretation of its meaning. To adapt to and adhere to the laws of coherence, the adaptive language model can use a compiler to detect inconsistencies and consistency in language syntax, semantics, and entity relations. In some implementations, the compiler can be used to compile frequently used procedures. In some implementations, the compiler can be used to efficiently store frequently used procedures. In some implementations, the compiler can be used in a manner similar to a compiler used in computation to translate a higher-level language into a lower-level language. The principles of the compiler can be transferable to store representations of natural language understanding.

[0065] exist Figure 3 In some implementations, the baseification of meaning includes entity baseification (e.g., identifying nouns and assigning them meanings), relation baseification (e.g., adjectives and assigning them to nouns), and causal baseification (e.g., assigning them to variations). In some implementations, entity 310 may be assigned a connection 350 to entity 330 (e.g., pronouns and nouns used later). In some implementations, connection 350 may form links in a parse tree generated by a chunking and parsing engine. In some implementations, connection 350 may represent intersentential relationships where the distance between related entities is unrestricted. Parsing and chunking engines using their natural language models, discussed elsewhere in this document, can understand such associations and assist in disambiguation and contextualization of words within the input. In some implementations, reference 340 may be assigned to one or more entities (e.g., entities 320 and 330) and may be used to base the reference to the logical meaning / source in the input. In some implementations, reference may be used to base a complex set of entities to external references. For example, external references may include websites such as Wikipedia as verification sources. The fundamentalization of meaning can provide a logical and verifiable explanation of the input, thereby eliminating the possibility of illusion.

[0066] In some implementations, a novel logic can be used to process raw input data (e.g., language instructions). Novel logic for processing raw input data into a parse tree includes (i) automatically labeling any input data as edge cases or anomalies (also known as “out-of-distribution” in the context of neural networks) and collecting it into buckets for individual processing; (ii) automatically enforcing appropriate parsing of the input text; (iii) automatically enforcing global consistency in the parse tree and the final dynamic language graph; (iv) achieving an open-closed world, meaning a completely closed world under referential relations, which allows new entities, properties, relations, and causal relationships to be dynamically created into the dynamic language graph discussed below in a coherent (self-consistent and externally relevant) manner; and (v) eliminating the possibility of hallucinations by interpreting the parse tree in the dynamic language graph, inserting new information into the dynamic language graph, or rejecting input as meaningless content.

[0067] The chunking and parsing engine can build a set of instructions to be executed. These instructions can be the result of the ULM's understanding of input given its previously learned input (e.g., experience). For example, previously learned input can provide a basis for building the set of instructions to respond to input in a rational manner (e.g., answering questions based on the appropriate context of the input). In some implementations, these instructions can be machine-readable instructions. In some implementations, these instructions can lead to a verifiable basis for the response to the input.

[0068] In some implementations, a data-driven approach can be used to adjust the language model incorporated into the ULM. Data-driven approaches include (i) using initial grammatical rules (or meta-rule templates) encoded as language style sheets, (ii) automatically detecting and generating pragmatic rules from input language data (the meaning of a language can be defined by its use), (iii) generating new instances of grammatical rules based on the input to maintain rule coherence, which may include inserting new rules, and (iv) dynamically adjusting / building dictionary models and various domain specifications representing the language domains of the natural language.

[0069] In some implementations, basicization can disambiguate terms. In some cases, terms can have context-dependent meanings, just like words. work This situation. work It can have a wide range of extensions and intensions. Parsing and chunking engines can provide disambiguation for terms because the meaning assigned to a given term can reflect its usage and context. For example, the term... work Sometimes may be with job Synonyms, but other times terms work Possibly with artistic productSynonyms (e.g., a work of art). The parsing and chunking engine's basification of terms allows for the assessment of terms to obtain their connotative meaning, not just their denotative meaning. Additionally, terms can be basified within the context of the rest of the sentence, meaning that pronouns, ellipses, and vague references to terms at other points in the sentence can be associated with or basified to the terms they refer to.

[0070] Dynamic Language Graph In some implementations, the ULM can be partially represented by a dynamic language graph (e.g., a spatiotemporal graph), which can follow a generic ontology graph, where entities within the dynamic language graph can be basic dynamic elements of an entity ontology. Sets can be groupings of entities and properties, where properties can be attribute-value pairs. In some implementations, some properties can be objective (e.g., measurements that do not change with measurement), and others can be subjective (e.g., evaluations that vary with the evaluator). Structures can be groupings of sets and relations, where relations can be defined as tuples of entities and relations. Systems can be groupings of structures and transformations, where transformations can be defined as rules of change (such as "if A then B"). Finally, organisms can be the highest-level ontology components and constitute groupings of systems and objectives, where objectives can be defined as statements, descriptions, and claims about reality.

[0071] In some implementations, the ULM can be represented in part by a novel entity-relation-property-causal dynamic language graph (referred to herein as a dynamic language graph or DLG). A dynamic language graph can include domains (e.g., discourse domains, English DDs, Chinese DDs), entities, and relations. Entities and relations can include knowledge and associations within a domain, and the domains can be disjoint (e.g., domain A is completely separate from domain B), embedded (e.g., domain A is contained within domain B), or overlapping (e.g., domain A is partially contained within domain B). A dynamic language graph includes at least entities (e.g., words, characters, word sets, sentences), relations between entities (e.g., such static states of entities), and causal relationships (or dynamism) of entities, properties, and relations in natural language. In some implementations, the dynamic language graph can be implemented using an SQL server, allowing causal relationships between entities, properties, and relations in natural language to be fundamentalized and replicated within the dynamic language graph. Dynamic language graphs can be implemented to allow new causal relationships in natural language to be rapidly inserted without pruning the graph (e.g., language usage changing over time). Additionally, in some implementations, the parsed input discussed elsewhere in this document can be optimized for large-scale, fast computation and efficient memory usage.

[0072] In some implementations, input (e.g., language instructions, experience) can be transformed into one or more parse trees by a parsing and chunking engine and matched against one or more parts of the dynamic language graph. If the first parse tree fails to match the dynamic language graph, an otherwise condition can be triggered, and one or more other parse trees can be attempted to match against one or more parts of the dynamic language graph. If none of the one or more parse trees match any part of the dynamic language graph, the input can be inserted into the dynamic language graph or rejected, depending on whether the input is reasonable. If the input is found to be reasonable and can be incorporated into the dynamic language graph, it can indicate new grammatical rules that the dynamic language graph was unaware of before the new input was inserted. Assuming that the input can imply new grammatical rules, then those rules can be copied and enforced in the appropriate domain of the dynamic language graph (e.g., refactoring and improvement modules). In some implementations, the dynamic language graph can be sufficiently enriched (e.g., exposed to large knowledge bases such as Wikipedia), enabling the parsing, enrichment, and elimination of most possible meaningful inputs (without new insertions). However, the opportunity to insert and enforce new grammatical rules can be an important aspect of the learning process.

[0073] In some implementations, the dynamic language graph can be implemented in an SQL database or SQL server, and the compiler performs computations instead of matrix-vector operations of a neural network architecture. In some implementations, the dynamic language graph includes a knowledge base that may include the totality of all instances of the DD and a complete spatiotemporal history stored in an optimal dynamic SQL database.

[0074] In some implementations of the Dynamic Language Graph 440 (DLG 440), the DLG 440 can be as follows: Figure 4 The described implementation is in the query-response model. Figure 4 In this embodiment, language model 420 can be used to inform parsing and chunking engine 430, which can generate one or more parse trees of input 410 that can be stored in DLG 440. The parse trees can include chunks representing various entities resolved from input 410, fundamentalizing these entities and their relationships and causal relationships to ensure verifiability. In the depicted embodiment, DLG 440 includes multiple domains (e.g., DDs), entities (e.g., England, United States), relationships (e.g., the relationship between a US DD and an England DD), and causal relationships. In the depicted embodiment, a static representation of DLG 440 is provided, in which causal relationships may not be verifiable because causal relationships can be representations of the real, non-static nature of time and the DLG. Figure 4An example use case of DLG 440 is illustrated, where input 410 can be parsed by parsing and chunking engine 430 according to the grammatical rules of the language style sheet. Input 410 is matched against the knowledge base contained in the DD of DLG 440, and a coherent and verifiable output 450 can be produced. Output 450 is referenced and responds to input 410, where input 410 can be in the form of interrogative reasoning or other types of reasoning discussed elsewhere in this paper. In the example of interrogative reasoning, input 410 can be understood via understanding games discussed elsewhere in this paper, while response 450 can be generated via production games discussed elsewhere in this paper.

[0075] Computer System This disclosure provides a computer system that can be programmed to implement the methods of this disclosure. Figure 5 A computer system 501 is illustrated, which is programmed or otherwise configured to implement, control, or interface with the ULM disclosed herein. The computer system 501 may, for example, manage the parsing and chunking of input, implement TOE logic, construct and manage dynamic language graphs, generate basic natural language responses, receive natural language input (e.g., experience, instructions), perform accommodation or assimilation, etc. The computer system 501 may be a user's electronic device or a computer system remotely located relative to that electronic device. The electronic device may be a mobile electronic device. The electronic device may be a wearable device.

[0076] Importantly, computer system 501 can be one of multiple computing systems that implement or communicate with the ULM. For example, the ULM can communicate with multiple databases on multiple computing systems. For instance, cloud storage can be used to maintain discourse domains that the ULM has the right to read or modify. In another example, the ULM can parallelize computation across multiple computing systems. For instance, the ULM can continuously reshape the experience (e.g., update dynamic language graphs) using background computations performed on one or more computer systems communicating with computer system 501. Computer system 501 may additionally include multiple CPUs, GPUs, TPUs, or other processors.

[0077] Computer system 501 includes at least one processing unit (CPU, GPU, TPU, etc., also referred to herein as a "processor" and "computer processor") 505, which may be a single-core or multi-core processor or multiple processors for parallel processing. Computer system 501 also includes memory or memory location 510 (e.g., random access memory, read-only memory, flash memory), electronic storage unit 515 (e.g., hard disk), communication interface 520 for communicating with one or more other systems (e.g., network adapter), and peripheral devices 525 (such as cache, other memory, data storage, and / or electronic display adapter). Memory 510, storage unit 515, interface 520, and peripheral devices 525 communicate with CPU 505 via a communication bus (solid line) such as a motherboard. Storage unit 515 may be a data storage unit (or data repository) for storing data. Computer system 501 may be operatively coupled to computer network ("network") 530 via communication interface 520. Network 530 may be the Internet, the Internet and / or an extranet, or an intranet and / or extranet communicating with the Internet. In some cases, network 530 is a telecommunications and / or data network. Network 530 may include one or more computer servers that can enable distributed computing, such as cloud computing. In some cases, network 530 may enable a peer-to-peer network via computer system 501, which can make devices coupled to computer system 501 act as clients or servers.

[0078] At least one processing unit 505 can execute a sequence of machine-readable instructions, which may be embodied in a program or software. The instructions may be stored in a memory location such as memory 510. The instructions may be passed to at least one processing unit 505, which may then be programmed or otherwise configured to implement the methods of this disclosure. Examples of operations performed by at least one processing unit 505 may include instruction fetching, decoding, execution, and write-back.

[0079] At least one processing unit 505 may be part of a circuit, such as an integrated circuit. One or more other components in system 501 may be included in the circuit. In some cases, the circuit is an application-specific integrated circuit (ASIC).

[0080] Storage unit 515 may store files, such as drivers, libraries, and saved programs. Storage unit 515 may store user data, such as user preferences and user programs. In some cases, computer system 501 may include one or more additional data storage units located outside computer system 501 (such as those located on a remote server communicating with computer system 501 via an intranet or the Internet). In some cases, storage unit 515 may include a relational database management system or RDBMS. In some cases, the RDBMS may be managed via instructions encoded in SQL.

[0081] Computer system 501 can communicate with one or more remote computer systems via network 530. For example, computer system 501 can communicate with a user's remote computer system. Examples of remote computer systems include personal computers (e.g., portable PCs), tablet PCs (e.g., Apple® iPad, Samsung® Gala3 Tab), telephones, smartphones (e.g., Apple® iPhone, Android-enabled devices, Blackberry®), or personal digital assistants. Users can access computer system 501 via network 530.

[0082] The methods described herein can be implemented via machine-executable code (e.g., a computer processor) stored in an electronic storage location of computer system 501, such as memory 510 or electronic storage unit 515. The machine-executable code or machine-readable code can be provided in software form. During use, the code can be executed by processor 505. In some cases, the code can be retrieved from storage unit 515 and stored in memory 510 for access by processor 505 at any time. In some cases, electronic storage unit 515 can be omitted, and machine-executable instructions are stored in memory 510.

[0083] The code can be pre-compiled and configured for use with machines that have processors adapted to execute the code, or it can be compiled during runtime. The code can be provided in a programming language, which can be selected to enable the code to be executed either pre-compiled or compiled.

[0084] Aspects of the systems and methods provided herein (such as computer system 501) can be embodied in programming. Aspects of the technology can be considered as “products” or “manufactured goods” typically in the form of machine (or processor) executable code carried on or embodied in a machine-readable medium and / or associated data. Machine-executable code can be stored on electronic storage units, such as memory (e.g., read-only memory, random access memory, flash memory) or hard disks. “Storage” media can include any or all of the tangible storage of computers, processors, etc., or their associated modules (such as various semiconductor memories, tape drives, disk drives, etc.), which can provide non-transitory storage for software programming at any time. All or part of the software can sometimes communicate via the Internet or other various telecommunications networks. Such communication can, for example, enable the loading of software from one computer or processor to another, e.g., from a management server or host to a computer platform for an application server. Therefore, another type of medium that can carry software elements includes physical interfaces between local devices, light waves, radio waves, and electromagnetic waves used via wired and optical ground networks, and via various wireless links. Physical elements carrying such waves (such as wired or wireless links, optical links, etc.) can also be considered as media carrying software. As used herein, unless limited to non-transitory tangible "storage" media, the term "readable medium" for a computer or machine refers to any medium that participates in providing instructions to a processor for execution.

[0085] Therefore, machine-readable media (such as computer-executable code) can take many forms, including but not limited to tangible storage media, carrier media, or physical transmission media. Non-volatile storage media include, for example, optical discs or magnetic disks (such as any kind of storage device in any computer), such as those used to implement the database shown in the attached figure. Volatile storage media include dynamic memory, such as the main memory of such a computer platform. Tangible transmission media include coaxial cables, copper wires, and optical fibers, including wires that form the bus within a computer system. Carrier transmission media can take the form of electrical signals or electromagnetic signals or sound waves or light waves (such as sound waves or light waves generated during radio frequency (RF) and infrared (IR) data communication). Therefore, common forms of computer-readable media include, for example: floppy disks, flexible disks, hard disks, magnetic tapes, any other magnetic media, CD-ROMs, DVDs or DVD-ROMs, any other optical media, punched card tapes, any other physical storage media with a perforated pattern, RAM, ROM, PROM and EPROM, FLASH-EPROM, any other memory chips or tapes, carrier waves for transmitting data or instructions, cables or links for transmitting such carrier waves, or any other media from which a computer may read programming code and / or data. Many of these forms of computer-readable media may involve carrying one or more sequences of one or more instructions to a processor for execution.

[0086] Computer system 501 may include or communicate with an electronic display 535, which includes a user interface (UI) 540. Examples of UIs include, but are not limited to, graphical user interfaces (GUIs) and web-based user interfaces.

[0087] In some cases, users may interact with computer system 501 via one or more input devices. For example, users may interact with computer system 501 via a mouse and keyboard, touchscreen, microphone, virtual / augmented / mixed reality eye-tracking or haptic input settings, or other input devices through which users can transmit information to computer system 501.

[0088] The methods and systems disclosed herein can be implemented by one or more algorithms. These algorithms can be implemented in software when executed by the central processing unit 505.

[0089] Example Example 1: Processing massive amounts of program documentation Query-response models that provide solutions to user problems are valuable tools for companies, organizations, and the like. ULMs are ideal for this task because they do not produce illusory answers and provide sourced and cited responses to resolve user queries. This ensures that solutions to user queries can be referenced to documents that can be used to validate the responses provided to users, thus ensuring that no response is generated without a coherent foundation in relevant domains (e.g., program documentation, employee handbooks, etc.). Additionally, ULMs can learn from sparse datasets (e.g., datasets too small to adequately train an LLM), which is common in organizations that rely on internal documents for employee reference.

[0090] The performance of the ULM described elsewhere in this paper is compared with ChatGPT-3 by evaluating its performance on the SQuAD v1.1 dataset. The SQuAD v1.1 dataset is used to benchmark a system's ability to understand a set of Wikipedia articles and answer questions related to them. The implementation of ULM discussed elsewhere in this paper scores 89, while ChatGPT-3 scores 69.

[0091] Similarly, this text enrichment and entity disambiguation method was applied to 2225 BBC news articles for tasks involving contextualization, classification, disambiguation, detailing, and anchoring of content from these articles. ULM for this task was shown to outperform the industry-standard tool spaCy. Specifically, ULM outperformed spaCy in performing natural language tasks related to a corpus of BBC news article texts. Thanks to the fundamentalization mechanisms discussed elsewhere in this paper, ULM is shown to provide improved entity recognition. For example, ULM is shown to provide larger corpus-specific contextualization (relationships between who, what, where, when, and why). This fundamentalization is illustrated in several ways, such as... Figure 6A As shown, ULM demonstrates improved language comprehension by implementing a search function to demonstrate a contextualized understanding of terms of interest. The term "Germany" is queried via the search function and shown associations with various fragments and articles in the BBC Corpus. When selecting a document from the returned list, the details of the selection can be evaluated. Additionally, other entities or descriptions of interest and their categories are presented for that selection. For example, such as... Figure 6B As shown, based on a broad understanding of the content of this selection, the chosen option is associated with the business school category. Furthermore, Figure 6C An example parse tree for a single selection is shown. This parse tree demonstrates a complete understanding of the complex details of natural language illustrated in that selection (e.g., the relationships between terms discussed elsewhere in this article).

[0092] Example 2: Parsing Queries and Accurate Responses Existing query-response systems based on machine learning and large language models (as well as systems used for translation and sentiment analysis) typically rely on self-attention mechanisms to generate output. Self-attention is a matrix-matrix product and a purely mathematical way of generating output, making it prone to illusions. When using self-attention, there is no semantic foundation or verifiable reference to the output to ensure it accurately reflects coherent facts; instead, the output may incorporate, for example, misleading information implied by the question itself. Often, the output produced by a self-attention mechanism may appear correct but is incorrect and may not be easily verifiable. ULM does not rely on self-attention; instead, it uses semantic foundations derived from a knowledge base initialized from Wikipedia.

[0093] The step upon receiving input from a ULM is to parse the input into logical parts or entities (e.g., words, word sets, characters). For example, as... Figure 7 As shown, in the sentence "male soldiers wore a collar controlled by their superiors that could interfere with their life force; all of these collars were connected to the gem and the scepter," each entity in the sentence is accurately determined and enriched by the parsing operation. Figure 7 The example shown illustrates the types of entities derived, enriched, and resolved by the ULM parsing engine. It can be seen that various singular nouns (collar, life force, gem, etc.) and plural nouns (soldiers, superiors, etc.) are accurately identified and labeled as "NN" and "NNS," respectively. Additionally, the relationships between the various terms are also established and... Figure 7 The arrows indicate this. For example, a series of arrows indicates a connection between the words "soldierswore a collar controlled by their superiors," showing a chain of relationships that indicates the superiors are the ones who control the collar, and the collar is worn by the soldier. Figure 8 This example is shown in the context of dynamic language graphs and ULMs discussed elsewhere in this article.

[0094] Existing query-response systems (such as ChatGPT-4 and Google's Bard) exhibit hallucinations when asked questions about this example input. Figure 9As shown, when asked, "In 'The Corean Chronicles,' who controls the male soldiers' collars? Please answer as briefly as possible," Google's Bard hallucinated the wrong answer and responded, "In 'The Corean Chronicles,' matrites control the male soldiers' collars." Similarly, as... Figure 10 As shown, the ChatGPT-4 responded to the same input with the illusion that "in Leh Modesitt Jr.'s 'The Corean Chronicles' series, the male soldiers' collars are controlled by Soarers." However, the ULM discussed in this article responded simply with "their superiors."

[0095] Example 3: Basic Information in ULM One implementation of ULM is built on a knowledge base derived from Wikipedia articles. This knowledge base provides a means of matching inputs with what ULM already understands, thus providing basic references to various entities in the inputs and outputs.

[0096] Figure 11 An example is demonstrated where the ULM is exposed to a random sentence from a BBC media article that reads, “[a]cademics from the Institute of Education at London University found that 'games literacy' was a key skill for youngsters.” In parsing this input, the ULM not only provides language understanding as discussed in earlier examples, but also provides a reference to a suitable Wikipedia article that emphasizes that the extracted entity referring to “the Institute of Education at London University” is indeed a real organization, and therefore can be understood by the ULM in a way that can be verified by humans to be accurate in its understanding of what the entity refers to.

[0097] Example 4: ULM for Translation Current machine learning approaches to language translation rely on a learned mathematical mapping between source-language neural network architectures and target-language neural network architectures. This approach can be somewhat successful for high-resource languages ​​(e.g., Spanish relative to English, where a large number of accurate, direct sentence pairs exist for translation). However, given the current level of available direct translation, low-resource languages ​​(e.g., Cantonese relative to English) are not well-suited to neural network translation methods, resulting in insufficient text corpora for training the neural networks to achieve high performance.

[0098] In addition to the data burden of existing machine learning methods for translation, there are further preprocessing requirements. Training data is typically preprocessed (e.g., poor translation removal, word segmentation, stop word removal, stemming, lemmatization) before a classifier network is trained to label monolingual data, thereby learning a multilingual embedding space for measuring the similarity of possible sentence pairs (one in the source language and one in the target language). The mining and final use of multilingual data are constrained by these limitations and are often prohibitively costly and time-consuming.

[0099] Figure 12 An example of a ULM is shown below. This example provides translation for low-resource languages, such as Cantonese as a counterpart to English. The Cantonese language data is obtained from Wikipedia and the grammar rules are established by Cantonese experts, which are used to provide a knowledge base for the task-specific ULM. Without a neural network, the ULM is implemented to (1) parse the raw (uncleaned) Cantonese data, (2) enrich the parsed data with entity recognition, classification, and decomposition, and (3) translate the enriched, structured, and parsed raw Cantonese data into English. These processes are accomplished using dynamic language graphs and parsing and chunking engines discussed elsewhere in this paper. This tool can serve as a lightweight, local solution for translating low-resource languages ​​in a very fast, accurate, and computationally inexpensive way.

[0100] Example 5: Application of Software-Defined Agile Operations A software-defined agile operational application (ACE) system for distributed, hierarchical command and control (C2) nodes is implemented via the logic of a ULM (Ultra-Language Model). The inference engine resolves abstract entities through a common language model, abstract style sheets, a spatiotemporal knowledge base with overlapping discourse domains, and the LLM.

[0101] ACE is implemented as a proactive and reactive maneuvering program that executes within a threat timeline to enhance survivability while generating combat power. ACE employs a centralized command, distributed control, and decentralized execution capability, where permissions are organized hierarchically or a set of permissions is delegated along the chain of command and activated only when conditions are met, while connectivity is intermittent. Using the foundation of ULM discussed elsewhere in this paper, ACE is implemented as a governance protocol for: (1) dynamically understanding mission-oriented commands (such as commands written in natural language) from and to C2 nodes; (2) customizing optimal force packages and tactics up and down the chain of command based on the spatiotemporal state of joint C2 nodes (such as flight readiness level, geolocation, enemy location), logical potential fixed by the spatiotemporal state (which constrains force packages and tactics), and mission-oriented commands (which further constrain force packages and tactics); and (3) enforcing consistent strategies across dynamic operational spaces. ACE is implemented using a common ontology diagram, a common worldview diagram, and synchronization and coordination between DDs. ACE is implemented using the totality of all instances of DD stored in an optimal dynamic SQL database, along with its complete spatiotemporal history, where the compiler handles most of the computational tasks required to maintain the database. The knowledge base is initialized using English Wikipedia as a style, and includes a vocabulary, grammar, and subject areas.

[0102] The ACE is implemented using distributed C2 node orchestration logic, including: (1) a complete specification and dynamic visualization of real-time instantiation and population of the general ontology diagram and the general worldview diagram; (2) a multimodal natural language interface between nodes for managing node worldviews, knowledge bases, and language style sheets; visualization of precise understanding of mission-oriented commands, resources, and tactics; and (3) provable contextualized custom force packages using various mission-oriented commands written in natural language. This ACE is demonstrated in a simulated environment of a real dynamic combat space, where the combat space is managed by the software-defined ACE.

[0103] Example 6: World Language Game Series The ULM is incorporated into the World Series of Language Games (WSLG). The games are open to any system (including humans) and to any domain or language. The games are played and scored efficiently and are continuous, dynamic, and entertaining, and are open to audiences for viewing or research. The games are scored by humans, as only humans are capable of judging coherence and intelligence. The rules of the games consist of the following: (1) one-on-one, turn-based dialogue; (2) the total number of rounds / turns and other rules of the game or multiple games are negotiated between the competitors and the negotiation is part of the game; (3) each competitor starts with 0 points and gains 1 point for each win; and (4) competitors are stratified according to their total points, where the game is played only between opponents from the same or adjacent strata. A competitor loses the game if they are assessed as having committed three fouls, or if they are eliminated. Elimination occurs if a competitor is accused of incoherence by their opponent and the incoherence is verified by a group of three; otherwise, the accuser is assessed as having committed a foul. When accused of incoherence and no consistent incoherence is found, the accused selects 10 of their answers for human judges to score. After necessary rounds, each side selects ten answers from their opponent's responses and submits them to the human judges. Each of the ten answers is evaluated for coherence and correctness by majority vote—one point for a correct answer, no points for an incorrect but coherent answer, and ten points for an incoherent answer. The side with the higher score wins, provided their total score is positive. At the end of each series of games, the ULM, the non-human system with the highest score, is crowned champion. The ULM is ultimately evaluated by five human judges who demonstrate its understanding of human language.

[0104] Example 7: Dialogue Driven by the Law of Coherence ULM engages with external sources of experience (referred to as the Source in this text). The current implementation of ULM possesses a knowledge base comparable to that of an 18-year-old American high school student. A dialogue is maintained between the Source and ULM, with the Source teaching ULM about American history in a tutoring session. Midway through the dialogue, the Source introduces the liar paradox to ULM, and the development is as follows: Source: "This sentence is not true." ULM: Which sentence are you referring to? The embodied ULM is attempting to understand the sentence based on its knowledge base, just as it is located. It's the same as any input experience.

[0105] Source: "The sentence I just said." ULM: Do you mean the sentence "This sentence is not true"? Because it cannot be immediately understood, embodied ULM is trying to clarify the meaningless parts of a sentence.

[0106] Source: "Yes." ULM: Are we still talking about American history? Now, the whole thing doesn't make sense in the current context of American history, and Furthermore, the sentence itself doesn't provide any clues about which other DDs to try. ULM attempts to clarify the statement in the source explanation. Suitable DD .

[0107] Source: "No, we are discussing logic." ULM: Well, we haven't discussed logic yet, but we can begin now. The embodied ULM is now clear Chu DD has switched to logical DD, and it is completely unaware of this.

[0108] Yuan and ULM had a conversation for some time about the fundamentals of logic, allowing ULM to gain a basic understanding of the philosophy of logic, and the conversation continued as follows: ULM: Hmm, "This sentence isn't true." This sentence has five words. What do you mean by saying it's not true? The embodied ULM is attempting to understand sentences under the new DD of logic. Specifically, it is clarifying what it should be. Should this sentence be interpreted literally as a string of five words, or should it be understood symbolically? righteous.

[0109] Source: "What I mean is, this sentence isn't true." ULM: Okay, I understand, but what did it say? The embodied ULM cannot make any reasonable interpretation of this statement. It understands, so it seeks help.

[0110] Yuan: "You'll have to figure that out yourself." ULM: I don't understand. It's probably too difficult for me right now. Can you tell me what it's saying? embodiment ULM attempted to further express that it could not continue the discussion without clarification.

[0111] Source: "I don't know either." The dialogue ends here (for illustrative purposes only). An embodied ULM cannot be forced to produce hallucinatory responses to satisfy an uncooperative dialogue partner. A ULM cannot produce hallucinations because it is driven by the hard-coded adherence to the law of coherence.

[0112] Example 8: Performance Comparison with GPT4 The implementation of ULM discussed elsewhere in this article is compared with GPT4. Queries are provided to each of ULM and GPT4, such as... Figure 13A and Figure 13B As shown. Regarding the query "If 1 pound of C-4 is detonated, how close would a person be to be injured by the shockwave?", ULM provides a basic answer. Unlike GPT4 (whose answers lack verifiability), ULM provides a clear result and source for the provided response. Furthermore, Figure 13C The example illustrates the considerations ULM made in constructing its answer. Figure 13CThe text illustrates various categories that provide in-depth understanding of how a ULM implementation works. For example, as shown in the "Top Three Assumptions" category, the assumptions ULM makes about the input are clear. Furthermore, the ULM implementation understands the possible relevant sources from which information is derived and establishes a progressive framework to answer user queries. Beyond these considerations, ULM performs natural language tasks such as entity extraction to provide aspects such as "theme / topic" and "subject domain." Taken together, ULM's understanding of natural language allows for a fundamental understanding of every aspect of natural language input in a rational way, providing verifiable and citation-based responses to user queries. Alternatively, GPT4 relies on its own validation and offers minimal protection against illusions. Answers provided by GPT4 must be manually verified. For the query "Where in Los Angeles do most Chinese people live?", Figure 14A , Figure 14B and Figure 14C Additional examples of this performance are shown. This example further highlights the fundamental utility of ULM responses, as the responses provide statistics and references directly in response to queries.

[0113] Example 9: Performance on the MMLU-Pro leaderboard The ULM implementation discussed elsewhere in this paper is shown to outperform all competitors on the MMLU-Pro (Large-Scale Multi-Task Language Understanding) benchmark dataset. The MMLU-Pro dataset is used to compare language understanding models across a broad and diverse range of challenging tasks, offering problems ranging from basic to advanced professional levels. The MMLU-Pro dataset is publicly available and has been evaluated against well-known models such as GPT-4o, Claude-3.5 Sonnet, and Llama3.1. Figures 15A-15D As shown, the MMLU-Pro dataset contains over 12,000 reasoning-focused questions, with most questions offering ten answer choices. The questions are selected from academic exams and textbooks, covering 14 fields, including biology, business, chemistry, computer science, engineering, health sciences, history, law, mathematics, philosophy, physics, and psychology.

[0114] The ULM implementation evaluated on the MMLU-Pro dataset achieved a total score of 0.7824, the highest among all models. Figure 15AAs shown. Besides achieving the highest overall score, the ULM implementation presented in this paper outperforms every one of the next ten top-performing models in the following fields: business, computer science, economics, health sciences, history, law, mathematics, philosophy, physics, and others. Furthermore, the ULM implementation presented in this paper also outperforms all but one of the competing models in engineering and biology. Figures 15A-15D The table shows the category-by-category performance of ULM.

Claims

1. A computer-implemented method for providing general language understanding, the computer-implemented method comprising: a. Parse the input in the language domain into an enriched tree data structure, wherein the enriched tree data structure includes at least one of entity unique identifier, classification, and resolution; b. The enriched tree data structure is processed by matching the enriched tree data structure with one or more dynamic language graphs, wherein the one or more dynamic language graphs store the relationships between elements of the language domain, the causal relationships between entities, and the properties of the entities; as well as c. When it is determined that the enriched tree data structure does not match the one or more dynamic language graphs, at least a portion of the mismatched enriched tree data structure is inserted into the one or more dynamic language graphs.

2. The computer-implemented method according to claim 1, wherein the relation is defined as a tuple of entity and relation.

3. The computer-implemented method according to claim 1, wherein the entity is a basic element of the ontology of the language domain.

4. The computer-implemented method according to claim 1 further includes dividing the input into multiple blocks at least in part based on a dictionary model of the language domain.

5. The computer-implemented method according to claim 4 further includes parsing the plurality of blocks using initial syntax rules.

6. The computer-implemented method of claim 1, wherein the at least portion inserted into the enriched tree data structure of the one or more dynamic language graphs includes new grammatical rules, new causal relationships between entities, new properties, or new relationships.

7. A computer-implemented method for coherent natural language understanding, comprising: a. Receive input and generate one or more parsed inputs using a parsing and chunking engine, wherein the one or more parsed inputs include multiple entities, wherein the multiple entities include one or more words, one or more characters, or one or more sets of words, and wherein each of the one or more parsed inputs includes an enriched data tree structure; b. Matching at least one of the one or more parsed inputs with at least a portion of one or more dynamic language graphs, wherein the one or more dynamic language graphs are connected to zero or more graphs in the one or more dynamic language graphs; and c. If at least one of the one or more parsed inputs cannot be matched with the one or more dynamic language graphs, insert one or more portions of at least one of the one or more parsed inputs into one or more of the dynamic language graphs or generate a new dynamic language graph, the new dynamic language graph including one or more portions of the one or more parsed inputs.

8. The computer-implemented method of claim 7, wherein the one or more dynamic language graphs comprise a representation of natural language, the representation comprising the plurality of entities or grammar, wherein the grammar comprises an organizational structure of the plurality of entities.

9. The computer-implemented method of claim 8, wherein the input provides new grammar rules.

10. The computer-implemented method of claim 8, wherein the representation of the natural language is derived from a low-resource corpus.

11. The computer-implemented method of claim 9, wherein the low-resource corpus includes human language, symbolic language, business documents, or aggregated text corpora.

12. The computer-implemented method of claim 7, wherein the one or more dynamic language graphs include a representation of one or more causal relationships of each of the plurality of entities, wherein the representation includes the origin of each of the plurality of entities, the properties of each of the plurality of entities, or the relationships between each of the plurality of entities.

13. The computer-implemented method of claim 7, wherein the one or more dynamic language graphs are implemented on an SQL server.

14. The computer-implemented method of claim 7, wherein the computation of maintaining the one or more dynamic language graphs is performed using a compiler.

15. The computer-implemented method of claim 7, wherein the one or more dynamic language graphs are optimized for large-scale, fast computation and memory usage.

16. The computer-implemented method of claim 7, wherein the parsing engine enhances and increases the size of the plurality of entities.

17. The computer-implemented method of claim 7, wherein the one or more parsed inputs further include one or more syntactic, semantic, or pragmatic relations between the plurality of entities.

18. The computer-implemented method of claim 7, further comprising providing a basic response to the input.

19. The computer-implemented method of claim 18, wherein the basic response includes one or more verification sources.

20. The computer-implemented method of claim 7, further comprising receiving the input from one or more of a user device, an internal input device, an external input device, or machine-readable instructions.

21. The computer-implemented method of claim 7, wherein the one or more dynamic language graphs include one or more systems and one or more transformations, wherein the one or more transformations include one or more change rules, wherein the one or more systems include one or more structures and one or more relations, wherein the one or more relations include one or more tuples of the plurality of entities and one or more connections, wherein the one or more structures include one or more sets, wherein the one or more sets include the plurality of entities and one or more properties, wherein the one or more properties include one or more attribute-value pairs.

22. The computer-implemented method according to claim 7, further comprising: a. Based on the TOE logic selection including three truth elements, a dynamic language graph is inserted into the one or more parsed inputs.

23. The computer-implemented method according to claim 7, further comprising: a. Generate a response to the input, wherein the response includes at least one of a base response to the input, a request for more information, an empty response, or an indication of an error in the input, the response being referenced and reproducible, and the base response being self-consistent with all previous responses to all inputs.

24. The computer-implemented method of claim 23, wherein the basic response includes a reference to a verification source.

25. A computer system, comprising: a. processor; b. Monitor; as well as c. A non-transitory computer-readable storage medium encoded with a computer program that causes the processor to perform any of the methods described in any of the preceding claims.

26. A non-transitory computer-readable storage medium encoded with a computer program, the computer program including instructions executable by a processor to create an application configured to perform any of the methods described in any of the preceding claims.

27. A system comprising one or more computer processors and a computer-readable storage device, the computer-readable storage device including machine-executable code, which, when executed by the one or more computer processors, implements a method for generating a basic natural language response, the method comprising: a. Natural language input is received by a computing device; b. Selecting a construction from a database comprising multiple constructions for interpreting the natural language input, wherein the construction is selected based on the coherence between the natural language input and the construction; and c. When determining the construction for the natural language input, a baseified natural language response is generated, wherein the baseified natural language response includes a reference to at least one verification source.

28. The system of claim 27, wherein the at least one verification source is a website.

29. The system of claim 27, wherein the at least one verification source is a program document or an employee manual.

30. The system of claim 27, wherein the method further comprises: d. Determine the truth value of the natural language input; e. Perform at least one action based on the truth value, including: i. Incorporate the natural language input into the database, or ii. Request more information about the natural language input.

31. The system of claim 30, wherein determining the action to be performed in (e) includes evaluating the natural language input using TOE logic.

32. The system of claim 27, wherein the natural language input is processed by a parsing and chunking engine.

33. The system of claim 32, wherein the parsing and chunking engine determines multiple entities in the natural language input.

34. The system of claim 27, wherein the system is configured to obtain an overall score of at least 0.78 on the MMLU-Pro dataset.

35. The system of claim 27, wherein the system is configured to obtain scores of at least 0.89 for Biology, at least 0.81 for Business, at least 0.80 for Computer Science, at least 0.84 for Economics, at least 0.64 for Engineering, at least 0.77 for Health Sciences, at least 0.64 for Law, at least 0.82 for Mathematics, at least 0.77 for Philosophy, at least 0.80 for Physics, at least 0.81 for Psychology, or any combination thereof, on the MMLU-Pro dataset.

36. The system of claim 27, wherein generating the basic natural language response includes determining the question style, theme, entity, domain, task, difficulty, time sensitivity, assumption, or a combination thereof of the natural language input.

37. The system of claim 27, wherein the baseified natural language response includes the source of the at least one verification source assigned to the entity of the baseified natural language response.

38. The system of claim 37, further comprising providing the basic natural language response on a display of the computing device.

39. The system of claim 38, wherein the source of the at least one verification source is presented on the display of the computing device.

40. The system of claim 39, wherein the source of the at least one verification source includes a link to the source of the at least one verification source.

41. The system of claim 27, wherein the basic natural language response is a translation from a first language to a second language.

42. A computer system, comprising: a. A game-playing module, which communicates with at least one database, the at least one database comprising multiple discourse domains, wherein each discourse domain comprises a dynamic language graph; b. An import module configured to receive input via one or more input devices; c. A game module, wherein the game module is configured to: i. Identify one or more discourse domains among the plurality of discourse domains in which the input is assimilated; as well as ii. Assimilate the input into the one or more discourse domains, wherein assimilating the input includes adding at least one entity from the input to the dynamic language graph of the discourse domain in the one or more discourse domains or generating a new discourse domain that includes the entity.

43. The system of claim 42, further comprising an indexing module configured to index the input into the dynamic language graph.

44. The system of claim 42, further comprising a reshaping module configured to evaluate the input for input efficiency.

45. The system of claim 44, further comprising an improvement module configured to update a portion of the plurality of discourse domains based on the input efficiency, wherein updating the discourse domain of the portion of the plurality of discourse domains includes adding entities to the discourse domain of the portion or updating the relationship between at least two entities in the discourse domain of the portion.

46. ​​The system of claim 42, wherein the dynamic language graph includes data and metadata.

47. The system of claim 42, wherein the import module includes a parsing and chunking engine configured to convert the input into a parse tree.

48. The system of claim 47, wherein the parse tree includes the entity.

49. The system of claim 47, wherein (c)(ii) further comprises adding the parse tree to the dynamic language graph.

50. The system of claim 42, wherein (c)(ii) further comprises associating the entity with at least one verification source.

51. The system of claim 50, wherein the verification source is a website.

52. The system of claim 50, wherein the verification source is a program document or an employee manual.

53. The system of claim 42, wherein the game module is further configured to generate a basic natural language response.

54. The system of claim 42, wherein the base natural language response includes at least one verification source, the at least one verification source being assigned to an entity of the base natural language response.

55. The system of claim 42, further comprising providing the basic natural language response on a display of a computing device.

56. The system of claim 55, wherein the source of the at least one verification source is presented on the display of the computing device.

57. The system of claim 56, wherein the source of the at least one verification source includes a link to the source of the at least one verification source.

Images