BUILDING SOLUTIONS USING Natural LANGUAGE PROCESSING

Abstract

The invention relates to the technical field of information. More specifically, the present disclosure relates to computer-implemented methods, systems, and computer-readable media for designing and deploying solutions.

Description

[0001] This complete specification is accompanied by Indian patent applications which are counterparts of Indian application numbers 202241027734, 202241038565, 202241043310 and 202241051441, each of which is accompanied by a corresponding provisional specification. Technical Field

[0002] The present disclosure relates to the field of information technology. More specifically, the present disclosure relates to a computer-implemented method, system, and computer-readable medium for designing and deploying solutions. background

[0003] Software engineering, design, and architecture practices have changed and evolved significantly over the past sixty years. For simplicity, the many levels of abstraction at which operational logic is communicated to a computer can be divided into two groups: (1) high-level application logic, as conveyed through programming languages, and (2) the operating system and below, which more directly mediate or manipulate the computer and its operations.

[0004] There are three major popular operating systems: Microsoft Windows, Apple Mac OS X, and Linux. However, there are hundreds of programming languages. All programming languages ​​are broadly driven by codes (symbols with specific meanings and functions described from natural languages ​​and arithmetic). It takes software experts and engineers from weeks to months to master a programming language and participate in creating or maintaining a solution. Therefore, users may not be able to create or modify a solution without the intervention of a technical expert.

[0005] Over the years, the computing and communication capabilities of information technology have increased exponentially. Software design and management techniques have improved with the move toward component-based design, service-oriented architecture, web services, business process management, and agile project management methodologies. However, at the same time, the technological landscape has become more complex as the number of moving parts has proliferated. Ordinary users remain distant from computing technology and solution design as well as from the implementation of changes to solutions. This over-dependence of users on technical experts and intermediaries is due to the fact that programming languages ​​are different from natural languages. Technical systems have not yet realized the opportunity to be as creative and innovative as programming languages ​​are as powerful as natural languages.

[0006] Natural Solution Language (NSL) has a transformative effect by eliminating the need to communicate solution or application logic to computers through programming code. NSL allows users to communicate solution logic directly to computers, just as they communicate user needs to technical experts using natural language structures similar to natural language.

[0007] NSL relies on a layer of "technical framework" called NSL-TF, which sits on top of operating systems and operates as if it were an integral part of those operating systems. NSL is driven by a simple but powerful approach called the "differentiation principle", through which traditional functions and processes are transformed into information. NSL is fundamentally influenced by the fact that all solution logic is about entities and their relationships.

[0008] NSL democratizes solution design, maintenance, and related operations by empowering users and bringing all relevant entities to the user interface level.

[0009] The features, terminology, concepts and applications of NSL are described in more detail in Indian Patent Application No. 201941028675 with corresponding PCT Application No. PCT / SG2020 / 050004. The description of Indian Patent Application No. 201941028675 is incorporated herein by reference. Overview

[0010] This disclosure is about additional features and concepts integrated with the NSL Technical Framework (NSL-TF), which establishes the equivalence principle of NSL with any established existing solution framework in use. By quantifying solutions in binary entities (BETs) and allowing BETs to exist in multiple substrates, NSL allows substrate crossing and substrate tagging, which can have a powerful impact on building efficient solutions that existing systems lack.

[0011] NSL aims to eliminate the information asymmetry and functional asymmetry between human and machine agents. Analytical and reasoning engines help unlock the true potential of machines by replicating human behavior, or in some cases, surpassing human intelligence through their ability to process large amounts of data, make quick decisions, and take actions without the help of human intervention. BRIEF DESCRIPTION OF THE DRAWINGS

[0012] The features, aspects and advantages of the present disclosure will be better understood when the following detailed description is read with reference to the accompanying drawings.

[0013] Figure 1 An example showing BET.

[0014] Figure 2 Represents an example of tightly coupled entities.

[0015] Figure 3 Represents an example of loosely coupled entities.

[0016] Figure 4 An example of a change unit representing a connection.

[0017] Figure 5 An example representing a related unit of change.

[0018] Figure 6 An example indicating minimum membership standards.

[0019] Figure 7 An example representing the principle of the physical continuum.

[0020] Figure 8 An example representing the dynamic switching between potentiality and reality.

[0021] Fig. 9 Represents an example of an analysis engine.

[0022] Fig.10 Represents an example of an inference engine.

[0023] Fig.11 An example representing the NSL-Technology Framework architecture.

[0024] FIG. 12( a ) and FIG. 12( b ) show examples of perspective switching (Vantage Point Switching).

[0025] Fig.13 An example showing functional distance.

[0026] Fig.14 An example representing a negative entity.

[0027] Fig.15 An example representing Bayesian logic.

[0028] Fig.16 An example representing mutability.

[0029] Fig.17 An example showing the relevant principle.

[0030] Fig.18 Represents an example of regression analysis.

[0031] Fig.19 Shows an example of residual information in NSL.

[0032] Fig. 20 Examples of information rights and decision-making powers.

[0033] Fig.21 An example showing the distribution and delegation of information rights and decision-making authority.

[0034] Fig. 22An example of delivering a product to a customer within or beyond a specified time frame.

[0035] Fig.23 An example of a four-layer CU is shown.

[0036] Fig.24 Represents a CU of the local network as a node.

[0037] Fig.25 Indicates interrogative sentences that help convert descriptive sentences into prescriptive sentences in a binary state.

[0038] Fig.26 Indicates interrogative sentences that help convert descriptive sentences into prescriptive sentences with multiple options.

[0039] Fig. 27 An example of expected and empty events representing the use of the pen and paper entities.

[0040] Fig.28 Represents an instance of a class within a class.

[0041] Fig.29 Shows examples of five identified substrates in the substrate library.

[0042] Fig.30 An example showing that a GSI of a lower-level CU triggers a higher-level CU.

[0043] Fig.31 An example showing that a nested CU applies greater contextuality to contextuality present at a higher level CU.

[0044] Fig.32 An example showing the shade of potentiality in the combination of two binary solid models.

[0045] Fig.33 Examples of representations that carry different amounts of information regardless of the basis.

[0046] Fig.34 Represents an example of parallel CUs.

[0047] Fig.35 A generalized computer network arrangement representing an NSL.

[0048] Fig.36 Represents multiple layers of CU in NSL.

[0049] Fig.37 An exemplary method for building a computer-implemented solution using natural language understood by a user and without using programming code is shown. Detailed Description

[0050] Although systems, devices or apparatuses, and methods are described herein by way of examples and embodiments, those skilled in the art recognize that the systems and methods for providing solutions are not limited to the described embodiments or drawings.

[0051] It should be understood that the drawings and descriptions are not intended to be limited to the particular forms disclosed. On the contrary, it is intended to cover all modifications, equivalents, and alternatives that fall within the spirit and scope of the appended claims. Any headings used herein are for organizational purposes only and are not meant to limit the scope of the specification or claims. As used herein, the word "may" is used in a permissive sense (e.g., meaning it is possible), rather than in a mandatory sense (e.g., meaning it must). Similarly, the words "include", "including", and "includes" mean including but not limited to.

[0052] The following description is a complete and informative description of the best methods and systems, devices or apparatuses currently contemplated for carrying out the present disclosure, which methods and systems, devices or apparatuses were known to the inventors at the time of filing the patent application. Of course, many modifications and adjustments will be apparent to those skilled in the relevant art in view of the following description, drawings and appended claims. Although the systems, devices or apparatuses and methods described herein are provided with a certain degree of specificity, the technology may be implemented with greater or less specificity depending on the needs of the user. In addition, some features of the technology may be advantageously used without the corresponding use of other features described in the following paragraphs. Therefore, since the technology is limited only by the claims, this description should be regarded as merely illustrative of the principles of the technology, rather than a limitation thereof.

[0053] First, for the purposes of the following discussion and the appended claims, the definition of the term "or" is intended to be an inclusive "or", that is, the term "or" is not intended to distinguish between two mutually exclusive alternatives. On the contrary, the term "or" when used as a conjunction between two elements is defined to include one element by itself, the other element by itself, and combinations and arrangements of elements. For example, a discussion or narrative using the terms "A" or "B" includes: "A" by itself, "B" by itself, and any combination thereof, such as "AB" and / or "BA". It is worth noting that this discussion relates to exemplary embodiments, and the appended claims should not be limited to the embodiments discussed herein.

[0054] For the purposes described herein, a processor may be implemented as a microprocessor, a microcomputer, a microcontroller, a digital signal processor, a central processing unit, a state machine, a logic circuit, and / or any device that manipulates signals based on operational instructions. Among other capabilities, a processor may fetch and execute computer-readable instructions stored in a non-transitory computer-readable storage medium coupled to the processor. The non-transitory computer-readable storage medium may include, for example, volatile memory (e.g., RAM) and / or non-volatile memory (e.g., EPROM, flash memory, NVRAM, memristor, etc.).

[0055] For the purposes of this description, a memory may be a memory of a computing device and may include any non-transitory computer-readable storage medium including, for example, volatile memory (e.g., RAM) and / or non-volatile memory (e.g., EPROM, flash memory, NVRAM, memristor, etc.).

[0056] For the purposes described herein, modules include, among other things, routines, programs, objects, components, data structures, etc. that perform specific tasks or implement specific data types. The modules also include modules that supplement applications on a computing device, such as modules of an operating system. An operating system includes at least one of a batch operating system, a time-sharing operating system, a distributed operating system, a network operating system, and a real-time operating system.

[0057] Each of the terms listed below has a specific role and application to the computer-implemented NSL methodology. The role of each of these individual techniques and methodological elements in relation to NSL is explained.

[0058] It is claimed that Natural Solution Language (NSL) will replace programming languages ​​by communicating with machines in a natural language-like manner. In order for Natural Solution Language (NSL) to produce a transformative technological effect, a computer-implemented approach needs to be applied. This approach requires a sensitive approach to entities and their relationships as required by the situation. There are different variations of entities and their relationships, and each of these variations must be defined and handled correctly.

[0059] NSL's core dogma: All solutions are about entities and their relations in the context of agent intentionality. All solutions are about getting from one desired state to another more desired state. Most solutions arrive at a desired state via a chain of connected solution states.

[0060] Solution Ecosystem: The solution designer selects and uses potential entities from the “real world” to establish relationships between them. The relationships between the potential entities are such that they combine and interact in such a way that the solution can be achieved along the defined change path.

[0061] Way World Works (WWW) Principles: NSL is more than just traditional techniques, it blends scientific and technological understanding to create a new paradigm in solution architecture. WWW are the principles that guide the way the universe or nature works as understood and recognized by science today. NSL logic leverages all the scientific insights about the way the world works and brings certain innovative approaches to the solutions that human agents seek through the use of computers. For example, all things are made up of particles. When particles combine, they create emergent properties that occur in space and time. All of these events are driven by energy and follow the Way World Works principles. These, in turn, affect the behavior of agents and how they cause movement from one desired state to another through directed changes.

[0062] Entity: Anything that is unique is an entity. That is, anything that has an independent existence and can be represented by information is an entity. In language, entities are represented by words, symbols, or numbers. For example, a grain of sand qualifies as an entity, just as a car qualifies as an entity.

[0063] Differentiated Entity: Anything that is unique and at the same time distinct from other entities is a differentiated entity. That is, it is different compared to some other entity. In natural language, these are represented by words. For example: "Pen" is different from "paper".

[0064] Undifferentiated Entities: Anything that is unique and at the same time identical to one or more other entities is considered undifferentiated from that other entity or entities. Such “recurrences” occur in space and time. These recurrences belong to the realm of mathematics and are represented by numbers. From a solution design perspective, an entity is considered recurring in space or time if it can be effectively replaced by some other entity without affecting the outcome. For example, if there is a pen and a piece of paper on a table, one can say, “There is a pen and a piece of paper on the table.” However, if there is a pen and “another pen” on the table, one can say, “There are two pens on the table.”

[0065] Potential vs. non-potential entities: Solution design involves entities and their relationships. These entities are selected from the real world in the context of solution design. Those entities that are selected for their potentiality with respect to the solution are declared as “potential entities”. Those that are not included in the solution-related “potentiality set” are excluded and have no relevance from the solution ecosystem perspective.

[0066] Independent entities: These are entities at the level where binary events occur - that is, a switch between potentiality and actuality occurs, causing a change in the state of the composite entity in which they participate. For example, a pen can move into existence or disappear from existence. When an independent entity event occurs, it may change the state of the composite ecosystem of which it is a part. If it exists as a potential entity with the paper, they can produce together , that is, 4 potential combination states.

[0067] Implied Entities: Many times entities connected to other entities are implied and ignored. For example, if a person walks into a street, it is implied that he is there in relation to the clothes he is wearing. Here the clothes are implied. Similarly, it is implied that there is air for the human agent to breathe. In case of room booking, the existence of an “agent” for inputting information can be implied. Such implied entities are taken as given by the designer of the solution. Even the attributes are implied most of the time. All changes occur within “Units of Change” (SI). Changes occur only when physical interactions occur in space and time. If the space and time of an independent entity are known, then the space and time properties of another entity can be implied. Even in other cases, it may even be the case that for the solution designer, not specifying these properties may not change the essence of the design making.

[0068] Shared Entity: A shared entity is an entity that exists in common across many local or global intent statements. For a given intent statement, there are many independent entities that are part of the triggered state. When an intent statement is in the triggered state, the entity will not be available to participate in any other intent statement during the elapsed time associated with the trigger. But once the triggered change is completed, the participating entity becomes a shared entity across all related intent statements again.

[0069] Informational entities: Informational entities are entities created by human agents for the purpose of communicating representational entities they own to other agents in the ecosystem.

[0070] Attributes: An attribute is also an entity, but its existence depends on some other entity. Such dependent entities are explicitly called attributes. Dependency is defined as the existence of one entity due to the existence of another independent entity. For example, a pen can exist in space and time. Here, space and time are considered attributes or dependent entities. Note that "units of space" or "units of time" qualify as entities. Since they depend on higher-level entities, NSL calls them attributes. When the pen is deleted, the attributes are automatically deleted. Entities contain a lot of implicit information. Some implicit information is identified but ignored because it may not be core to the solution. For example, a person may care whether someone is well dressed. But a person may not care about the color of the shirt. Sometimes the implicit information may be unknown or inaccessible. For example, a person may not know how many cells there are in a person's body, or for that matter, most people may not know that the body has an organ called "spleen". Attributes are formed by surfacing this implicit and associated information related to entities as required by the context.

[0071] Attribute Levels: There is no limit to the number of levels an attribute can exist at. The first level is called the "primary attribute", the second level is called the "secondary attribute", the third level is called the "tertiary attribute", and so on. For example, if at the first level, the space is defined as India, each state will exist at the second level and each city will exist at the third level.

[0072] Natural Property Values: Any information that is attached as a property value in the solution belongs to this category. So spatial coordinates and time naturally belong to this category since they are standard intrinsic properties. All property values ​​extracted from any entity like its weight, volume, color, etc. should also belong to this category.

[0073] Derived attribute values: As the name implies, all derived attribute values ​​should belong to this category. All values ​​that are derived by applying different kinds of established statistical techniques should belong to this category, for example, probability, correlation (e.g. Fig.17 ), variability, means, ratios, various measurements, regression analysis (e.g. Fig.18 These values ​​can be exported in real time or via batch mode, as appropriate. NSL provides these options to give the solution designer or user the flexibility to specify what they are looking for.

[0074] Change Drivers: The entities and their attributes that cause changes in a change unit are called change drivers. Attributes are also entities, but they depend on independent entities. There can be any number of attribute layers that even further differentiate independent entities. Each change driver has slots, and each slot is connected to a transformational pathway. Each slot is called a change component. Each driver has its own unique and distinct identity and intrinsic information.

[0075] Variation Unit (CU): From a natural language perspective, a Variation Unit is a unit described by a Statement of Intent (SI). Values ​​of any type can only occur through controlled variations, and only within a Variation Unit. It is by weaving together local Variation Units (by combining sentences to create paragraphs) that the global Variation Unit that a human agent expects or wants is obtained. For simplicity, NSL treats these Variation Units as synonyms of SI. Therefore, CU and SI are used interchangeably in this document. A local Statement of Intent is a local "Unit of Variation" expressed in natural language as a Statement of Intent (a sentence). A global Statement of Intent is a "global Unit of Variation" expressed in natural language as a global Statement of Intent (a paragraph).

[0076] Agents: Agents are entities too. Agents are both creators and consumers of solutions. Agents are distinguished from "nature" because they are driven by "purpose". In other words, agents seek favorable changes and avoid unfavorable changes. Since every solution deals with controlled change, it is assumed that all units of change are affected by an agent, whether a human agent or a machine agent. Since all changes require energy, agents use their inherent energy or borrow energy from one or more combined entities and provide directionality to the change by following a predetermined path or by applying free will.

[0077] Human Agents: Also known as “stakeholders,” human agents play a variety of roles depending on the requirements imposed on them by the solution environment. Some units of change are driven by human agents out of necessity. For example, the physical delivery of some “hard assets” will require human agent involvement.

[0078] Agent Functionality: The agent functionality that occurs in an intent statement can be divided into three layers of the intent statement: i) Physical Functionality: Physical functionality is related to the participation of independent entities, resulting in a composite entity state (CES) that forms the backbone of the intent statement. The primary function of physical functionality is to facilitate solutions, while the other two categories directly or indirectly support physical functionality. ii) Information Functionality: Information functionality involves entities connected to the composite entity state and serves only the function of providing information, but does not involve physical functionality. By extension, these information functions are connected to the intent statement and the agents that drive them. Information functionality makes the agent fully informed and plays a role in dynamic solution redesign and other value-added functions such as analytics, machine learning, and artificial intelligence. iii) Mind Functionality: From the perspective of computer-implemented NSL, mind functionality simulates the functionality of the human mind in the real world. These functions "anticipate" entity states and guide physical functionality in the process of achieving the desired transformation. Anticipation applies to "temporal aspects" related to the future. But anticipation can apply to all situations where there is uncertainty. In theory, uncertainty can also be related to things in the past or present. For example, a person may not know completely, but can try to predict what happened yesterday or what is happening in another room right now. Revisions of "estimates" or "expectations" may occur in each instance of an event. If such expectations have an impact on the current physical function, these will be fed back into the physical function as an entity of the impact. In addition to playing similar roles such as information functions, mental functions also help to plan ahead and optimize functions.

[0079] Information Rights: These are the rights of human agents to obtain information about specific individual or combined entities and statements of intent related thereto.

[0080] Decision Rights: These are the rights of human agents to change the potential or actual states of individual or combined entities and the intentional statements associated with them.

[0081] Machine Agents: These are synonyms for "computers" where the units of variation are driven by machine agents, designed by human agents or other machine agents to generate appropriate outputs in response to inputs. Machine agents essentially mimic human agents in their ability to consume inputs, cause controlled variation between inputs (process those inputs), and generate outputs. Human agents impart purpose-driven qualities to machine agents.

[0082] Events: All events arrive at one local intention statement or another. All events are about individual entities moving from one state to another, from potential to actual, and vice versa. Events occur by way of individual entities arriving at or leaving the LSI, resulting in a change in the state of the composite set as a whole. If there are 6 mutable entities in the LSI, there are 64 different possible states of the composite entity. A change in binary state at the individual entity level can result in any of the 64 different states in the LSI. While 63 other states may be in non-triggering composite entity states, the 64th state will be in a triggering state that affects other LSI states or itself.

[0083] Combined Entity States (CES): Combined states result when independent entities (dragging their properties with them) are combined with other independent entities, and these combined states are differentiated and have their own emergent properties. CESs are contained in Local Statements of Intent (LSIs), each representing a unit of variation, equivalent to a sentence. A collection of such LSIs that result in a larger desired variation is called a Global Statement of Intent (GSI), equivalent to a paragraph. The size of a CES in an LSI is proportional to the number of participating independent entities. Each LSI will contain states, where “n” is the number of independent entities, since each independent entity can exist in either the “potential” or the “actual” state. Basically, there are two kinds of combined entity states in each local intention statement: i) Non-triggering CES: These are combinations of entities that do not cause a change in the combined entity state in other local intention statements or within the same LSI to which they belong. For example, if there are four independent entities, as binary variables, they will produce entity states, i.e. 16 CESs. Of these states, 15 states are non-triggering CESs as they do not trigger any changes. (ii) Triggering CESs: These combined entity states trigger changes in one or more other LSIs or within the same LSI. Triggering CESs are CESs in which all independent entities and their attributes are present in the actual state. When a CES in one LSI affects CESs in other LSIs, the sentences are connected. LSIs are grouped together according to their degree of participation in the implementation of the GSI to form a paragraph. Based on the previous example, the 16th state is a triggering state because all four independent entities are present in the actual state in this state.

[0084] Binary states: In NSL solution design, all entity states are represented as existing in binary states only. That is, they either exist in a potential state or in an actual state. Each state is discrete, with no in-between state. Each word operates in a binary state, and even sentences and paragraphs exist in a binary state. Agents simply keep changing the perspective from which they view entities. When one zooms in or out, the perspective changes. But each perspective is in a binary state. The choice of binary states in NSL solution design is a choice of discrete states versus continuous states, similar to the choice of digital versus analog. When events occur, there is a state transition of the excluded middle. In theory, these binary states can also be represented by assigning values ​​of "true or false".

[0085] Natural Solution Language (NSL): This is a slightly modified version of Natural Language and is a computer-implemented approach where things are recast in a form that captures only the intention statement and makes all descriptive statements subordinate to the intention statement. These intention statements exist in two states: i) Static Intent Statements: These just express the intention but lack the ability to transform it into reality. Static entity states are those entity states that do not have properties that can trigger changes in other states. If there are 6 variables (independent entities and their properties) in a system, they may exist in 64 different states. But only the 64th state is capable of triggering a change when all variables exist in the "real" state. All other entity states are called "static entity" states. One thing to note in this regard is that the Intent Statement (SI) is just another independent entity that describes the nature of the desired change and participates in the "change unit". The existence of SI is based on the fact that any subsequent action must be supported by the agent's intention. ii) Dynamic Intent Statements: These are the underlying transformation-causing entities behind the Intent Statement, which are collectively triggered when a certain desired state is reached. This state is called Trigger Combinatorial Entity State and is affected by events at the independent entity level. Dynamic entity states are those that can cause one or more entity states (including themselves) to change further. In the previous example, state 64 is a "dynamic entity" state. In other words, in order for a static intent statement to become dynamic and realize the intent statement, it needs to be powered by a triggering CES.

[0086] User Interface (UI): Entities can exist at different levels of abstraction, either at the database or user interface level. At the user interface level, human agents exercise their "information rights" or "decision rights". UI plays a very important role in NSL because the "user" oversees the creation or use of the solution. Everything happens over the hood rather than under the hood. NSL drives the behavior of entities at the UI level by making UI "intrinsic properties". These properties specify how the entity should appear at the UI level, what its address is (on which screen and where on the screen), whether it is sensitive to navigation or information input, and so on.

[0087] NSL Technology Framework: One innovative technical effect brought by NSL is the combination of unique methods and technology framework. NSL is built on a standardized technology framework to meet a wide range of application needs, where "users" are the main drivers of the solution. The technology framework encapsulates all the innovative methods described in this document and sits on top of the operating system to cater to any type of application logic to be conveyed to the computer. Users remain agnostic to this underlying technology framework and have the power to use NSL in a natural language-like manner. In summary, the NSL technology framework is a lightweight additional layer on top of the existing operating system that gives life to the principles and methods behind NSL based on the principle of differentiation. In addition, it also helps to automate most of the functions that were originally human agents. But for enhancements from time to time, the NSL technology framework will remain unchanged. Just like an operating system, it does not use any code, but conveys the NSL logic to the computer through natural language constructs.

[0088] Technical Translation Framework (TTF): One of the most important things that NSL has is the ability to convert any programming code into a natural language-like NSL format, based on the same principles of handling controlled differentiation using the NSL method and the NSL Technical Framework (NSL-TF), so that the logic emerges for direct use and impact to the user or stakeholder. TTF is built on a matrix-based / tile-based approach that encapsulates the keywords, operators, symbols, and functions of each programming language and their representation in NSL. TTF analyzes the construction of the code, identifies the programming language in which the code is written, and uses the matrix to pick up the matching NSL equivalents for each keyword, operator, symbol, function, or a combination thereof.

[0089] Technology Re-Translation Framework (TRF): The innovative framework that NSL brings is the ability to convert any solution built with NSL into any programming language. TRF is based on the same matrix-based approach that TTF is based on. TRF understands NSL constructs and identifies matching keywords and functions in programming languages, thereby constructing code in any programming language of the user's choice.

[0090] a. 360° Any to Any Translation (A2A): TRF along with TTF completes the full lifecycle of a mechanism called 360° Any to Any (“A2A”) using which a solution in any programming language or any natural language can be translated into any other programming language or natural language. Just like the meaning is constant and can be expressed across various natural languages, the solution logic can be expressed in any programming or natural language substrate. In NSL, the solution is a special class of information called prescriptive information. Prescriptive information expressed in a potential state becomes actual when acted upon, and this prescriptive is done at the class level, and actualization occurs at the transaction level when their members arrive. Any member that arrives at the defined class will act in the same way as that class. These are replacing the traditional processes. The events that arrive are selected from the potential text, and when this happens, the whole thing becomes expressible in a natural language format. In other words, NSL follows a certain differentiation cycle where differentiation is expressed appropriately and contextually, and this differentiation according to NSL is expressible in any substrate. NSL, through TTF and TRF, can extract the solution logic embedded in each substrate and process them in the same way as they were processed in the original substrate. This A2A has been tested and the principle is that in each solution built in various programming or natural languages, the input is the same and the output is the same. In short, NSL constructs act as a hub and other programming languages ​​are like spokes. For example, if a programming language must be translated into another programming language, these programming languages ​​must hit the hub called NSL and then branch out as another programming language.

[0091] Stakeholder Engagement Center (SEC): This is a synonym for the user interface. SEC identifies all entities that are potentially relevant with respect to any agent and presents them on the user interface level in a structured manner. NSL identifies the relevant entities, as all change units are driven by one or another agent, clearly establishing ownership. Moreover, the added fact that all entities have clearly defined decision rights and information rights makes the distribution and navigation of entities across agents easy. SEC provides stakeholders with highly customized interfaces that are context-driven. It provides a distributed and secure environment for each stakeholder. It adapts itself to the user in a personalized way.

[0092] Mission Control Center (MCC): MCC brings together those entities that are significant in the regular process of human agents performing their duties or meeting their needs. These significant entities are gathered from those entities that are relevant to the agent (that is, they have information rights or decision rights). Distributed MCC is about the ability of the system to first automatically identify the entities that belong to a specific agent or agents; and then pick up the entities that are significant for the agent's functioning. MCC takes the context of SEC to another level. It adapts itself to the "time" or "event" based on the context. It highlights all the relevant "BETs" that better drive the relevant SSA loop. Among other things, information or actionable measures are also available in the context.

[0093] Every thing is a binary entity (BET): In NSL, all unique and discrete things are called entities. These entities are either unique (differentiated unique entities) or identical (undifferentiated unique entities). Unique entities are represented by words and identical entities are represented by numbers. The term binary entity (BET) means that all discrete entities are in a potential or actual state. Since the word "BIT" (binary number) usually exists in the context of information, "BET" is a subset of "BIT" that exists in the context of solutions. Each BET is in a differentiated state because of the large number of BITs of information it carries and freezes. Events arrive only at the BIT level. Since all bits are frozen, they lose the ability to be loosely coupled. For example, a pen is composed of many atoms. When the pen is frozen, one cannot pull out an atom and call it "the pen excluding that atom".

[0094] BETs in all perspectives: A solution can be decomposed into its constituent parts. When it is decomposed, one can traverse various perspectives, at chapter level, paragraph level, extended composite entity state level, variation unit level, entity level, and attribute level. From the perspective of NSL, an important thing to remember is to treat anything unique as a BET. BET status is given to attributes, general entities, agents and their combinations, variation units, sets of variation units, solution ecosystems, and all higher level sets of BETs. In each perspective, NSL treats each BET as a binary variable. The solution ecosystem is built in such a way that potentials and their memberships are laid out to enable events to find their way and label themselves to their members. BETs exist in different substrates and each representation of a BET in each substrate will have a unique identity. Example: (a) An image or video representing an entity will have its identity. Each representation can consume its own quantum of BITs in the form of BETs. (b) An end-to-end telecom billing solution is a BET. The units of change that make up this telecom solution, such as Customer Profiling, Address Validation, Bill Generation, etc., are also BETs, and this continues until the last attribute attached to each entity.

[0095] BIT and BET: "BET" (binary entity) is to solutions just like BIT (binary digit) is to information. By extension, BET is to "solution theory" just like BIT is to information theory. Usually, information is measured by the number of "BITs". It essentially means that each bit is in a binary state of "0" or "1". Information only appears when the position of each bit is determined, or differentiated in some sense. To calculate the size of information, the state of each bit is ignored and only the number of bits contained in the information is counted. Similarly, in the solution ecosystem, the number of "BETs" can be calculated by ignoring the state of each BET. "BIT" and "BET" are highly related concepts that are differentiated only by context, one is generally related to information and the other is generally related to solutions. "BET" is like a "primordial entity" without any distinction. "BET" in Figure 1. When each entity reaches this state, all entities become identical and countable. For example, a one GB video will ignore the state of BIT. What matters is the number of bits that make up the video. Similarly, in NSL, the quantification of a solution is done by counting the number of BETs that make up the solution. BET represents the unit of value and is the core of the agent system, which transforms all the continuity of changes into controlled and directed discrete states, just like the picture frames in a video. All BETs in the ecosystem system are quantifiable, and all BETs in the ecosystem system are connected to each other based on the nearest neighbor principle. All BET events are driven by qualified agents, and the internals of any BET type are exactly the same, while providing any allowed type in the context. BET accommodates triggering attributes CES and non-triggering attributes CES. BETs entertain events at the level of individuals and tightly coupled entities. Multiple verticals belong to embedded BETs or nested BETs. Multiple horizontals are labeled as hierarchies based on evolutionary taxonomy, where the hierarchy arises from a three-dimensional networked node structure that serves as the basis for paths of generalization and differentiation, which is laid out in the context of the directionality of the path, and the direction in which the goal is heading defines the differentiation direction. When the direction is reversed according to the context, the generalization end becomes the differentiation end. The node structure adopts a hierarchical structure based on the defined path.

[0096] Tightly coupled entities: Agents and general entities are combined together according to the context to produce the expected change. Generally, a combination of entities can arrive or leave together. Tightly coupled entities are those that act together. Example of tightly coupled entities: Truck and driver arrive and leave together. Tightly coupled entities cannot act independently. In any change, when tightly coupled entities participate, they must participate together. In no case can one of them be missing from the action. An instance of multiple entities participating in a change together is called tightly coupled entities. For example, while performing a surgery, the doctor wears designated surgical gowns, gloves, masks, etc. Figure 2 An example of tightly coupled entities is represented in .

[0097] Loosely coupled entities: Loosely coupled entities are single entities that are reached separately to participate in a change. Examples of loosely coupled entities: Pen and paper can reach the change unit separately. They are loosely coupled entities; they can be reached independently. Examples of loosely coupled entities are in Figure 3 Indicated in.

[0098] Substitution of entities: Substitution of entities can occur at (a) independent entity level, (b) attribute level, (c) CU level. The term “substitution” is used only in cases where the subsequent state will generate the same set of events. If the transition path is different, then it cannot be called a substitution entity. When substitution occurs, the nearest neighbors should not notice the difference. The effect of the triggering state should remain the same. For example, a pencil can act as a substitute for a pen in the context of writing. The system operates dynamically and the recipient will not even notice which entity participated in the change, whether that entity is the original or the substitution entity.

[0099] Cloned Entities: As a part of the solution, sometimes it is necessary to copy soft assets without differentiating them from each other. Such identical non-differentiated soft assets are called cloned entities. For example, the policies of an organization have to be communicated to all employees through emails and each copy of the email is identical and non-differentiated. NSL system provides entity cloning as a part of the solution design. In cloned entities, it will not be possible to determine which is the original entity and which is the cloned entity.

[0100] Negative Entity: Normally, the important change driver (CD) is the part that triggers the CES. But in some rare cases, it may be the absence of an entity that is important rather than its presence. For example, in order to complete a delivery order, the absence of "rain" as an entity may be important. This example is in Fig.14 NSL provides n-potentiality and n-actuality, which provides an alternative way to deal with it at the attribute level.

[0101] Representational Entities: In NSL, everything is contextual and relative in nature. Any entity that is in the physical layer of a CU (like a CD) that is contextually relevant becomes a "real entity". All other entities that have an "equal relationship" with it become representational entities. In other words, what is "real or representational" is contextually based and relative in nature. No substrate can override any other substrate to determine what is a real entity or a representational entity. A variation unit can have variation drives (CDs) from different substrates at the same time. For example, a message can be one CD, a "physical pen" can be another CD, and an "image" can be yet another CD, each belonging to a different substrate and still located in the same CU.

[0102] Truth value: Although representational entities are said to represent "real entities" or "other representational entities", truth values ​​may vary due to uncertainty inherent in nature or the understanding, motivation, or intention of human agents. For example, it may be said that "X" is at location "Y", but this may or may not be a correct statement. If it is correct, the statement is "true", and if it is not correct, the statement is "false".

[0103] Physical reality: All entities - real, perceived, and informational - exist "physically" in the physical world. While it is intuitive to draw this conclusion about real entities, even perceived and informational entities exist in physical reality - space and time. The fact that they derive their values ​​from representational entities does not change the characteristics of those entities, which are also physical entities.

[0104] Elapsed Time: When a trigger state is reached in an intent statement, it causes one or more changes in one or more intent statements (including its own intent statement). All changes require time, called "elapsed time". Whether the change is driven by a human agent or a machine agent, there is always elapsed time involved. In some cases, this change can occur in a fraction of a second, while in other cases, the length of time can be as high as hours or even days. All entities participating in the interaction that produces the desired change will be occupied during the elapsed time and may participate in any other trigger only after completing the previous action.

[0105] Perspective: Each basic entity exists in a binary state at the individual level. Entities also combine to form composite entities. Perspective refers to the relative position from which entities can be observed. If an entity is observed holistically from a higher perspective, i.e., from a higher rung of the differentiating ladder consisting of all its subsets, then the connected entity count will be quite high. In contrast, if an entity is observed at a lower perspective, i.e., from a lower rung of the differentiating ladder, then the connected entity count will be much lower. For example, imagine a higher perspective "A" from which the direction of differentiation can be seen. "A" can have a differentiating subset "AB". If combined with "C", it can have a second level more differentiating subset "ABC". "AB" covers only the subset "ABC". "AB" has fewer connected entities in the direction of differentiation than "A". Another way to say this is that higher perspective entities carry more information than lower perspective entities. Furthermore, the direction of differentiation is from top to bottom, and all entities are connected through their nearest neighbors. These entities are loosely coupled but essentially unified, meaning that events can reach individual BET levels but keep changing the collective state. Higher perspectives have the highest number of BETs or information. The BET structure is nodes, potentials, and actualities. Information is often ignored to reduce cognitive load. When this happens, the nearest neighbors in the generalization direction become the same. When the pen color is ignored, the two pens become the same. But if the pen itself is ignored, only the BETs / nodes remain. This is why the number of BETs is higher at higher perspectives. How much information should be ignored is based on optimization principles. For example, the CEO of an organization ignores most of the information and only calculates the amount of transactions and revenue, even though he has access to all the information.

[0106] Perspective switching: Differentiation occurs horizontally through the connected CES and ECES. An example of horizontal differentiation is represented in Figure 12(a). Differentiation can also occur vertically by creating classes, subclasses, and any number of sub-sub classes, all the way to transaction classes or even sub-transaction classes. An example of vertical differentiation is represented in Figure 12(b). The degree of differentiation increases as one moves down the vertical differentiation tree. For “adjudication” or “optimal differentiation,” solution designers can leave room for transaction classes to switch between higher-level differentiation or lower-level differentiation to apply when the situation requires. When more information is subtracted or ignored, one moves to a higher perspective. For example, an application is created for pizza delivery. If the information called “pizza” is ignored, it becomes food delivery. If the information called “food” is ignored, it becomes delivery. Here, the information is present, but at a higher perspective, the information is ignored.

[0107] Differentiation: In NSL, anything that is unique and / or discrete that is relevant to the solution is an entity. This appears as a “BET” when animated. In the case of entities, events flow in only one direction, from the entity to the brain or system. But there is no mechanism for events to feedback or flow back. The BET structure incorporates feedback flows. If each entity is informational (because it is unique and / or discrete), then each event that changes its state (from potential to actual or vice versa) is also informational. Each entity is also a class. A class is created when the possibilities can be restricted to many others. “Pen” is a class because the only member it contains is a pen. You cannot put a paperweight or pencil into that class. A class distinguishes one or a few from many. A set of classes differentiates to a more granular level. A pen is a differentiated class. When combined with another class called “red”, it becomes more differentiated. If you combine it with yet another class (such as “dark”), it is further differentiated. All solutions are optimally differentiated sets of classes. There are different synonyms that can be used to describe these, such as "rules", "algorithms", and "laws". If a class is added, the solutions are more differentiated, while if a class is removed, the solutions are less differentiated. Since all classes obey the nearest neighbor principle, the directionality of differentiation operates in the following way, the former set is ABC and the latter set is ABCD. If class "D" is ignored, it is merged with ABC. However, if ABCD is ignored as a differentiated set, but its existence is still considered, ignoring the existence of "D" leads to having two ABCs, the former and the latter set.

[0108] CU as a Local Node Network: There are countless species and organisms on Earth. But all of these species, without exception, are made up of "cells". The fundamental building block of all organisms is a "cell". Similarly, the fundamental unit of any solution is a "Change Unit" (CU). All Change Units consist of a "Local Node Network". A node represents the identity of an entity that exists. The connection of nodes is represented by a "Transition Line" (TL) with an arrow (or equivalent) that shows the direction of differentiation between nodes. Nodes are differentiated by the unique or identical entity hanging on them. A CU starts with a "Master Node" which is differentiated by a "Statement of Intent" attached to it. Fig.24 CU is represented as a local node network. At the initial level, CU has nodes related to "independent entities" that are distinguished from the main node. There is no limit to the number of nodes at the initial level in theory. There can be any number of attribute levels, and each level can have any number of attributes. There are four node levels, that is, called a four-layer CU. The property of the local network of this entity is that it has an attribute that causes an event in one or more local node networks when the trigger condition is met. This attribute is called a driver of change driver (DCD). In NSL, it is also called a "change driver". The trigger state of a local network can drive changes in any layer (e.g., the information layer) of any local node network including itself.

[0109] Furthermore, NSL is driven by a network of nodes to which BET is connected in unbroken chains. Boxed or monolithic structures must be avoided. The BET structure in the construction solution is done in the following way:

[0110] Each BET is hung on an implicit node. A BET is anything that is important to the solution, including CES and ECES, as long as it deserves to be considered independent. Example: A, B, C and D are all BETs, as is the CES "ABCD". Each BET has its own properties that will cause an event when triggered; non-triggered CES result in a "null" event. When nodes are connected to the nearest node following the nearest neighbor principle, an unbroken network of nodes is formed. CU nodes are connected to each other, up to the GSI nodes. These GSI nodes are connected to each other at a higher aggregation functional level based on the IRDR of that level. All transactional CU nodes are hung to their respective solution nodes. A CU node is the master node of a CU representing the combined entity state (CES) of that CU. Each combined entity state node consists of nodes for each non-triggered node, all the way up to the triggered CES. Each CES node consists of loosely coupled and simultaneously unified CESs. Potential (expected) BETs are hung on the corresponding nodes. In turn, actual (experienced or perceived) BETs are hung on potential BETs in the "actual" dimension, or, so to speak, as members of potential BETs. For visualization, imagined potential BETs are those that first come to mind when anticipating what to expect. Actual BETs or member BETs are those that match the expected potential BETs in the real world.

[0111] Classification of CU: CU is roughly divided into the following categories: a. Horizontal change units: These are change units that interact horizontally, and the generated triggers move from one CU to another horizontal CU. In practical scenarios, each solution consists of multiple horizontal change units. Sequential, alternating, and parallel CUs belong to this category.

[0112] b. Vertical Change Units: These are change units where a higher level change unit triggers a lower level change unit in the change unit. Embedded and nested CUs fall into this category.

[0113] c. Multi-layer variation unit: All layers and sub-layers of a CU belong to this category.

[0114] d. Aggregate change units: Those CUs that have been called subordinate and superordinate CUs so far belong here. These essentially rely on information input and transaction aggregation of CUs at a lower perspective. For example, the aggregation of a supervisor's CU is based on transactions generated by the delivery leaders reporting to that person.

[0115] Basic Change Units: These are the basic units in which all transactional interactions between entities and the resulting triggered states occur. Basic CUs exist and operate in the same way regardless of the perspective in which they exist. At higher perspectives, information layers tend to carry more information.

[0116] Sequential Change Units: These are CUs that can be affected by one or more events when triggered by the basic CU. Sequential CUs utilize the AND operator principle. The CES state is maintained in the basic CU as well as the sequential CU to form an ECES. For example, to prepare a cup of tea, you need to put a tea bag in the cup, fill the kettle with water, boil the water in the kettle, pour the boiled water into the cup, and add sugar to the cup. These are the sequential steps to make tea.

[0117] Embedded Variation Units (ECUs): These are CUs within a CU. Embedded Variation Units are part of vertical differentiation. They are triggered only when triggered by a higher level CU, which is either the base CU above or the embedded variation unit immediately above. When there are several levels of embedded variation units, they are called primary, secondary, tertiary, etc., similar to how attribute levels are defined. At each embedded variation unit level, there can be any number of connected embedded variation units. There are two types of embedded variation units: 1. Sub-CUs and 2. Recursive CUs. Whether it is "recursive or sub-CU", the nature of the functionality is the same. An embedded CU decomposes the functionality of a higher level CU into several steps through connected smaller CUs. For example, a higher level CU may be dealing with the problem of moving from one end of a city to the other. An embedded CU may decompose the functionality into the intersection of 10 connected streets until one of them leaves the city. Entering the city triggers the embedded CU of CU1, leaving from the last street triggers the higher level CU, placing the "leaving the city" event in the higher level CU2. In other words, the GSI of the embedded CU triggers the higher level CU to generate an event in the next CU. There can be any number of layers in an embedded CU. The GSI of the lower level CU triggers the higher level CU, which is Fig.30 Indicated in.

[0118] Sub-CU: When a CU is split into several underlying smaller CUs, each of these CUs becomes a sub-CU. For example, an activity that takes ten minutes (base CU) can be decomposed into several smaller units of change consisting of one or two minute segments called tasks. In the absence of sub-CUs, the base CU (CU1) can place the output in the sequential CU (CU2). However, the solution designer can choose to ensure that the activity is driven in an orderly manner through the steps specified in the smaller CUs (sub-CUs) connected to it. He can introduce one or more connected sub-CUs. When the base CU (CU1) triggers, it relies on the set of sub-CUs located in the main embedded CU level. The embedded CU set has its own embedded GSI. When this GSI is triggered, an event will now be caused in the base CU2, just as it would have happened if the embedded CU did not exist. This process can occur at any depth relative to the more levels of embedded CUs that exist (secondary, tertiary, etc.). The secondary CU serves the corresponding single CU (each task) in the main level through its GSI. That is, the sub-CU1 (task 1) of the main level is served by the secondary level GSI and causes an event in the sub-CU2 (task 2) of the main level. This process can continue to any number of levels. NSL provides the ability for each task to be served by any number of subtasks at the secondary level. Each of the several tasks at the primary level can individually have its own secondary level, each of which can accommodate any number of tasks. This is how the differentiation tree built by embedded CUs branches. At the primary level, there is no difference between the way differentiation occurs with respect to attributes and differentiation caused by embedded CUs.

[0119] Recursive CU: There is no fundamental difference between recursive CU and sub-CU. Both are subordinate to a base CU or a higher level recursive CU or sub-CU. The main difference between them is that recursive CU deals with recursion and therefore with numbers and mathematical constructions; sub-CU involves unique entities and unique transformations. For example, each of a series of tasks embedded in an activity is unique within a sub-CU instance. Washing dishes includes tasks such as bringing the unwashed dishes from the dining table to the sink, turning on the tap, wetting the sponge, applying soap to the sponge, washing the dishes, etc. In contrast, a recursive CU involves recursion in space and time. In the case of a sub-CU, for washing dishes, base CU1 will be triggered and all tasks are executed at the level of the embedded sub-CU. The result will be that the GSI at the sub-CU level will place the washed dishes at base CU2 as an event caused by it. This will happen anyway (base CU1 places the clean dishes in CU2) if the solution designer chooses not to impose standard operating procedures in the system through main level tasks. Recursive CUs are important if the desired solution is that the dishes must be washed ten times before being placed in base CU2. The tasks performed are not unique but repeated. Recursive CU1 will place the plates that have been washed once in the next recursive CU, the second recursive CU will place the plates that have been washed twice in the third recursive CU, and so on. The last recursive CU, which is also the GSI where the tenth wash occurs, places the plates that have been washed ten times in basic CU2. The change driver (CD) in each of these recursive CUs will be the same agent and the same plates, with the attribute values ​​of the plates gradually changing. In the first recursive CU, the plates will have the attribute "washed 0", in the second recursive CU the attribute "washed 1", in the third recursive CU the attribute "washed 2", and so on.

[0120] Nested CU (nCU): Inherent in each variation unit is a fractal-like playout of the SSA loop. In the presence of an agent, the senses detect things in the environment, the mind makes the appropriate choice from several possibilities; the body provides the energy needed to complete the variation loop. A nested CU is an additional CU layer added to a base CU to provide more information at the transaction level. It is like an SSA loop within the SSA loop of the base CU. NSL has no restrictions on the number of layers of SSA or variation units. Depending on the desired solution, the solution designer has the flexibility to add as many granular SSAs as needed within the base variation unit. A nested CU can cause one or more events in one or more CUs, including the base CU to which they belong or their higher-level nested CUs. For example, a nested CU can convert the "reality of the base CU's intention" into potentiality, thereby disabling it in certain circumstances. Events caused by nested CUs are always in the context of the base CU to which they are attached, while their triggering can be independent of the triggering of the base CU or higher-level nested CUs. The CD of a nested CU can be an independent entity, or an attribute of a base CU entity or a higher-level CU entity (such as the probability of a realistic state of an entity or CES). Nested CUs can also convert "conditional potentials" into potentials in one or more CUs (including themselves). For example, "rain" can convert the conditional potential of a raincoat in a base CU into a potential that makes the triggering of the base CU conditional on the availability of a raincoat. Nested CUs are euphemistically referred to as nested thinking. Embedded CUs decompose coarser CUs into finer connected CUs. In contrast, nested CUs apply a larger context to the context that exists at a higher-level CU. For example, a higher-level CU context can be the delivery of a product, provided that there are CDs such as human agents, vehicles, and products. The implicit condition of the higher-level CU is that the weather is normal. A nested CU may be created, bringing in the context of "rain". The higher-level CU continues to function as if the nested CU did not exist before it stopped raining. When the condition for rain is met, the behavior of the higher level may change. It may result in stopping the triggering of the higher-level CU and abandoning the transaction, or it may generate conditional potentials that introduce additional CDs (such as umbrellas). This example is in Fig.31 If the probability of a CD arriving is low, the context can influence the behavior of a higher-level CU. For example, if the probability of a doctor arriving is quite low, the patient can be asked to come back later. There can be one or more connected nested CUs. There can also be any number of nested CUs, i.e., contexts, within a context.

[0121] Entangled CU: This construct was introduced in NSL to solve frequently encountered mathematical expressions such as formulas and equations. Entangled CUs always coexist with properties that can conditionally affect each other. The behavior of entangled CUs is synonymous with entangled particles, which can determine the value of their counterparts when their values ​​are determined. In other words, they are inextricably dependent on each other.

[0122] a. Formulas: These are defined as "general structures of relations between quantities". These qualify as supersets. For example, "A" is greater than "B". These expressions encompass the possibility of equality but can be extended to other general formulas.

[0123] b. Equalities: They are defined as "statements asserting that two expressions are equal". This is similar to the value of "subject" being the same as "object", with the special property of being able to determine each other's value, unlike ordinary sentences where the "subject" determines the behavior of the "object". This should be observed in the context of mathematics, where there is room only for identical entities and their relations with respect to the sets they form.

[0124] Connected CU: All CUs and entities in the ecosystem are interconnected. This is similar to how humans have relatives in the form of first cousins, second cousins, etc. A connected CU is a CU of the ecosystem that belongs to a particular GSI. There can be several connected GSIs, but when one of them is satisfied, based on the choice made by the event, the other connected GSIs will disappear. For example, to fulfill the global intent of a customer to reach his destination with documents and a lunch box, two agents can provide these entities (documents and lunch box) into the connected CU system. An example of a connected CU is in Figure 4 Indicated in.

[0125] Related Entities and CUs: The term “related entities” refers to all entities that are directly or indirectly part of the solution ecosystem. This even includes entities that enter and exit the solution ecosystem. These extend to all classes and all transactions. Related CUs are those CUs that may not be connected to the same global intent. In some ways, the connected CU ecosystem is a subset of the related CU ecosystem. Related CU system example: When a final offer letter is sent to a candidate, both the finance manager and the hiring manager are notified. The finance manager has to do the budgeting, the hiring manager has to arrange the logistics for the new hire, and the interviewer has to go through the interview process. Examples of related CUs are in Figure 5 Indicated in.

[0126] Four-layer CU: Everyone learns from principles of how the world works, which have been established through 400 years of science. In the presence of agents, a few principles stand out.

[0127] i. Agents are constantly seeking solutions for survival.

[0128] ii. All solutions arise from controlled and directed change.

[0129] iii. The agent is driven by the purpose of the SSA loop control.

[0130] iv. In the case of human agents, they are designed through an evolutionary process. In the case of machine agents, they are designed by human agents to overcome complexity and infinity.

[0131] v. Agent systems are driven by discrete / unique states out of necessity.

[0132] vi. Discrete states are concerned with objects, their properties, and any type of change.

[0133] vii. Any change is driven by the cause-and-effect principles experienced by the units of change, and SSA cycles are inherent to them.

[0134] viii. Any unique discrete / unique state can be represented in natural language.

[0135] ix. Any identical discrete / unique state can be represented by a number.

[0136] In NSL, a CU is a local node network. The master node represents the local network in the form of "LSI" or CU name. There are two types of layers in the local node network, physical layer and information layer. There are also two or more implicit or inherent layers in each of the local node networks. One of the layers is the "interrogative layer". This represents the ignorant agent asking questions and seeking answers from the knowledgeable agent located in the CU. In order to perform functions within the CU, it is assumed that the agents in the CU are knowledgeable. Depending on the information and decision-making power of the agent asking the question (interrogation), the knowledge agent is obliged to provide or not provide an answer. Another implicit layer is the "measurement layer" (called exclamation in natural language). Measurements have the following properties: (i) They are salient parts of the physical layer or information layer. (ii) Usually, the salient parts are further differentiated by attribute values ​​to focus more on things. For example, if the salient part is "delivering products to customers", the differentiating attribute can be delivering products in less than 30 minutes or more than 30 minutes. (iii) The third property of the measurement is the agent's opinion on the status of the salient part with a given differentiating attribute. These are called norms. For example, products delivered in less than 30 minutes are good, and products delivered in more than 30 minutes are bad. Fig. 22 NSL considers CU as four layers, such as Fig.23 As shown. The four layers of CU are as follows:

[0137] 1. Questioning layer: This layer is latent and is invoked when an “ignorant agent” asks a question. The ignorant agent is provided with answers by an authorized agent with information rights and decision rights (IRDR) located in the corresponding CU.

[0138] 2. Physical layer: It is the same as imperative or prescriptive statements in natural language.

[0139] 3. Information layer: It is the same as descriptive or declarative sentences in natural language.

[0140] 4. Measurement layer: It is the same as the exclamatory sentences in natural language.

[0141] Interrogative sentences help to convert descriptive sentences into prescriptive sentences. There can be a descriptive sentence like "The sky is blue." This can be converted into a prescriptive sentence by asking a question or interrogative sentence "Is the sky blue?" The qualified member of this prescriptive sentence is in a binary state of being blue or not blue ("yes" or "no"). Fig.25 Indicates interrogative sentences that help convert descriptive sentences into prescriptive sentences in a binary state. When there are several options, interrogative sentences that generate "prescriptive sentences" take the form of multiple-choice questions. For example, "What color is the sky?", the options provided will be A, B, C, D, and E, of which "blue" is one of them. Only blue qualifies as a member of the prescriptive sentence. Fig.26 Indicates interrogative sentences with multiple options that help convert descriptive sentences into prescriptive sentences.

[0142] Multi-layer CU: A multi-layer CU (also interchangeably referred to as a multi-NSL stack CU) extends the capabilities of the CU from four layers (functional layer, information layer, UI layer, and measurement layer) to additional layers that provide depth and breadth to the functionality of the CU. In the context of a multi-layer or multi-NSL stack CU, a layer or NSL stack is a collection or system of properties with some common properties that bind them. An NSL stack for a local intent declaration (CU) is linked or integrated with the local intent declaration (the CU) to generate data, wherein the generated data is used to: (a) provide predefined functionality to the local intent declaration (the CU); and / or (b) provide predefined functionality to one or more other local intent declarations (other CUs); and / or (c) perform data analysis. Examples of layers or stacks include, but are not limited to, the following:

[0143] A. Language Layer or Language Stack: NSL not only provides the ability to switch from one natural language to another, but also provides the ability to personalize the natural language at each agent level. Multiple users can develop and trade in any language of their choice at the same time. This is achieved through a language equivalence matrix, where each language is in a given column and a unique BET ID maintains functional integrity. The language equivalence matrix is ​​a database that stores language equivalences across multiple natural languages. For example, when the information displayed when building or executing a solution is in a first natural language, the user can provide input to select a second natural language that is different from the first natural language. In response to selecting the second natural language, the equivalent word in the second natural language that is equivalent to the word in the first natural language is obtained from the language equivalence database and displayed by the system.

[0144] B. Machine Learning (ML) Layer or ML Stack: CESs located in this layer are different from the functional layer. CESs in this layer absorb information from transactions, constantly re-evaluate CESs for optimal efficiency, and insert themselves into the main stray functional layer when certain conditions are met. An extreme case is that when a CU no longer serves the purpose it was originally intended to serve, it will delete the CU itself. This is similar to the suicide of cells in biological systems in certain circumstances. In the example, the machine learning stack is linked to a local intent statement to generate data that provides a predefined function that evaluates and / or modifies and / or ignores and / or recommends at least one of user input and output during the construction or execution of a solution. The predefined functions that evaluate and / or modify and / or ignore and / or recommend can also be associated with local intent statements, entities, attributes, agents, unique relationships, NSL stacks, etc. The predefined functions described herein are provided based on one or more machine learning techniques and / or one or more machine learning databases associated with the local intent statement and / or with one or more other local intent statements. In machine learning, relevant or important features are extracted, and unimportant / irrelevant features are ignored or discarded, that is, feature engineering is automatically done by the algorithm. In deep learning, convolutional layers are used to find features in an image or object that are relevant or important to the next layer to form a hierarchy of non-linear features that grow in complexity. The final layer or stack uses all these generated features for classification or regression depending on the problem. NSL uses various techniques of ML to continuously evaluate transactions and provide recommendations / insights on various aspects such as trends, efficiency, etc. based on parameters defined by the solution designer.

[0145] C. Blockchain layer or blockchain stack: Many aspects related to security, information integrity in a distributed environment, issuance of non-fungible tokens (NFTs) at the CU level, personalized cryptographic tokens and other blockchain-related features are mixed with the NSL structure to provide significant effects. Therefore, the elements of the present invention can be multiplied. Blockchain is a combination of cryptographic keys, peer-to-peer networks containing shared ledgers, and computing means for storing transactions and records of the network. NSL provides the ability to protect information in the solution using Ethereum blockchain network technology. In the example, the blockchain stack is linked to a local intent statement to generate data that provides the following predefined functions: during the construction or execution of the solution, based on one or more blockchain technologies, for the local intent statement and / or for one or more other local intent statements, protect at least one of the user input and output; and / or during the construction or execution of the solution, based on one or more blockchain technologies, for the local intent statement and / or for one or more other local intent statements, issue a non-fungible token and / or personalized token for at least one of the user input and output.

[0146] D. BET analysis layer or analysis stack: Similar to the measurement layer, this layer can add special features and advanced features to the NSL that are mainly driven by statistical functions. In general, whenever there is additional information or classes, several potential paths are generated. For example, consider a set of 4 classes ABCD. Suppose an additional class E is added, creating a new set ABCDE. In the first BET set, there are CES states (16), in the second BET set, there are (32) states. This means that adding one BET or class generates 16 additional states or paths. Analysis is about processing this additional information and selecting the important information elements or paths. All possible paths are generated based on the additional information, and the truly important ones are selected, which are called insights. It is observed that all insights should lead to actions that add significant value now or later. Actions can occur at a transparent level captured by CES or ECES. But insights can also lead to best practices or actions within opaque trigger states performed by agents. For example, a delivery person can deliver a delivery by walking to a place or by using a bicycle. The insight may be that it is more efficient to deliver the delivery using a bicycle. If the solution does not generally specify the way, these actions are opaque to the system because it only processes things from one frame to another. Between frames, actions are not captured at the system level, making them opaque. In the example, the analysis stack is linked to a local intent statement to generate data that provides predefined functions for data analysis of at least one of the user input and output based on one or more statistical functions for the local intent statement and / or for one or more other local intent statements during the construction or execution of the solution. The data analysis performed by the analysis stack is as described above. Additionally, the analytics stack can perform any type of data analysis based on the information collected to build and execute solutions.

[0147] E. Knowledge layers or knowledge stacks: While a CU requires a certain understanding of the functions to be performed by an agent, the actual knowledge of a particular agent can vary greatly. By adding knowledge layers, the knowledge level of an agent can be captured at the level of each CU and can also be influenced at the system level. This is a powerful tool.

[0148] The knowledge layer has the following characteristics: Knowledge Base (KB): The knowledge layer should have a knowledge base which deals with real facts of the world and is updated by the knowledge level of the agent captured by each transaction. It is a mixture of sentences interpreted in a knowledge representation language.

[0149] Inference Engine (IE): It is a knowledge-based system engine that is used to infer new knowledge in the system.

[0150] Actions performed by the agent: When one wants to update some information (sentences) in the knowledge base and learn about what is already there, the reasoning system is used. This mechanism is done through the TELL and ASK operations. These operations include reasoning, which is the generation of new sentences from old ones. When a question is asked to the KB, the reasoning must accept the requirement and the answer should follow what the KB has been told. The agent also has a KB, which initially has some background knowledge.

[0151] In an example, a knowledge stack is linked to a local statement of intent to generate data that provides the following predefined functions: determining a knowledge score of an agent associated with the local statement of intent or one or more other local statements of intent based on a set of predefined questions and answers during building or executing a solution; and storing the knowledge score of the agent in a knowledge database. In addition, in an example, a prompt is generated by the system to change one or more agents of the local statement of intent or one or more other local statements of intent based on their respective knowledge scores.

[0152] F. Integration layer or integration stack: NSL not only creates new solutions, but also integrates seamlessly with existing systems through NSL APIs and adapters placed at the intersection of a given CU and external system bridging level. In the example, the integration stack is linked to a local intent statement to generate data that provides predefined functions that implement one or more NSL application programming interfaces and system integration during the construction or execution of the solution.

[0153] G.NSL Retained CU:NSL follows a basic rule that BETs present in DSD are never recreated but only cloned. The retained BETs or cloned BETs are inserted into the correct CU level in the system through the catalytic role played by this layer.

[0154] H. Internet of Things (IoT) Integration Layer or IoT Integration Stack: AI products are driven by the SSA cycle. The “S” in the middle stands for “Select”, which is the same as the NSL Intelligence Layer. This layer inserts intelligence into AI products with sensing and actuation capabilities. IoT is about sensors implanted in machines, which provide data streams through internet connectivity. All IoT related services inevitably follow five basic steps, namely, creation, communication, aggregation, analysis, and action. The value of “action” depends on the penultimate analysis. In the SSA cycle, “A” stands for action, which performs actions based on the analysis. The analysis step is done by the analytics engine present in the NSL. The IoT Integration Layer can help in predictive maintenance of machinery (i.e. predicting machinery failures and server failures in advance), better risk management, improving operational efficiency, triggering new and enhanced products and services, robotics in manufacturing, self-driving cars, retail analytics, etc. Machine learning (a subset of AI) in IoT devices helps in identifying patterns and detecting any failures in data collection through extremely advanced sensors. In an example, the IoT integration stack is linked to the local intent statement to generate data that provides predefined functionality to enable integration of one or more IoT device interfaces and / or one or more sensor interfaces and / or IoT application programming interfaces with the system during building or executing a solution.

[0155] I. Metaverse layer or metaverse stack: Elements of VR, AR, MR, and holography can be placed in this layer in context to prepare for the shape of things in the future. NSL uses three categories of VR, namely non-immersive VR, semi-immersive VR, and fully immersive VR. VR technology usually consists of a headset and accessories such as controllers and motion trackers, and proprietary software or apps. VR hardware includes sensory accessories such as controllers, headsets, hand trackers, treadmills, 3D cameras, 3D mice, optical trackers, wired gloves, motion controllers, tights, and even olfactory devices. Sensory accessories used in VR are part of the SSA loop, where the first “S” stands for “sensing” in NSL. The software includes VR software development kits, visualization software, content management, game engines, social platforms, and training simulators. Some apps allow users or players without headsets to connect to the same environment and interact with each other in VR. The middle “S” in the SSA loop stands for “selection”, which is the same as the NSL intelligence layer, inserting intelligence into the product. In NSL, virtual reality is used for training, gaming, sales support, healthcare, retail, architecture, data visualization, marketing and advertising, etc. Augmented reality is a technology that extends our physical world by adding multiple layers of digital information on it. Augmented reality technology combines virtual information with the real world. Technical aspects include multimedia, 3D modeling, real-time tracking, intelligent interaction, sensing, cloud computing, etc. The principle of this technology is to apply computer-generated virtual information, such as text, images, 3D models, music, videos, etc., to the real world after simulation. In NSL, there are 4 types of augmented reality: (1) markerless augmented reality; (2) marker-based augmented reality; (3) projection-based augmented reality; and (4) overlay-based augmented reality. Augmented reality can be displayed on various devices, namely screens, glasses, handheld devices, mobile phones, head-mounted displays. The accessories used in augmented reality are part of the SSA loop, where the first "S" stands for "sensing" in NSL. The middle "S" in the SSA loop stands for "selection", which is the same as the NSL intelligence layer, inserting intelligence into the product. Augmented reality involves technologies like SLAM (Simultaneous Localization and Mapping), depth tracking (sensor data that calculates the distance to an object), and other components, namely cameras and sensors, processors, projection, and reflection. In NSL, augmented reality is used for training / education, gaming, healthcare, broadcasting, data visualization, etc.

[0156] Mixed reality depends on an evolving relationship between humans and machines. Mixed reality uses a range of cameras, sensors, and AI-enhanced technologies to process data about a space and use that information to create digitally augmented experiences. The sensory attachments used in mixed reality are part of the SSA loop, where the first “S” stands for “sensing” in NSL. The middle “S” in the SSA loop stands for “selection,” the same as the NSL intelligence layer, inserting intelligence into the product. For example, when a user puts on a pair of mixed reality glasses, the cameras and sensors in those glasses connect to a software program that collects as much information as possible about the environment, essentially creating a virtual map of the real world. Using that map, mixed reality technology can add holographic images and content to the world using image projection. Computer processing in the cloud, advanced input sensing, and environmental awareness enable mixed reality solutions to successfully blend the real and virtual worlds, moving beyond the basics of augmented reality technology. In an example, the Metaverse stack is linked to a local intent declaration to generate data that provides predefined functionality for implementing integration of one or more virtual reality device interfaces, and / or one or more augmented reality device interfaces, and / or one or more mixed reality device interfaces, and / or holographic device interfaces, virtual reality application programming interfaces, and / or one or more augmented reality application programming interfaces, and / or one or more mixed reality application programming interfaces, and / or holographic application programming interfaces with a system during construction or execution of a solution.

[0157] J. Value layer or value stack: This layer will capture the value of each BET in monetary terms. Each BET contains a value that can be expressed in monetary terms, and the combination of BETs also produces a value. The values ​​generated in the CES state are based on time or based on the state change of the entity. NSL provides solution designers with the ability to enter unit costs at the BET level and methods to calculate values ​​at the CES level. When a transaction occurs, the value layer performs calculations and generates instant values ​​for the transaction based on the rules set by the solution designer. Instant reports can be extracted from the system based on this calculation, eliminating the need for any separate financial system or record. In the example, the value stack is linked to a local intent statement to generate data that provides the following predefined functions: receiving a monetary value of at least one of each entity, each attribute, and agent associated with the local intent statement; and based on the received monetary value, generating a total monetary value of at least one CES in the CES set associated with the local intent statement. This total monetary value can be generated during the execution of the solution and when at least one CES is changed to a real state.

[0158] K. Energy layer or energy stack: The energy layer will capture the energy consumed by each BET. Each BET contains directed energy, and the combination of BETs also requires energy. The agents that own these BETs act as catalysts that drive energy. At any perspective, the NSL can report the energy consumed by each BET. In the example, the energy stack is linked to the local intent statement to generate data that provides the following predefined functions: determine the energy and / or storage space consumed by at least one of each entity, each attribute, agent, and each CES associated with the local intent statement during the construction or execution of the solution. In the example, the consumed energy and / or storage space can be determined when the corresponding entity, attribute, agent, and CES change to a real state. In the example, the energy can be determined based on the communication frequency of the signal, the data processing speed, the power or energy consumption of the system, etc.

[0159] Furthermore, the node network operates in the following manner relative to the layers and sub-layers within a CU: Each layer is subordinate only to the functional layer of the CU. Therefore, the master nodes belonging to each layer are directly hung on the master nodes of the functional layer. Each layer has a one-to-one relationship directly with the functional layer. The sublayers of any particular layer will have a one-to-one correspondence with the layer above. If there are more sublayers in the sublayer, they will have a corresponding relationship with the sublayer above. Each node will have a unique id, showing its position in the node ecosystem of the solution. There will be an id for each CU, and a corresponding id for the layer represented by the node. For example, the functional layer may have a "layer distinguishing id", such as a node number starting with "F". The blockchain layer may have a node number starting with "B". It is up to the designers to exercise the correct id assignment that they think is convenient. All nodes and subnodes will be distinguished in this way.

[0160] Additional layers or additional stacks: In addition to the multi-layer CU, here, several more layers are described below: a. Base layer or base stack: The details of this layer and its properties are described later in the description of the paragraph "Base and its properties" of this document. In an example, the base stack is linked to a local intent statement to generate data that provides a predefined function to determine the medium of at least one of user input and output before executing the solution. In an example, the medium is at least one of text, audio, video frame, image, and gesture.

[0161] b. Security Layer or Security Stack: Each BET from all perspectives is either an independent BET or a collection of its own properties. This makes it easy to make all BETs highly secure both individually and collectively. In fact, the security of a BET can be personalized to any desired degree based on the context. In an example, the security stack is linked to a local intent statement to generate data that provides predefined functionality to provide security to at least one of user input and output based on one or more personalized techniques and / or one or more encryption techniques during the construction or execution of the solution.

[0162] c. Privacy layer or privacy stack: Due to the uniqueness of the BET structure in the NSL paradigm, the privacy of BET can be treated as easily or flexibly as "security". Privacy-enhancing technologies used in NSL are cryptographic algorithms such as homomorphic encryption, secure multi-party computation, differential privacy, and zero-knowledge proofs. Data masking techniques include obfuscation, pseudonymization, etc., as well as other machine learning and artificial intelligence algorithms such as synthetic data generation, federated learning, etc. In the example, the privacy stack is linked to a local intent statement to generate data that provides predefined functionality to provide privacy to at least one of the user input and output based on one or more cryptographic techniques and / or based on one or more encryption techniques during the construction or execution of the solution.

[0163] d. Masking layer or masking stack: This is the same de-identifying information required for contextual optimization. For example, the CEO of a large conglomerate, while having access to all information in the ecosystem, may choose to mask most transaction information, such as details of where, when, and who delivered the goods. The CEO captures information, such as the number of transactions in a given time period, to maximize the value of the information with the least effort. In the example, the masking stack is linked to a local intent statement to generate data that provides predefined functionality to mask at least one of the user input and output during the construction or execution of the solution.

[0164] e. Hidden Layer or Hidden Stack: In each CU, there may be many entities that are important but not consciously recorded in the functional layer or any other layer, which may help to derive deep insights or insights that may lead to meaningful actions. This can be the case with intent (master node) or with each entity or attribute that constitutes the CES in a CU, or it can be the case with the process behind the triggering state. The possibilities are endless. Here are a few examples:

[0165] i) If the intention is to write a letter, a table and a chair may be involved. These can be placed in the latent entity layer. Note that the existence of latent entities does not need to be deterministic, but probabilistic. A table or a chair can be placed in the latent entity layer with a 90% probability attribute value.

[0166] ii) If a pen is used, the cap or colour associated with the pen is implied.

[0167] iii) If the CU cycle time is a few milliseconds, it implies that the agent is a machine. If it involves CU triggering while crossing a busy street, it implies that the traffic light was green at that time.

[0168] It can be noted that all implicit entities enable the ecosystem system to access more meaningful information. With each additional piece of information, there are more opportunities to gain more actionable insights, enriching the quality of the solution. In the example, the implicit stack is linked to a local intent statement to generate data that provides a predefined function of adding one or more implicit entities and / or one or more implicit attributes and / or one or more implicit agents to the local intent statement during the construction or execution of the solution.

[0169] f. Voice layer or voice stack: This is the counterpart of the default text layer used for user interfaces.

[0170] g. Image layer or image stack: This is the counterpart of the default text layer with further support for text.

[0171] h. Game Layer or Game Stack: This layer attempts to make the solution an interesting activity and potentially throws the solution out as a byproduct of the game. In the example, the game stack is linked to a local intent statement to generate data that provides predefined functions that implement the integration of one or more game application programming interfaces with the system during the construction or execution of the solution.

[0172] i. Parent-Adult-Child (PAC) / Behavior Determination Layer or Behavior Determination Stack: The discipline of psychology uses transactional analysis as a widely accepted method for classifying personality traits. Each CU driven by a human agent and therefore the general behavior of the human agent can be classified in this way. This helps to cultivate the right behavioral characteristics in the human agent. In an example, the behavior determination stack is linked to a local intent statement to generate data that provides predefined functions for determining the behavior of an agent associated with the local intent statement or the behavior of one or more agents of other local intent statements based on analysis of user input during the construction or execution of a solution.

[0173] Sublayers: Since there can be any number of sub-attributes or sub-embedded CUs or sub-nested CUs, there can be any number of sub-layers below the CU layer. The drivers of these layers should identify the true nature of these layers by identifying the sub-layers and their properties. For example,

[0174] a. The base layer can have sub-layers such as physics, life forms, natural language, and metaphor.

[0175] b. The knowledge layer can have a learning assessment layer that assigns a given learning maturity level to a leader.

[0176] c. Natural languages ​​and programming languages ​​can have sub-layers for each language represented in the form of columns in a two-dimensional matrix.

[0177] d. The blockchain layer can handle NFTs and internal crypto tokens as associated sub-layers.

[0178] Multi-layer CU in solution development: Each of the above multi-layer CUs is a built-in layer developed and integrated into the NSL system. At solution design time, the system provides the user with the flexibility to select one or more multi-layer CUs based on his / her requirements for the solution being designed. While the description in the previous paragraphs discusses the function of each multi-layer CU and how the system implements the function, the following explains how a user can select a multi-layer CU and what impact it has on his / her solution:

[0179] During solution design or construction, the system prompts the solution designer whether one or more multi-layer CUs or multi-stacked CUs are required for the solution. Fig.36 Represents multi-layer or multi-stacked CUs in NSL.

[0180] When the designer selects a language layer or language stack for a CU, the designer can select any of a number of natural languages ​​displayed by the system. Based on the selection of the natural language, the system converts the solution design screen and the solution transaction screen into the selected natural language.

[0181] When the designer selects a machine learning layer or machine learning stack for a CU, the system reads and absorbs information from the transactions and constantly re-evaluates the CES for optimal efficiency and inserts itself into the main stray function layer when certain conditions are met, which must be input by the solution designer.

[0182] When the designer selects a blockchain layer or blockchain stack for a CU, the system uses the technology of the Ethereum blockchain network to provide secure information within the solution. The level of security can be selected by the solution designer.

[0183] When the designer selects an analysis layer or analysis stack for a CU, the system adds NSL special features and advanced features that are primarily driven by statistical functions to analyze these features. The system prompts the designer to select one or more such statistical functions required for the analysis.

[0184] When the designer selects a knowledge layer or knowledge stack for a CU, the system captures the knowledge level of each agent at the CU level. The system infers the knowledge of each agent at the CU level and enhances its knowledge base to provide real-time updates. For example: "The highest score a student can achieve in Geography is 90% because no student has scored more than this in the past". If in a transaction, the student's Geography score is entered as 92%, the knowledge base will be updated to "The highest score a student can achieve in Geography is 92%".

[0185] When the designer selects a value layer or value stack, the system receives the value of each BET in monetary form and generates a final value for the combination of BETs. The value generated at the CES state is based on time or based on the state change of the entity. This layer receives the unit cost at the BET level and calculates the value at the CES level. This layer performs calculations and generates an instant value for the transaction as it occurs based on the rules set by the solution designer. This layer extracts instant reports from the system based on this calculation, eliminating the need for any separate financial system or records.

[0186] When designers select an integration layer or integration stack for a CU, the system allows the solution to be seamlessly integrated with existing systems through the NSL API.

[0187] When the designer selects an IoT integration layer or IoT integration stack for a CU, the system integrates one or more IoT devices into the defined CU for prediction, pattern recognition, any fault detection, etc. based on the information generated in the runtime transactions.

[0188] When a designer selects a metaverse layer or metaverse stack for a CU, the system receives one or more elements of virtual reality, augmented reality, mixed reality, and holographic projection, where these elements can be placed at that layer in context in preparation for the shape of things to come.

[0189] When the designer selects a substrate layer or substrate stack for a CU, the system has its own set of constructs to make the truth values ​​of the entities equal. Audio / video / image are some well-known substrates.

[0190] When the designer selects a security layer or security stack for a CU, the system provides security for each BET from all perspectives. This makes it easy to make all BETs highly secure both individually and collectively. The security of a BET can be personalized to any desired degree based on the context.

[0191] When the designer selects a privacy layer or privacy stack for a CU, the system provides privacy for each BET in the NSL based on a cryptographic algorithm.

[0192] When the designer chooses sub-layers or sub-stacks, these can provide any number of sub-layers below the CU layer. The drivers for these layers discern the true nature of their layer by identifying the sub-layers and their properties.

[0193] As described above, when the designer selects any additional layer or any additional stack, these may provide one or more additional layers as per the user requirements in the NSL when building the solution.

[0194] Multi-layer CU is context-dependent. Since NSL interprets everything in the context of the solution, the functional layer related to the solution becomes the default master layer. All layers attached to it act as contextual additional information. Each layer is a collection of BETs that constitute a system with system properties. For example, if the layer is a language layer such as English, the additional information passes through the filter "English language grammar" before using the information in the context. Each layer has its own properties and is able to act as a master layer. For example: If the main purpose of building a solution is to provide knowledge, the knowledge layer becomes the master layer and all other layers including the functional layer are subordinate to it and act as a system, providing additional information in the context. When creating a solution in NSL, all layers appear in a potential state. Depending on the type of solution, those layers that can be transformed into a real state can be selected as master layers. Each layer has its own properties. For example: the physical layer is governed by the laws of physics. Therefore, any physical object should have weight, volume, color, etc. In a multi-layer structure, each layer is loosely combined while adapting to its own unique properties. One of the layers is the master layer, and the master layer itself is the context for setting the agent's goals. As a rule, a group of layers can potentially be tightly coupled, and while any number of layers is allowed, they can belong to a given group, such as new technology layers, functional layers, etc. Multiple sub-layers, each adapted to its own properties, are also allowed. Each sub-layer potentially acts as a filter for the layer above.

[0195] Fractal CU: The fractal nature of CU and BET is no different. Events in BET are caused by CU. The behavior of CU is affected by BET. They exist seamlessly in a symbiotic relationship. In essence, CU establishes horizontal or vertical relationships with other CUs. Horizontal CUs are 1. sequential, 2. alternative, 3. parallel. Vertical CUs are embedded, nested, and superordinate. Embedded vertical CUs are recursive and sub-CUs. When operating within any of these CUs, we cannot distinguish the type of CU because the basic structure is the same. With reference to the CU relationship, we can distinguish one CU from another and determine its type. For example, viewing CU2 from the perspective of CU1, the agent marks it as sequential. Similarly, all CU types are determined. The relationship between CUs also determines the direction of differentiation. For example, sub-CU5 causes sub-CU6 (which can be an embedded GSI), which in turn will cause the triggering of CU1, further leading to events in CU2. There is sequential sensitivity between CUs. For example, when an egg falls off a table, it is broken. It is impossible to put it back on the table in its original form. Likewise, when events flow in a particular way, reversal of events is impossible, just as we cannot change the past. However, the effects of past transactions can be ignored, and new transactions can be created within another transaction. Regardless of whether the relationship between CUs is vertical or horizontal, they are all part of an unbroken BET chain.

[0196] Fractal BETs: All BETs are binary variables that switch between potential and reality. The opening or closing of these switches is called an event. In the solution ecosystem, all events are controlled events. This means that there are agents behind each event. Each event involves three functional elements of the SSA loop, involving corresponding agents. 1. Sensing agent: a machine or human agent that notifies the information technology system of an event arrival or departure event. 2. Selection agent: this agent places the potential BET in the appropriate place at the solution level or transaction level. 3. Action agent: an agent that plays a role in causing the event. The name and ID of each agent are appropriately recorded. In some instances, the sensing, selection, and action agents can be the same, but there are some exceptions. The agent footprint across the SSA loop functionality is captured and converted into non-fungible tokens (NFTs) using blockchain. This immutability of information in the blockchain can be used as a permanent record of the value creation relative to the agent. Functionality around the SSA loop is usually captured in the following way: 1. Sensing is a UI attribute. 2. Selection is a functional logic BET. 3. Action is the previous CU and the agent in it, which will cause an event when triggered. BET participates in the ecosystem of BET as a value fractal to adapt the flow of value in the context of a set goal. This value flow system is similar to switches based on the flow of electricity in a network of wires, or to a network of water pipes based on control valves, or to a system of lockers within lockers controlled by a combination of multi-digit keys, or to a network of roads that lead to a destination by correctly choosing turns at each intersection. Underlying each of the above is the fact that the world is filled with random combinations of almost infinite entities, and these unique combinations create a large number of random contextual possibilities in the context of the agent, according to which the agent tries to fold the possibilities to gain order through the correct choices to reach the set goal in a series of directed steps driven and adapted by the BET. The anatomy of the BET provides static entities and relations that are incorporated into its folding, and it transforms entities and their relations into a dynamic and animated system that consumes and generates events by transforming them into connected binary entities (BETs).

[0197] Agent Effort: The efforts and contributions of all agents and teams, regardless of their hierarchical perspective, are quantifiable or measurable. These contributions, without exception, express themselves in the form of agent footprints in a solution BET or transaction BET. Rewards and organizational actions in favor of or against agents can be determined based on such objective considerations. Since every event is caused by one CU or another (causal CU), it should be properly identified. Causal CU triggering times, such as start, end, and cycle (event cycle time) are used as relevant information. An extension of this is that spatial aspects of triggering, such as where the triggering starts, where the triggering ends, and the distance covered, are also considered to be things of substantial importance. Events may also be caused by qualified agents outside the solution ecosystem. It may also be valuable to assess the cycle time between transaction BETs. Based on the context, a BET can be an input BET and an output BET. For example, if CU1 puts a pen BET in CU2, from CU2's perspective it is an input for its own triggering. From CU1's perspective it is an output BET. An event is also an event that may occur in a connected ecosystem (same transaction), or it may be an event that occurs relative to some other (related) solution flow or in a different transaction. Regardless of the perspective, the structure of BET is the same. It is a switch between potential and reality.

[0198] Multi-agent BET: Each BET is driven by an agent that acts as a catalyst for change. Agents are driven by the OSSA loop (Goal-Sense-Select-Action). In the NSL ecosystem, each layer has multiple agents associated with it that drive that layer through the OSSA loop. The multi-agent system regulates agents for each Goal-Sense-Select-Action (OSSA) loop function, and the SSA is always contextually subordinate to the goal function, and the OSSA loop applies to both the potential state and the actual state separately. For example: the test layer will be driven by the test agent whose role is specified for that layer, the knowledge layer will be driven by the knowledge agent, and the IR / DR layer will be driven by the IR / DR agent, who should have the right to de-identify information as needed in addition to having the right to see all information. Regarding the OSSA loop connected with potentiality, events occur in batch mode, distributed over different spatiotemporal instances ahead of real-time transactions. Potential OSS events in batch mode are stored through the storage action "A". All this stored information retrieved while executing transactions in real time serves as additional information to make the transaction execution more informed. Potentiality represents the intent, expectation, and anticipation in the context of the goal. Reality represents the transaction-level state of potential based on qualification criteria. In many cases, the agent executes the potential. But sometimes the potential changes based on feedback from the potential shadow, the reality shadow, and all input and output events. Potential and reality complement each other.

[0199] The world of agents and BETs: For convenience, agents divide things into unique and discrete. From the agent’s perspective, this observed uniqueness is information or entity. When dealing with entities from a solution perspective, the entity level takes the primary position. The dual nature of entities in agent contextuality is perceived entity (potential) and experienced entity (reality), which produces a binary entity (BET). In the world of agents, only agents and BETs exist. Agents perform the OSSA (Goal-Sense-Select-Action) cycle to survive. The OSSA cycle leads to a “controlled reduction of possibilities (classifications)” at each stage to move towards the desired final possibility (goal). There are external agents who are humans. There are digital agents, which are artificially created by humans to relieve themselves through solution- and transaction-level OSSA cycles. There are internal agents with the dual identities of questioning agents and answering agents. Human agents participate in it through their interactions with agents or BETs. Internal agents can represent the internal voices of Q (questioning) and A (answering) agents. These internal dual agents seem to exploit each other’s BETs. For example, consider the two halves of a wheel. If one of the parts is placed on the floor, it will swing back and forth but will not move forward. Each half represents either a "Q" or an "A" agent. The overall functionality of the wheel can only be observed if the two halves are combined. The "Q" half of the wheel leads to the "A" half of the wheel and the "A" half of the wheel leads to the "Q" half. This results in a positive feedback loop that moves the wheel forward until it reaches the destination. In other words, each turn of the wheel is like a CU until the answer is fully landed on the floor. The destination is the GSI. These internal agents have the properties of storing, processing (creating, deleting or modifying) and retrieving BETs. The senses (the ability to see, hear, smell, taste and touch) enable the agents to collect BETs from the environment. The ability to communicate and interact with other agents gives the agents the additional ability to exchange BETs. Agents collect valuable BETs from anywhere they can touch. Internal agents interact among themselves and with external human agents and further with digital agents.

[0200] Knowledge transfer in agent systems: Knowledge is the possession of the state of entities and their relations in the form of representational entities holding truth values. Knowledge transfer occurs when agents possess the same relay. The state of entities (entities and their relations) through representational entities holding truth values ​​(most commonly through spoken language such as text or voice) will be registered by the agent providing access. Knowledge is also acquired when agents seek knowledge by asking questions to agents that possess knowledge and are willing to share. There is a set of questions for uncertainty resolution of given types such as why, who, where, when, what, how, which, who, who else, and the value fractal captures all of these at the micro level itself. Questions “why” are goal seeking (effect entity) questions. Questions “who” seek the driver of the change driver CU (causal CU) or the owner of the effect CU. Questions “where” seek the location entity. Questions “when” seek the time entity. Questions “what” seek other general entities and properties involved. Questions “how” seek to trigger the CEs and their paths. Questions “which” seek the knowledge of the effect CU or the causal CU (is it CUx or CUy?). The interrogative question “who” seeks the possession status of a general entity (e.g., to whom does the pen belong). The interrogative question “who else” seeks to understand other agents who have access to information rights or decision rights (IRDR).

[0201] Knowledge and all solutions are agent-centric: Any controlled change is agent-centric. Without agents, there is no knowledge and no solutions. In the context of knowledge and solutions of agents, matter expresses itself in the form of entities and their relationships. Agents classify and define entities to transform everything they encounter from a continuous state to a discrete state. When this classification is done for all entities, including their functions, the agent is faced with a one-in-a-million situation where only one out of a million entities and their relationships are important. The million represents disorder or chaos and the one represents order. This is like finding the right combination (or equivalently, password) for a six (6) digit (xxxxxx) combination or a million possible combination locker. Having the right entities and their relationships is like having the right password. The evidence is equivalent to opening all valuable lockers with the right combination and inspecting them. The billions of knowledge components and solution components are called BETs and these BETs are the passwords for value.

[0202] Interrogative sentences define uncertainty categories and serve as a useful tool to establish certainty and order. With the help of interrogative sentences, human agents think about different possibilities while deciding on the right potential. Interrogative sentences not only help in self-reflection but also help in extracting knowledge from other cooperating agents.

[0203] BIT vs BET: In NSL, anything unique is information. Agents can identify or create unique things from their perspective. Information technology has proposed a self-serving model that uses binary digits to represent anything in the world and connects it to controlled electromagnetic forces. If there are enough 0s and 1s, all unique things in the world can be represented by these binary digits. In NSL, all unique things in the world that are important in the context of the solution can be called entities. Bits are not only able to represent entities, but also their relationships, and even relationships have uniqueness associated with them. From the perspective of information technology, since a set of bits can effectively represent an entity, the set of bits is equivalent to the entity it represents. Taking a set of bits that represents an entity and freezing these bits together will give the entity a state that maintains integrity. Once frozen together, the "set of bits" has achieved a single state. This single set has a binary nature. It can exist or not exist, but it does not allow for intermediate states. Once this equivalence between bits and entities is established, not only can solutions be quantified, but also the information about them.

[0204] "BET" is just a natural extension of the entity when it appears in the context of the solution. The solution requires first predicting the entity in the mind (potential) to match the real entity through the actuator function. This is how the entity is animated into potential and reality, at any time, only one of these two states can exist and is controlled by events. The BET model allows for counting the bits behind each BET. This can be easily implemented as a separate layer that can be created for each BET relative to the bits it consumes so that the counting of bits can also be maintained from the perspective of storage, processing and communication requirements.

[0205] Directionality: This is about moving up or down the differentiation tree based on the addition or removal of entity values. When new entity values ​​can be added, movement will be in the positive differentiation direction. By removing values, movement will be in the negative differentiation direction, that is, in the direction of "no differentiation" or "generalization" or "integration".

[0206] Quantification of solutions: Just as information is quantified as “bits” in information theory, NSL quantifies solutions by identifying the distances between entity relations. (a) Binary events: The distance between entity relations can be measured in terms of the minimum number of binary events required to get from one CES to another. For example, if entity 1 is “A”, entity 2 is “AB” and entity 3 is “ABC”, then the minimum number of binary events required to get from entity “1” to entity “3” is “2”. The principle is that differentiation, when ignored or recognized, will either lead to merging or the two entities becoming identical. NSL eliminates the difference between structure and process, and only the directionality of differentiation is important. (b) Space: Because each CES is either explicitly stated or implicit, and operates in space, it is possible to calculate how much distance has been covered. (c) Time: Because there is a stated or unstated time associated with each CES, time can potentially be assessed, and thus distance can be measured in time.

[0207] Dynamic Natural Language: The solution is prescriptive information that an action is being taken. NSL contains much more contextual information than natural language in the form of all subjects, objects, and desired transformations (verbs or action words). NSL uses the basic principle of differentiation to identify the uniqueness of each entity by attaching adjectives (attributes) to nouns (entities) and adverbs (properties) to units of variation (statements of intent or steps to achieve a purpose or goal). Therefore, NSL is equivalent to Natural Language +.

[0208] Change Unit (CU) Clock: By the nature of things in NSL, all things exist in potential or reality in a CU, more specifically, in CU components. Differentiation about CUs proceeds from the class level to many subclass levels until the transaction level is reached. It would be valuable to track the birth and death (deletion) of any entity in the solution ecosystem, and by extension, the period and age of the entity's existence. All entities coexist in time, which means that time is always part of the CES of each CU. Time can reside in a CU as a change driver (CD) in the functional layer or an information driver (ID) in the information layer, but more commonly it is treated as an implicit entity. Just as "air" is an implicit entity of humans, "time" is an implicit entity of the change unit. It does not need to be mentioned separately. At the "syntactic level", that is, as a basic solution support level that meets all situations and scenarios, the coexistence of each entity with time should be provided. At the "semantic level", the solution designer can decide whether to use this property and make "time" an implicit entity. The usefulness of keeping track of time can be extended to a wide range of things, extending from analysis all the way to inference. For example, imagine a CU with a pen and 3 other variables. Since there are four variables in the CU, it may have 16 different CES ( state). If the pen is the first to arrive, CES number 1 may go from potential to actual. The system tracks the time of that potential and when that potential is deleted or eliminated because it is replaced by "actual CES 1". When another entity arrives, that CES becomes potential and another CES say CES number 5 becomes actual. The system can also track individual entities (not just CESs) because NSL provides loosely coupled but unified entity states. When a "triggering CES" is reached, the lag time between its actual state and the expanded CES resulting from the triggering CES can also be tracked. There is always a lag time between the trigger and one or more events that result from the trigger. Having this information is very valuable to users of the solution in different contexts.

[0209] Time derivatives: One can derive the existence period of a BET in all perspectives based on its birth or death time. The start of the trigger and the end of the triggered state can be captured for each event it generates, and the elapsed time can be derived. For a CU, the proportion of time it is idle and the proportion of time it is in the triggered state can also be calculated. The proportion of time that an entity is idle (not participating in the triggered state) relative to active can be established. The correlation between "events and periods" established in different perspectives creates huge opportunities for analysis and action. The combination of time and space coordinates brings these analysis and action opportunities to another level.

[0210] Change Unit (CU) Spatial Coordinates: Both “time” and “space” are ubiquitous. All entities exist in space, regardless of which substrate they belong to. “Space” is always implicitly present in any entity, whether it is explicitly chosen or not. Just as the system provides each entity with tagged time-related attribute values ​​at the syntactic level, the system also provides each entity with tagged spatial coordinates. These can be two-dimensional or three-dimensional. Since each entity is physical and informational at the same time, their existence and interactions are associated with spatial coordinates. When an entity triggers, the changed state created by the trigger can also be expressed in terms of distance. For example, when John travels from location A to location B when the triggering state occurs, the distance can be measured in terms of the number of meters traveled. This is the same as measuring elapsed time. The attribute values ​​of space and time apply equally to machine agent functions as they do to human agent functions. Furthermore, in NSL, all entities exist in a binary state (BET). Each state change is an event. All events occur in time and space. Therefore, all entities have attached temporal and spatial attribute values ​​(timestamps) indicating “entering existence” and “leaving existence” respectively, as well as spatial coordinates. This is the same as the time of one's birth and death and the place of birth and death, respectively. This applies to potential and actual states. The end of potential is the beginning of actuality and vice versa. This rule applies to all perspectives.

[0211] Spatial distance: The distance covered when providing a solution can be derived by summing the distance covered by each CU. These distances can be calculated based on actual distances traversed or theoretically as the crow flies. These measurements can be for any CU to any CU in a connected or related CU with reference to a specific solution.

[0212] Functional distance: NSL is modeled according to a three-dimensional distributed network of nodes connected by lines, which have a directionality associated with them. NSL has the ability to normalize any type of database, making "polyglot persistence" possible. All entities reside within the nodes either potentially or actually. Each of these entities can take many incarnations in the form of "identity, language / number, image, etc." located in the corresponding substrate. Crossing from one substrate to another is allowed, provided that the principles of equivalence and truth value are maintained. Equality applies between classes, between classes and members (deductive process), and between members and classes (inductive process). All nodes are connected to each other following the nearest neighbor principle. Nodes in the same transaction are called connected nodes. All nodes in the same solution ecosystem are called related nodes. Since NSL is governed by a network of nodes, everything in the solution ecosystem is relative in nature. Just like the "cosmological principle" in science, any selected node or perspective becomes a central reference point. In other words, there is no absolute reference point, everything is relative. Since the lines connecting to the nodes have a directionality, there is usually a directionality of information flow or differentiation. The network of nodes provides all the degrees of freedom. Hierarchical models arise from specific choices about the flow of information and decisions, but they are not fundamental. In this context, any two nodes can be selected and the functional distance measured. To measure the functional distance, the number of nodes that exist between the selected nodes must be counted. This helps to judge, for example, how close the relationship between two nodes is. An example of functional distance is given in Fig.13 Indicated in.

[0213] Masking: Masking is the same as optimizing the de-identified information based on the context. It is in this context that one must approach the process of optimal ignoring or “masking” in the following way:

[0214] The basic structure of a BET is a node to which a BET is hung, and that node has a unique identity. There is a potential child node "Pen" hanging on that node. The potential pen also has a unique identity attached to it, which is generated by adding a "potentially designated" letter such as "P" to the node identity. In addition, it also has a "Pen" label attached to it. In addition, a "Pen" in the potential can have a child node "Pen" hanging on it (a member of the potential "Pen"), which has a unique id generated by the letter "R" added to the node id. It will also have a "Pen" label attached to it. The labels are natural language or number theory specific labels. For example, "Pen" is in English, which can change dynamically based on the language chosen. But the number "9" that specifies the number of pens is universal and does not change with changes in natural languages. The solution is node identity driven. Just like the "object feature", it remains the same in each language regardless of different words labeling it in different ways. It is for this reason that NSL is able to adapt to instant switching between languages. It also accommodates different human agents participating in the solution simultaneously in the language of their choice. In this context, the process of masking or ignoring information operates in the following way:

[0215] Each BET has this unique node set structure. If the label is ignored, the node and its id are retained; if the node id is ignored, only the node is retained; if the node is also ignored, only the higher-level node and its identity are retained; if the id of the higher-level node is also ignored, only the higher-level node is retained. The word "ignore" is a synonym for the word "mask". When only the node is retained, the number of nodes within the focus area can be counted; this is the same as counting the number of BETs. Following the same principle, the distance between BETs can be determined. In the case of transactions, all transaction information is ignored, including the nodes of the CU; only the GSI nodes remain to be counted. The connectivity of the nodes does not stop with the GSI. There is always ownership of the CU (individual or team); whoever owns that CU, which is called the end CU of the GSI, owns the GSI. The transaction agent keeps track of all the GSIs for which he / she is responsible. In doing so, he / she creates a node with its own identity that is a superset of the GSI nodes; all GSIs hang on this node. A supervisor who holds information and decision rights (IRDR) for a given transaction agent has a superset node that consumes all transactions of all agents reporting to that person. It is because of this process that all nodes in the solution ecosystem are interconnected from beginning to end, forming an unbroken node chain; by extension, all BETs are also interconnected.

[0216] Here are a few examples that qualify as BETs: i) Any snapshot of an ecosystem is a BET. ii) Any chosen perspective is a BET. For example, if the chosen perspective is a property of an independent entity, then it is a BET. iii) If the chosen perspective is a perspective of an independent entity without properties, then it is a BET. iv) If the chosen perspective is a CES, then the set is a BET. v) If the perspective is a GSI, then this is also a BET. vi) BETs are contextually relevant to what is important in a given situation. vii) BETs are either micro or macro, or anything in between, depending on what is relevant in the context. viii) If a BET is in the form of a CES or ECES, then the potential can contain many shades of potential and degrees of freedom. ix) If it is at a more granular level, then there may be no shades of potential. For example, the attribute value red is either present or not.

[0217] Nested SSA and Residual Information: Nested SSA exploits meaningful information and acts upon it. In some cases, a large amount of information accumulates over time, which may not find any value in the form of an SSA loop. This is called residual information, such as Fig.19 As shown. Nested thinking will be considered as any number of nested SSA layers. If information cannot be acted upon, it is in the information layer of the last layer of nested CUs. Any action emanating from the nested SSA can be added to the solution class as a CU. The addition of CUs adds more information or generates more information in the form of transactions. Residual information can be retained at each nested SSA loop level.

[0218] Normal Probability: Probability is the quantification of the likelihood of an event occurring. NSL is an entity-based model where entities can switch between potential and reality driven by events. NSL provides the ability to apply statistical methods to BETs from all perspectives. Probability is defined as the ratio of favorable outcomes to possible outcomes. It is based on observations of past events. For example, if the delivery of a product occurs in less than an hour, it can be considered favorable. Other things remaining the same, out of 1,000 instances of this product being delivered, it may occur 800 times within the specified time. Then the probability of the product being delivered next time is 80%. In NSL, all transaction classes are located in the "solution class" above. In order to calculate all probabilities, what must be done is to collect transaction information about a given solution class. In most cases, if the probability is unlikely to change significantly with each recent transaction, these calculations can be done in batch mode in NSL. The use cases for probability applications are simple and rich. For example, what is the probability that the doctor will arrive in the next hour? If the probability is 80% over, then it may be worthwhile for the patient to wait. The application of probability extends to advanced planning and optimization (APO), analytics, robotic process automation (RPA), the introduction of conditional potentiality, machine learning, etc.

[0219] Differentiation Probability: There are many variations that can be applied when calculating probabilities. Probabilities can be assigned to various perspectives of the differentiation tree. For example, how likely is it that the offender is in a particular country, state, city, or locality? What are the odds that the first event occurred in a particular LSI within a GSI? What are the odds that this alternative CU will fire first compared to some other alternative CU?

[0220] Bayesian Logic: Bayesian Logic is increasingly important in machine learning. It is about the probability of an event based on prior knowledge of conditions that may be associated with the event. This is also closely related to "conditional probability". Example: Given that A and B already exist, how likely is it that "C" will arrive? Given that A, B, and C already exist, how likely is it that "D" will arrive? This example is in Fig.15 The NSL framework provides "contextuality". That is, it stipulates that the arriving or departing entity is placed in the context of the environment in which it arrives, in the same way that existing CES or ECES are affected by the arrival or departure of the entity. In NSL, "conditionality" is nothing more than the existence of a certain state, based on which actions can be performed. Changes are propagated throughout the solution ecosystem based on the nearest neighbor principle. Given these basic properties present in NSL, Bayesian logic or "conditional probability" can be naturally processed from all perspectives.

[0221] Conditional Potentials: There are several entities in the universe of the solution ecosystem. Everything that exists in the universe is a possibility. The solution designer picks up these possibilities from the universe as potentials. Between the universe of possibilities and potentials, NSL provides the ability to create an intermediate state where possibilities can be stored as reserves and can be converted to potentials when certain conditions are met called "conditional potentials". Conditional potentials are a special class of potentials that are converted to potentials only when certain conditions are met. These potentials can exist at the level of attributes, all the way up to the level of paragraphs or even entire books, but will only be triggered when certain conditions are met. Otherwise, they are like shadow potentialities that are ignored for the purpose of determining the triggering nature. For example, a raincoat can exist in the base CU as a "conditional probability". But until a "conditional potential" becomes a "potential", it may not be considered for the purpose of triggering the base CU. For an entity to be in potential is necessary for it to become real. This is a powerful construct in NSL because the entire solution ecosystem can dynamically change its behavior based on the requirements of the environment. The flexibility this introduces ranges from attributes all the way up to the highest perspective in the solution ecosystem. The exercise of this power is subject only to the satisfaction of certain conditions and the application of the agent's information and decision-making rights.

[0222] Solution Classes: Solution Architects define classes and subclasses and create potential level paragraphs. Events arrive at the membership level and they select the appropriate class. It always starts with the formation of expectations, change drivers and agents being selected. It is important to separate entities that are in the perspective of solution logic from entities that are in the business logic. In solution logic, variables are “any LSI”, “any human agent”, “any pen”, “any paper” etc. which elaborate the principles of entity relationships. All classes have membership criteria that are either implicit or explicit. At one end, it can be just binary states like “light is there or it is not there”. At the other end, it can be “person” as a class containing any of the 7 billion people in the world as its member. In this case, the rule is that the class admits any of the 7 billion people but only one at a time.

[0223] Sub-Solution Classes: There can be any number of sub-classes between solutions before the "Transaction Class". For example, if World is a class-level entity, USA can be its sub-class, and California can be its sub-sub-class. It is important to note that sub-classes are members of classes.

[0224] Transaction Class: The transaction class is a member of the solution class. When executing a transaction, the user can choose from the different possibilities and options allowed by the solution class and these possibilities and options are in a potential state. The transaction is carried out in the transaction class. It requires that the specified transaction change driver (CD) is in place at the physical layer of the CU. For the transaction to be carried out, the "minimum member standard" should be met. For example, when the CU specifies the information of a person, if a dog arrives, the minimum standard is not met.

[0225] Differentiated Transaction Class: This is a class where transactional entities should carry more information, far beyond satisfying the "minimum membership criteria". For example, a pen that has arrived can carry additional information such as its color, its brand, its arrival time, and its arrival location.

[0226] Sub-transaction classes: As part of solution creation, the solution designer defines transaction classes without mentioning the details within them. Agents arriving at a transaction class are free to create sub-classes of transactions, called sub-transaction classes. For example, the solution designer defines a CU for writing letters, but the agent writing the letter chooses the style and content of the letter. This feature enables every transaction execution agent to become a solution designer at the transaction level. This can be achieved by using the same solution environment where information and decision rights are applied. By introducing the creation of classes within classes, NSL transforms every transaction performer and user into a “planner and designer”. This is predicted based on the fact that freedom is limited as per planning. It helps transaction level agents carve out their own destiny. One scenario is being limited by the constraints prescribed by the solution designer. In this case, one can act as per the prescribed constraints, but cannot plan and design within the scope of a higher level design in the existing solution environment. For example, what if the flexibility of planning and designing transactions is given to the transaction agent? A prescribed system level constraint could be that the transaction agent has to make 10 deliveries to any of a hundred houses in a settlement in a day. Within the available degrees of freedom, the transaction agent can use the same design system that the solution designer used for planning. A delivery to home ‘x’ can be planned in the first hour, home ‘y’ in the second hour and so on. All planning or algorithms are about stipulating meaningful constraints. While there are millions of possibilities, the agent sets some constraints based on some criteria and plans. To use an analogy, the current system is equivalent to designing the evolution of animals that can react to the environment based on sensory information. But animals cannot plan because they lack a prefrontal cortex that can perform higher-order cognitive functions. The introduction of transaction subclasses is like giving an animal a prefrontal cortex and making it human. Now here is an animal that thinks and plans. Sub-transaction classes are similar to this. It is a powerful and great way to empower people.

[0227] Minimum membership criteria: Minimum membership criteria handles class level differentiation. Membership is defined in the form of constraints attached at the class level which define the criteria for a member to arrive. When a member arrives with multiple layers of information, only the most basic relevant information is considered for admission and all other information is ignored. For example, when a passenger arrives at an airport terminal for his journey, at the check-in counter, his ticket and passport are the minimum requirements to issue him a boarding pass. At the security level, the boarding pass and baggage check are the minimum criteria for security checks. Finally, for boarding, a stamped boarding pass is the minimum criteria for boarding. There are many things that can be checked, such as driver's license Id, employee Id, phone number. However, for the purpose of each checking stage, only the minimum membership criteria are checked and other details are ignored. This example is shown in Figure 7 Indicated in.

[0228] Variability: When an entity enters a class as its member, it only meets the minimum membership criteria. For example, if a person is a member of a club, the person will be allowed to enter the club as long as he / she carries the membership card. After meeting the minimum membership criteria, each qualified member carries with him / her more information. For example, members carry with them the time of entry, gender, height, weight, skin color, and a host of other information. As the size of the transaction increases, the amount of information also increases, and this is known as data. This data can be plotted and interpreted in many ways to discern meaningful information. The variability of data or information is statistically assessed in many ways. There are methods to identify the mean, median, mode, ratio, range, variance, and standard deviation, among others. The usefulness of these in analysis and inference cannot be overemphasized. This example is in Fig.16 NSL provides the ability to perform statistical analysis at all perspectives of a BET. In addition, it exploits the connectivity of all BETs through their nearest neighbors. In addition, data visualization techniques can be better deployed using NSL.

[0229] Retained Entities and Retained CUs: Each solution created in NSL is curated and stored in a library called Dynamic Solution Dictionary (DSD). Each such solution stored in DSD and the BETs contained in the solution can be reused by any solution designer instead of recreating or redesigning the same solution again. NSL minimizes redundancy in building solution logic by providing the ability to use existing BETs in various perspectives. These reusable entities are called retained entities. If the entire CU is reusable, it is called a retained CU.

[0230] Dynamic Solution Dictionary (DSD): The DSD is a single central repository of all solutions and solution components in NSL. Every feasible solution should be maintained in the DSD with contributions from different sources. Entities from all perspectives will exist in the DSD, from the lowest level of attributes to the highest level of books or libraries. The DLD engine will be attached to this DSD so that any solution that does not exist can be instantly built and contributed to the DSD. The DLD can even self-generate GSIs and enable them through LSIs at idle time, constantly enriching the DSD. This should be based on a "point system" based on points assigned to efforts and results. This is similar to business functions guided by the principles of revenue, cost and profit based on assigned values. To be able to self-generate GSIs, the nested SSA loops will only simulate the way human agents think and operate. All solutions or their components can be visualized as available in the department store of NSL. The department store will be attached to assembly lines driven by machine agents that will instantly assemble any product that is not available in the store. Entities can exist in all perspectives with their own unique IDs. Each entity in a different perspective is like a snapshot taken from that perspective existing in a binary state. These entities are strung together through the concept of nearest neighbors. A DSD should have a dynamic user interface through which the user engages with the world of the solution.

[0231] Substrates: Any independent system with its own set of properties and rules, containing enough member entities to establish equivalence with entities in other systems is a substrate. The "rules" mentioned above are synonymous with: (a) constraints, (b) properties, (c) CUs, (d) principles, (e) potentials, (f) laws, (g) algorithms, or any other synonymous names. For example, the physical substrate has its own quality of being made up of atoms, operating in a three-dimensional world with masses associated with its entities. Similarly, the English language is a substrate made up of a specific kind of letters. Just as entities can be expressed or implied, substrates can also be expressed or implied in the solution ecosystem. All substrates and entities belong to "physical reality" and are expressed in space and time without exception. Every entity must exist in some physical form and be embedded in space and time. Since everything physical has uniqueness associated with it, it is also informational by definition. In modern physics, the boundary between the physical and informational aspects of reality has disappeared. Entities move from one substrate to another in solutions. Implied substrates refer to the fact that NSL solutions are stored in one substrate or another by default, even if it is not explicitly stated. For example, a solution designer can create a solution on the NSL platform. A solution can only be created using a user interface if the data is physically stored in the database.

[0232] Substrates as "Classes of Classes": Substrates are "classes of classes". Each substrate is a system of a large number of entities at the solution class level. The entities contained in a substrate are subject to the properties of the substrate to which they belong. That is, the constraints or rules associated with the substrate will apply to each entity in the substrate. For example, a "rock" in a physical substrate will be heavy, which is dictated by the fundamental laws related to the laws of nature's physics. The "word rock" in a natural language substrate will be governed by the laws of natural language, which are the same as natural language grammar. Just as humans have the ability to recognize many entities in their environment, they also have the ability to recognize multiple substrates.

[0233] Substrate and its properties: Substrate is the medium used for observation, recording and communication. There are various substrates available to humans. Audio / video / images are some of the well-known substrates. Each substrate will have its own set of constructions to make the truth value of the entity equal. There are some commonalities in properties when it comes to substrates. For example, all statues made of brass will have similar properties. A brass statue can represent any individual. However, the same individual can be represented by a picture or image of it. The properties of the image will again be similar. Each substrate has its own unique properties. A three-dimensional representation will be very different in composition from a two-dimensional representation. Similarly, a written text on a piece of paper representing an entity will be very different from an image representing the same entity.

[0234] Substrate Marking and Substrate Crossing: Every entity can reside in multiple substrates. Every entity is both physical and informational in nature. An entity can have multiple representations and these representations can exist in multiple substrates. Each substrate and its constituent representations carry their own properties. For example, a statue of a person has its own set of properties. It may be heavy, made of iron or brass, takes time to move from one place to another, etc. Whereas an image of a person has very different properties. It is lighter, easy to move, takes up less space, encapsulates less information, has a two-dimensional form, etc. For a solution to unfold, it needs to be defined in which form (substrate) or representation it is important to be in. Sometimes a doctor needs to perform a surgery in person. In some cases, a doctor can call for a consultation to provide a solution. When the representation changes, the substrate changes as well. Therefore, it is important that each entity and its representation and the substrate it resides in become important from a solution perspective. Representations in electromagnetic form move at a much faster pace than physical entities. Substrate Crossing and Substrate Marking can have a powerful impact on building the most effective solutions. The dynamism imparted by NSL coupled with seamless substrate marking and crossing can truly change the solution landscape and lead to a new era of breakthrough solution paths.

[0235] Equivalence Principle: Mathematical equations operate on the equivalence principle, when A=B=C=D, they are interchangeable. Similarly, many bases can have their equivalent entities in other bases or within the same base. For example, "Rama" in the physical base can have its equivalent entity "the word Rama" in the linguistic base, "the image Rama" in the image base, in the perceptual base (in the brain) as a set of "arrangements of molecules that are equivalent to Rama", in the same base as "statues of Rama", and so on. NSL treats every entity in the world (including the base) as existing in the physical world. For the same reason, it also treats every entity in the world (including its base) as equally informational, because everything unique qualifies as an entity. All entities in every base must be informational. This does not mean that all equivalent entities across bases carry the same information. In addition to cloned entities, there is information asymmetry between the same entity residing in different bases. For example, when a letter is electronically copied to 100 people. All that the equivalence principle requires is that "the minimum membership criteria (MMC) are met". MMC is looking for the minimum information necessary to satisfy the membership criteria, and any additional information is welcome but not mandatory. If by observing A in a basis, another entity in another basis or another entity in the same basis can be identified as being the same, then the equivalence requirement is met. It can be a "physical Rama" carrying bits of information, the "word Rama" carries 32 bits of information, and the "image Rama" carries The information content of equivalent entities can be different. It is accidental that truth value must be preserved when crossing across bases, following the equivalence principle. Example: When "physical Rama" is equivalent to "word Rama", truth value is preserved. When "physical Rama" is equivalent to "word Krishna", truth value is not preserved.

[0236] Bundled Substrates: Substrates are bundled together when there is a lot of affinity between them. For example, in information technology, abstraction layers are equivalent to substrates in NSL terminology. These substrates can be controlled by electromagnetic forces, information bits, symbols, databases, logical and functional layers, UI, etc. These substrates are bundled together when they have a symbiotic relationship. This bundling behavior also applies to many other groups of substrates. For example, the brain contains many substrates, including substrates that capture information, substrates that store information, substrates that process information, and so on.

[0237] Related Bases: Within a base there can be many bases that are related to each other with small changes. For example, if hard assets are a category of bases, then there are two branches within it called fixed assets and inventory. These are bases within the broad base of hard assets. Similarly, if natural languages ​​are a base, then there are 7000 natural languages ​​in the world that are its layers. Similarly, inanimate things in the world are related to living things because they all belong to the same material world.

[0238] Hierarchical Basis: There are situations where the basis is defined more broadly or more narrowly. The basis can be defined as “hard assets” or the perspective of the basis can be lowered and narrowed down to a “fixed asset” basis and a “variable asset” basis. The principles of differentiation that apply to independent entities by their attributes also apply to more differentiated basis.

[0239] Physical Continuum: The principle of physical continuum involves a basic premise that for a solution to be informational, information must be physically stored in one or another substrate, and that the SSA loop is continuously carried out. The principle of physical continuum maintains a continuous thread of information and exchange between substrates by maintaining discrete states and truth values. The principle of physical continuum processes information stored in different substrates while maintaining truth values ​​and discreteness without breaking the chain of physical continuity. Since there is a continuous transition from problem state to transition state, each state is combinatorial in nature. Moving from one state to another must also be viewed as a transition from one composite entity state to another composite entity state. NSL can store a continuum of states. Even when the entities are explicit or implicit, NSL has a model that captures all states and connects substrates. While the platform has the ability to store the minimum amount of information that is important enough to capture truth values, not all substrates carry the same amount of information. For example, a person with impaired vision can perceive more information through ears, smell, and touch. People absorb information in a variety of ways. If a person is in a dark room, then vision may not work. The SSA loop is constantly turning, and each SSA loop is a discrete unit of change. However, events that occur in reality are captured in one basis or another. There is a constant intersection of basis, which preserves truth value to accurately convey reality. The flow of energy from problem state to solution state is continuous. Therefore, SSA loops find their representational counterparts in any basis, and each of them is physically stored. The principle of physical continuum deals with information stored in different basis while preserving truth value by having enough construction to make the representations equivalent. This example is in Figure 7 Indicated in.

[0240] Symbiotic Substrates: Whether it is human or machine agency, the physical continuum that produces a solution cannot be accomplished in isolation. Seamless transitions or crossovers between substrates are necessary to maintain the physical continuum and progress toward a solution. For example, in the case of IT, the physical continuum cannot be maintained without the user interface, which is where inputs are presented to and outputs are obtained from the bundled substrates.

[0241] Labeling of substrates: All entities are embedded in a reality that coexists with “space and time”. This natural reality does not categorize things. In “nature”, everything is continuous and tends to infinity. It is the agent that creates discrete entities and categorizes them to overcome complexity. The agent has limited capabilities in sensing, selecting, and acting (performing SSA loops). Therefore, by necessity, the agent must optimize the entities it handles. As mentioned earlier, this classification can be about both the substrate and the entities embedded in it. Since the substrate and the entity are inseparable, as if they are constant partners, two sides of the same coin. Therefore, one way to deal with them is to represent each substrate as a property of the entity. Entities can be labeled with respect to the substrate to which the entity belongs. Substrates are also differentiated according to the properties of the substrate that span all entities in that substrate. For example, in a physical substrate, entities have mass or weight associated with them. They can be further differentiated according to properties that are specific to them in the context of the substrate to which they belong. Entities in a physical substrate can be solid or liquid. This labeling can be done in an automated manner to a large extent by machine agents. The degree of automation depends on the predictability or reproducibility of the properties of the substrate attributes. In cases where automation is not possible, the solution designer or user should help to accurately mark the substrate.

[0242] Substrate as Attributes: In NSL, everything is relative, that is, relative to direction, relative to what is important, relative to what is intended. When anyone looks at something in terms of an entity, its substrate becomes its subset or attribute. If anyone looks at something in terms of a substrate, then its constituent entities become its attributes. This is the same as declaring oneself to be Indian, where India is the attribute. From the perspective of “India” as a country, everything in India is its constituent part and therefore becomes its subset or attribute.

[0243] Basis Library: From the perspective of NSL, all things are informational, regardless of what basis they belong to. Entities can exist in many basis simultaneously. Examples of carrying different amounts of information regardless of basis are shown in Fig.33However, the equivalence principle and truth value should be preserved. The amount of information in each basis is different, and there will be information asymmetry. The existence of "minimum qualifying information" is sufficient to establish "entity equivalence" in different basis. For example, by looking at the "word pen", its equivalence with the "physical pen" can be established. Although the amount of information in the "physical pen" is obviously higher (because it has a large number of discrete / unique states), the few bits of information in the "word pen" are sufficient to establish its equivalence. It meets the "minimum qualifying information" standard. All basis are mental constructions of agents. They are classes of classes. For example, pen itself is a class, and it can be in the physical basis. As it happens, the "physical basis" is also a class. When the "pen class" is in the physical basis, NSL encounters the situation of "class within a class". This example is in Fig.28 Everything in information technology is ultimately handled at the representation level of the language. Additional information in the physical substrate is captured by expressing the additional information in the form of attribute values ​​attached to a "class of the physical substrate" expressed in language terms. The superset of all substrates is the "physical substrate" because nothing can fall outside the space and time where this substrate resides. The physical substrate is a superset because the information in it is maximal because all different states must be captured in it. NSL has a substrate library that focuses on i. physical substrates, ii. life form substrates, iii. language substrates, iv. image substrates, vi. metaphor / proverb / idiom substrates. Fig.29 Represents the five recognized substrates in the substrate library. The substrate library handles the following:

[0244] 1. Establish all additional information about each entity through structured attributes.

[0245] 2. Establish a process for subjecting these entities to constraints associated with their respective substrates.

[0246] 3. Establish constraints on the interactions these entities may have with other entities, either individually or in combination.

[0247] 4. Inputs for predictions that can be made and inferences that can be drawn.

[0248] 5. Make machine agents draw inferences similar to or better than human agents.

[0249] Functional Asymmetry: Functional asymmetry refers to the inability of machine agents to get enough SSA cycles. Information asymmetry refers to the inability of machine agents to get enough information. Humans can not only read the words, but also read between the lines. Reading between the lines refers to the contextual information that humans can relate to. Even in human understanding, there are asymmetries in similar lines. A nuclear scientist may be better suited to understand nuclear physics than a police officer. An experienced detective may see a crime scene much better than a chemist who may not know much about the subject. NSL embarked on a mission to eliminate the asymmetry and empower machines in unprecedented ways. This asymmetry was systematically eliminated by introducing reasoning engines and analysis engines. Machines can only read the words, but do not have the ability to read between the lines like a normal person. NSL offers unique potential to empower machines. Machines are far superior to humans in information storage, information retrieval, processing large amounts of data, and response time. If the information and functional asymmetries between humans and machines are bridged, machines can tip the scales of reasoning in their favor. Machines should be provided with purpose and prediction, just like humans. They should have a third eye to read between the lines and a sense of purpose to carry out the SSA cycle. Machines should be provided with anticipation and planning, as well as a wealth of contextual information.

[0250] The Nature of Information: Anything unique is information. Unique things that are important to the solution are called entities. In the environment of the agent, entities are acquired and converted into BETs. It helps to visualize BETs as hanging on nodes with assigned identities and labels. These BETs are loosely connected to other entities, producing CESs, and are processed by lines connecting them, through which directionality is implied or indicated. When entities are connected, the combined entities obtain a single state and have their own nodes to which they are hung. Because all unique things are entities, nodes are independent entities, representing generic entities that declare the existence of entities without any other established properties. Information, namely labels and identities, can be systematically ignored, resulting in only nodes remaining independent. If anyone can go further and even ignore the existence of nodes, only higher-level nodes will be left. When information is ignored, the system tends to create identical entities represented by numbers. Ignoring information in context leads to a concentration or condensation of information, which best and often significantly serves the agent's goals. Several synonyms have been used to convey the ignoring of information, such as "de-identifying" or "masking" information.

[0251] Information Asymmetry: NSL benefits from 400 years of progress in science. It reinterprets “the way the world works” (WWW) in the context of technological solutions. While it has not discovered anything new about “the way the world works”, it has invented a way to deal with technological solutions. One of the most important conclusions drawn by NSL is that everything in the world is physical, embedded in time and space. At the same time, everything in the world is informational, which makes the difference between physical and informational only conceptual. Going a step further, it considers time and space as entities as well, making them informational as well. All entities in the world undergo constant change driven by energy. Agents capture only those static and dynamic entities that are important to them. Agents (human and machine agents) control entities and their behavior through the directed energy they provide. This means that all “directed actions” are the same as “acting on information in a directed way”. In this world consisting of many substrates and entities embedded in them, there are realities where one of these entities may have a counterpart that carries reciprocal information. Reciprocal information is when one can observe one entity and infer information about some other entity. NSL calls these entities representational entities. These representational entities can reside in the same substrate or across different substrates. For example, a person and his statue are in the same physical substrate and can represent each other. More often, the representational entities are in different substrates. Physical Rama can be in a physical substrate, word Rama can be in a linguistic substrate, and image Rama can be in an image substrate, representing each other. The crossing from one entity representation to another in different substrates can occur by adhering to the equivalence principles established by truth values. It is these equivalence principles that maintain the maintenance of the physical continuum from the “beginning CES” to the “end CES (GSI)” in accordance with the laws of physics. If entities can have equivalent information and thus acquire the quality of being able to represent some other entity, then what among these representational entities qualifies as a real entity? The answer to this question is simple and straightforward, it is relative to the expectations of the stakeholders (GSI) and the choices made by the solution designers. There is information asymmetry between human agents and machine agents. When reading a sentence, human agents read between the lines and therefore have more information than machine agents. For example, in the sentence “elephants walk in the woods”, human agents generate much more information than machine agents. Humans imagine the size of elephants, the nature of woods, and landscapes in their own way. Similarly, there are information asymmetries between human agents. For example, when two friends meet a third mutual friend, they will come to the same conclusion about this friend. But at a more differentiated level, their views of that friend will be very different.This asymmetry between human agents can be called "between the ears asymmetry". These principles apply to information differences at the level of "vertical CU differentiation".

[0252] Dynamic User Interface: NSL provides a platform for developing solutions using natural language. NSL makes it possible to develop any solution using natural language and mathematical constructs, and it is unaware of any of the thousands of natural languages ​​used. NSL makes the solution logic transparent. In line with the vision of democratizing solutions, NSL developed a dynamic user interface (CDUI) that moves away from the old graphical user interface paradigm to an interface that accommodates dynamic text. Each solution presents itself as sentences and paragraphs. Figure 8 An example of a dynamic switch between potential and reality is represented. Furthermore, the user interface should be self-configuring, context-driven and dynamic. Dynamism and context go hand in hand. The Dynamic Solution Dictionary (DSD) dynamically adapts itself to provide distributed and secure access to the solution “BET” individually to its stakeholders (human agents). Access rights are governed by the Information and Decision Rights (IRDR) that each stakeholder has.

[0253] Solution Mining: Solutions exist in many substrates. Programming languages, videos, standard operating procedures, flow charts, images, audio files are some of the substrates that contain solutions. Solution mining refers to translation services. Solution mining helps to extract information from all substrates and translate the information into natural solution language.

[0254] Potential Entity: It is a potential class that collapses degrees of freedom in a directed manner in the context of a goal. The collapse of possibilities or degrees of freedom occurs through the SSA function loop within the specified goal. The collapse of a series of local degrees of freedom relative to the local goal continues until the global goal is achieved. This is similar to the wave-particle duality, where whether a quantum entity is a wave or a particle remains uncertain until the interaction of the quantum entity with another entity causes the wave function to collapse, and then the quantum entity reaches the state of a particle.

[0255] Reduced development by developers: Most solutions in the programming world are handled at the equivalent of the basic CU (including their embedded CU) level. The core dogma of NSL simplifies all solutions to "entities and their relationships" in the context of "agents and their purposes (desires)". Relationships are either static (CES), or dynamic (ECES). NSL treats ECES as a special class of information, eliminating the need for "processes". Each agent is an entity (with some special properties), and each purpose is a CES chosen by the agent. "CES" or "ECES" are about relationships of entities. When entities are combined, each combination is the result of loose coupling, but the single entity itself also qualifies as an entity. Therefore, all entities, including their most complex combined forms, also exist only in a binary state. This means that perspectives can change, but their basic nature as binary entities does not change. Entities of all perspectives are connected or related to each other through their nearest neighbors. For example, if Tom's friend lives 5 houses away, then Tom can go there without going through the other 4 houses. Entity relationships are contextual-coming-together-of-entities about the solution. The solution is to implement a wish, which in turn is a "selected CES". DLD automatically connects all entities in the context to a selected CES (GSI). This automatic selection of potential entities in the context of a GSI (Global Statement of Intent) follows a structured three-stage process:

[0256] a. Contextual selection of LSI (Local Statement of Intent) b. Context selection of CD (Change Drive) c. Context selection of DCD (Driver of Change).

[0257] DLD can perform contextual searches and identify the right types of contextual entities that meet the goals set by GSI. In this process, DLD stitches all the contextual entities together. DLD uses machine learning techniques to make the automated process of building solutions more efficient. The NSL framework lays the foundation for efficient creation of real-world solutions. The DLD engine uses NLP, ANN, and nearest neighbor technologies / components to process solution content. NLP technologies include named entity recognition, word disambiguation, and entity synonymization components. ANN technologies include probabilistic models, sentence encoders, and deep learning components. The DLD engine uses various permutations and combinations of probabilistic models to make predictions.

[0258] Analytical Engine and Robotic Process Automation: There can be any number of levels of nested SSA loops added to the base CU. The only requirement is that there is additional differentiated information that is worth taking action on. It is also possible to take action on partial information that is available even at a higher level. For example, if Rama brings vegetables, the nested SSA loop can place "vegetables" in the physical layer. Rama can be placed in the information layer of this nested SSA loop as "residual information". If the results of the nested SSA loops are fed to the corresponding CUs in the ecosystem in the form of analysis and insights at the information layer level, then it is equivalent to providing capabilities for the solution with the analytical engine. Alternatively, if the result of the nested SSA loop is to provide capabilities for the CU owned by the machine agent of the physical layer, then it will be related to robotic process automation (RPA). If there are no actuators involved at the physical layer, RPA will be a type of software bot that affects things in the computer substrate. If there are associated actuators, depending on their sophistication, RPA can be extended to affect objects in the "physical substrate". The analytical engine processes data using descriptive statistics and / or inferential statistics techniques. The analytical engine performs descriptive, diagnostic, predictive and / or prescriptive analysis on data (big data) by using artificial intelligence techniques, machine learning techniques, natural language processing techniques, deep learning techniques and other known techniques. Fig.15 Represents an example of an analytical engine. In addition, NSL provides a very powerful analytical engine. This is achieved by the fact that entities and CUs can be as granular as possible to process information at the very source. Embedded CUs and nested CUs provide greater granularity to consume information and generate meaningful insights. In NSL, the difference between analytical engine capabilities and RPA is very small. The analytical engine generates insights for self-consumption or dissemination across the solution ecosystem as needed. RPA is just one step away. Insights are placed in the "physical layer" to take action on them. These actions are driven by machine agents to minimize human labor and improve the quality of the solution.

[0259] Information rights and decision rights: As the name implies, information rights provide access to information about the entity in question. For example, an agent has the right to know "the presence or absence of a pen". When there are only information rights on entities, these entities are available in the information layer of the CU owned by a given agent. In case of decision rights, the agent is authorized to influence the entity. For example, in the case of "pen", the agent is authorized to use it to write or do what the solution design provides. These entities are available in the physical layer of the CU owned by a given agent. Fig. 20 Examples of information rights and decision-making rights in .

[0260] Allocation or delegation of IRDR: Solution designers can allocate or delegate IRDR to agents in the solution ecosystem. Allocation involves an agent with information rights to pass that right to other agents within the constraints set by the solution designer. Delegation is when an agent with decision rights passes that right to other agents within the constraints set by the solution designer. These constraints may involve making the allocation or delegation happen in a way that limits the number of agents in a finite time. It can even be an event-based allocation or delegation. Allocation and delegation of IRDR is Fig.21 Indicated in.

[0261] Regarding conditional potential of IRDR: Solution designers can also provide conditional potential. In a given instance, the IRDR of an agent can change in context. This will prove to be a unique feature, providing a highly versatile solution design.

[0262] Reasoning Engine: NSL identifies solutions as special classes of information, centered around differentiated classes, on which actions can be taken. The word “information” is used in the limited context of information available in the substrate of natural language. Natural language is “meaning-centric”. NSL is solution-centric. NSL is a subset of natural language because it is a special class of natural language. Natural language processes everything in the world and is neutral about whether they produce solutions or not. NSL processes only solutions. NSL selects those entities in natural language that are important for solutions (numbers and mathematics are implicit). NSL relies heavily on “information” and the “meaning it carries” because it is constantly looking for information that can be acted upon. Reasoning engines play an extremely important role in specifically portraying the correct meaning about information using tokenization methods, rule-based POS tagging methods, random POS tagging methods, Markov models, hidden Markov model methods. Information resides in a large number of substrates in context. “Physical, biological, image” are just a few of the possible substrates that people can easily identify. Each basis has its own properties, principles, and constraints according to which the basis is guided. Entities are also constrained by the properties of the basis to which they belong. The constraints and principles followed by each basis are clear. Each such basis principle is equivalent to a static differentiated class-level entity. For example, all subjects are bound by gravity. Only those subjects that meet this class-level specification are eligible to become members. The reasoning engine attaches nested SSA loops to each applicable basis in which the entity resides. All solution classes are generally equivalent to NSL entity potentials. Whenever the SSA loop is carried out at these basis levels, it checks whether the membership criteria are met. Fig.16 Represents an example of an inference engine.

[0263] Natural Solution Language-Technology Framework (NSL-TF): NSL-TF is responsible for the design and implementation of the NSL runtime environment. NSL-TF is developed using Java and Spring technologies. It consists of multiple modules designed with distributed microservices. Multiple modules present in NSL-TF are responsible for providing the ability to design all constructs present in NSL, such as entities, various types of CUs, transaction classes, retention CUs, natural language translation, etc. In NSL, general entity creation, updating entities by adding new attributes, updating entities by adding new sub-entities, updating entire entities, creating basic change units, updating basic change units, updating CUs by modifying participating items (e.g., attributes) in its layers, updating CUs by modifying layers, creating GSIs, updating GSIs, adding recursive CUs, and adding replacement CUs are done by using JSON (Java Script Object Notation) schemas and other known ways or methods. The NSL-TF architecture includes core and transactions. The core includes CU services, generic entity services, and context ID services. Transactions include trigger CU execution services and DCD execution services. In NSL-TF, the database holds all forms of information. The NSL platform provides multi-language persistence. Polyglot persistence refers to the coexistence of multiple databases to support the runtime of the solution ecosystem. For messaging and other asynchronous uses, TF uses Kafka and / or MQ (messaging queue) related technologies. For user authentication and authorization, IAM (identity and access management) technologies such as Key cloak and SpringSecurities are used. The NSL-TF architecture is operationally connected to Fig.11 Multiple modules represented in .

[0264] Animating Natural Language: This is the process that can build any solution with less than 1% of the effort compared to traditional ways. Even complex solutions can be built using NSL, paving the way for completely eliminating programming code.

[0265] Real Nature of Entities and Combined Entity States (CES): In NSL, entities are classified as independent entities or attributes. All events occur at one of these levels that change the CES, creating a loosely connected but single environment. Sometimes, there are cases where there is a local tight connection between independent entities and attributes. With this exception, when entities or attributes consume events, they do so at the independent level. The occurrence of these events is based on qualification criteria. The satisfaction of this qualification places reality in the shadow of one or more levels of reality. When independent entities come together, they create CES. Just as independent entities have their properties, CES also have their own properties and identity. The same logic applies to extended CES. All CES are like a part of a video movie composed of many frames. Interestingly, there may be CESs within CES. For simplicity, such sub-CESs are ignored because they do not change the functionality. For example, perspective is an independent entity, i.e., a pen. In an instance, a pen can have two properties, "color red" and "material plastic"; both at the master attribute level. In this case, from the perspective of the pen, the sub-CES is itself and the two properties at the master level. In another instance, a pen may have "color red" at the primary attribute level and "color dark red" at the secondary attribute level. In this case, from the perspective of the pen, the sub-CES are two attributes at two different attribute levels. In both cases, the sub-CES is considered implicit and ignored because it does not make a substantial difference to the triggering functionality of the CU. In this conceptualization, the perspectives of non-triggering CES, triggering CES, extended CES, and GSI treat all lower perspective attributes, independent entities, and CESs as their attributes. In the context of any chosen CES perspective, all subordinate attributes, independent entities, and CESs that need to be turned to a realistic state in order for the contextual CES to turn to a realistic state are considered to be contextual CES attributes.

[0266] Magic Mirror: “Animating natural language” is a powerful way to explain the true nature of NSL. Another equally powerful metaphor is to visualize NSL as a magic mirror. Over thousands of years, thousands of natural languages ​​have been tested for their ability to effectively represent everything in the real world. In a sense, natural languages ​​are mirror images of entities in the real world. One thing about a mirror is that it captures all physical images accurately. But it is only a mirror. Entities in the mirror reflect entities in the real world, and are affected by them. But for all practical purposes, mirrored entities do not affect entities in the real world. But when it comes to the magic mirror, it is another story. This magic mirror is made up of controlled electromagnetic forces. This control is obtained through many levels of abstraction in the “information technology” mirror. By combining these controlled electromagnetic forces with many levels of abstraction and natural language, NSL makes the magic mirror real.

[0267] Different levels of abstraction that make computers work: Abstraction is an old paradigm term that is the same as different levels of representation and equivalence in NSL terms. All computer logic is ultimately converted into binary code of zeros and ones. The language that directly imparts logic to the computer through binary code is called machine language, also known as machine code, object code, low-level language. There is another low-level programming called assembly language. Assembly language is designed to communicate directly with hardware. The compiler itself is a program that helps to convert any program code into machine-readable and executable code. The operating system manages all other computer application languages. Application programs make requests to the operating system through APIs. Application programs are called higher-level programs that can perform specific functions for the end user or in some cases for other applications. Although there are many types of programs / languages, the ones listed above provide a broad framework for imparting computer logic. All computer languages, except application programming languages, have been standardized to the effect that they can be integrated with the computer most of the time regardless of any type of customized application for the user, and they remain unchanged because all these standardized and low-level programs can be copied without much human effort because they have been commoditized. Applications are unique to each user need, and millions of applications are developed to meet the unique needs of users, or there are standard products based on applications that still require a lot of customization. In addition to technical hardware, application programming constitutes the majority of the expenditure generated by the world every year, reaching trillions of dollars. NSL provides a way to standardize and commoditize any type of application programming. It reduces application development efforts and increases added value. Moreover, it democratizes all applications by empowering people. This is done through several systematic steps. First, NSL replaces programming languages ​​with spoken language through its creative binary entity (BET) framework, which reduces the development time to less than 1%. Second, the NSL new paradigm seamlessly integrates itself with a rich BET library containing billions of solution BETs to meet a variety of application and solution scenarios. Third, it connects these billions of BETs with an exhaustive set of interrogative sentences and answers. The result is NSL's ability to completely eliminate the asymmetry between human agents and machine agents.

[0268] Contextuality and Conditionality: Each entity is unique and it has its own properties. In agent systems, entities are those entities that are important to the agents when they are seeking solutions. In the agent’s perspective, entities are mostly macroscopic. These entities have been composed of trillions of atoms and particles of different types. Numerous discrete / unique states help to make the properties of the entities contextually differentiated. For example, a pen has the property of being able to write, or paper has the property of being able to write on it. Agents rely on such entities to achieve their goals. For example, a person only needs an apple to satisfy hunger. In this case, trillions of discrete / unique states in the form of atoms may have come together (combined discrete / unique states) to form an apple. But if the same person needs to write a letter, the person now needs a pen and a piece of paper to write the letter. Just as “apple” produces the event “satisfy hunger”, the combination of “pen and paper” can also produce the event “writing paper”. Note that entities in the NSL paradigm operate according to the principle of the law of the excluded middle. That is, an entity is either there or not there, in a binary state. In any environment where a solution has been designed, classes are first created to facilitate the arrival of members. In the case above, the class of apples was there first (in potentiality), and then the real apple arrived. No intermediate states such as "half an apple" or "quarter of an apple" were provided. When the apple enters the class, this is considered an event that turns the "class of apples" into reality. If the apple leaves, this is also an event. The "class of apples" is now without its members, turning the situation into potentiality again. Two entities - a pen and paper - are needed to produce the desired event of writing a letter. NSL theory requires the combination of "pen and paper", and this combination itself has its own properties. Since there are two entities in the form of binary variables, the combined state can be in four different states from the perspective of the solution.

[0269] 1. The pen and paper are both potential (only the class exists).

[0270] 2. The pen arrives as a member of the class attached to the pen, so the pen is in reality and the paper is in potentiality.

[0271] 3. Another possibility is that the paper has arrived, transforming its state into reality, but the paper has not yet arrived.

[0272] 4. The fourth combination state is that both the pen and paper are in reality.

[0273] Only the fourth state has the ability to cause the expected "writing letter" event. That is, only this combination meets the conditions for generating the expected event. The other three combinations result in the generation of a "null event" (no event). The expected event and the null event of using the pen and paper entity are in Fig. 27The difference between the single entity model and the composite entity model is that events can occur individually relative to each entity present in the composite. In other words, a CES behaves like a single independent entity, but in fact it is composed of many loosely coupled entities and attributes. For all practical purposes, a CES composed of two or more entities operates as if each entity contained in it is its attribute. If you switch perspective and look at things from the perspective of a GSI, all CUs and the entities contained in them together become attributes of the GSI. All combinations are contextual and relative, i.e. one entity is relative to the other entities. But only the presence of all entities involved in the combination satisfies the "condition" for triggering an event. If there are 10 entities in a binary state, the possible combinations are (1024). But only the 1024th composite entity state satisfies the condition for triggering the desired event. This is the main difference between contextuality (CES or ECES) and conditionality. Conditionality is contextuality with a triggering nature. Incidentally, if the entities are in a "constant" state (members always exist in the class), the number of possible composite entity states decreases accordingly. If 9 out of 10 entities are "constants", there will be only two composite entity states, the 10th entity being in potentiality or reality, while all the others exist in any case. There are implicit entities whose existence is taken for granted but not stated. For example, a table and a chair can be taken as a given fact for writing a letter. With respect to "machine agents" the path of change is clearly specified so that when the conditions are met, the action is automatically performed. In the case of "human agents", when the triggering conditions are met, it is usually assumed that the performer of the role can direct the change as needed.

[0274] Latent Shadow Theorem: In NSL, a series of connected "BETs" produce a solution (wish fulfillment). BETs are connected because they are part of CES in the physical layer of the CU, or they are part of ECES (extended CES). A "BET" represents a binary entity. A "BET" switches between a latent state (in which only the class exists) and an actual state (in which the class has eligible members). This is synonymous with a "bit" (binary digit) in information theory, where a binary variable holds either "0" or "1". The number of binary entity CESs held by the physical layer of the CU is given by The formula is determined where "b" is the number of BETs in the CES. Example: If there are 6 CDs (change drives) where BETs are located in the physical layer, then CES (64 CES). Of these, only the 64th CES is realistic in terms of triggering and achieving the goal (where all CDs will be reached). An example of the potential shadow in the combination of the dual binary entity model is shown in Fig.32 middle.

[0275] Alternative CUs: CUs belonging to the same GSI ecosystem can be called connected CUs. If they affect something outside the GSI ecosystem, the affected CUs are called "related CUs". If connected CUs belong to the same paragraph, such connected CUs are called sequential CUs. These are controlled by the "AND" function. The potential shadow theorem applies to these connected CUs. But it also applies to all alternative paragraphs connected by the GSI ecosystem (generated due to the influence of the alternative CU). Alternative CUs provide alternative paths of the GSI, controlled by the "OR" function. NSL has established a process for calculating the number of paths in the context of a GSI. The potential shadow theorem can be directly applied to all existing GSI paths.

[0276] Parallel CUs: A connected CU is a CU that belongs to the same GSI ecosystem. A GSI ecosystem includes a primary GSI or a GSI that houses alternative CUs and alternative GSIs (different scenarios related to the primary GSI). For example, delivery with “cash payment” or “credit card” payment methods. The sequential CU (AND) function paves the path all the way to the GSI, and the alternative CU (OR) and the sequence connected to it lead to the same or alternative GSI. Each alternative GSI is an independent paragraph but belongs to the ecosystem of the connected GSIs. If the events generated by a CU cross the boundaries of the connected paragraphs and affect the events in other paragraphs, they are called related events. In this context, NSL evaluates the quality of “parallel CUs”. Examples of parallel CUs are in Fig.34 Shown in.

[0277] Parallel CUs have two properties: 1) The triggering of these CUs is independent of the triggering in the corresponding CU. 2) In order to achieve the GSI as a whole, all parallel CUs should have triggered as well. This is how parallel CUs are distinguished from "alternative CUs". In the case of alternative CUs, once one path is taken, the other loses its importance. But in the case of parallel CUs, the branch they belong to also persists to achieve the GSI. Parallel CUs belong to the main paragraph or alternative paragraph of the same connected GSI ecosystem. Parallel CUs are branches of the main paragraph or alternative paragraph, where they run in parallel to a given fragment of the main paragraph or alternative paragraph.

[0278] 1. Parallel CU branches: These consist of one or more CUs.

[0279] 2. Main CU path: Fragments belonging to the main section or alternative section regarding "Parallel CU Branch" are called "Main CU Path".

[0280] 3. Emanating CUs: These are the CUs from which parallel branches originate.

[0281] 4. Parallel CU branch culminating CU: These are the CUs where parallel CU branches terminate.

[0282] Example: Assume that "CU1-CU2-CU3-CU4-CU5-CU6" represents a GSI. There may be a branch originating from CU1 that has the characteristics of a "parallel CU branch" corresponding to a "main CU fragment". It may flow in the following manner.

[0283] CU1 – PCU1 – PCU2 – CU4 – CU5….

[0284] PCU stands for "Parallel CU". In this example, "CU2 and CU3" represent the main CU segment, and PCU1 and PCU2 represent the "Parallel CU" branch. The parallel CU branch starts from CU1 and ends at CU4. Fig.34 Indicated in.

[0285] Latent Shadow Theorem in the context of parallel CU branching: The standard "Latent Shadow Theorem" is as follows:

[0286] "Parallel CU branching" creates a new path with respect to the GSI. In these cases, two paths appear. One path contains the "main CU fragment" in it, and the other path contains the "parallel CU branching" in it. The "parallel CU branching" is CU1-PCU1-PCU2-CU4-CU5... In this example, the path ends at CU4. Parallel CU branching contributes additional potential shadows to the ecosystem of the GSI. The theorem for additional potential shadows is exactly the same as stated by the "potential shadow theorem". The mathematical fragment of the theorem needs to be used for each PCU and the terminating CU, just after the terminating CU.

[0287] Shadows of reality: Shadows of reality address the question of what qualifies as a member of a potential BET. If red is the potential, then only red qualifies as a member of it. But if the potential BET is an even number, there can be an infinite number of even numbers that qualify as members. In this case, the shadows of reality are infinite. Depending on the degrees of freedom in a given context, a BET can allow for an arbitrary number of shadows of reality. From a systems perspective, both potentials and shadows of reality are traditionally referred to as data. NSL provides the ability to perform analysis on data in a variety of shadows of reality using all known statistical applications, because shadows of reality have the potential to provide data at the smallest perspective, that is, at the attribute level.

[0288] Lifecycle of an Entity: Each entity in a solution ecosystem also has a lifecycle associated with it. Solution-level entities tend to live longer than transaction-level entities. Some solution components (e.g., a given CU) may last a long time compared to other solution components. Each entity (solution entity or transaction entity) will have a birth date (creation time) and a death date (deletion time) associated with it. Deleted entities can be retained in the repository, which can be decided by the designer. When an entity is modified, the old form dies (deleted) and the new form is born (created). A transaction CU lasts only until such time as the transaction is completed. Not all entities are equally active. The same applies to solution-class entities and transaction-class entities. Some entities are used extensively. If an entity participates in a triggered state, it is active, otherwise it is idle.

[0289] NSL API: The success of NSL depends largely on its ability to coexist with other solution environments. Its ability to seamlessly integrate with other solutions and solution components (such as web services) is critical to its success. NSL contributes to other solution environments and benefits from them equally. The NSL API maintains the purity of the NSL framework by using only natural language constructs in the process.

[0290] NSL Grammar: The goal of NSL grammar is to formulate basic rules or constraints or restrictions that will animate natural language for the purpose of processing solutions. NSL grammar is a type of grammar in natural language grammar. In other words, NSL grammar is about rules, or constraints or restrictions in rules, or constraints or restrictions. For example, NSL grammar should respect natural language grammar while overlaying its grammar on top of natural language grammar. Sentences formed by NSL are still grammatically correct from the perspective of natural language. NSL takes some allowed liberties within certain boundaries in order to process solutions efficiently. NSL is predicted based on the belief that natural language (combined with mathematical constructions) is also a form of code. Everyone is familiar with this from a very young age. That is why NSL uses the word “natural” when referring to these languages. Artificially created programming languages ​​are another form of code that have been dealing with the problem of “solution creation” since the beginning of information technology. However, they have created a gap between human agency and machine agency. NSL corrects this anomaly. It makes the solution completely transparent and many times valid. NSL and NSL grammar take natural language and convert the word classes into BET. By doing so, NSL animates natural language, developing solutions of any complexity in any natural language.

[0291] Turning the dial: In NSL, the team has made the switch from fat sentences to flat sentences on a solid foundation. In NSL, there is a process of doing the conversion of "fat sentences to programming languages" and "programming languages ​​to fat sentences" for all languages. NSL intends to turn the dial so that solutions can be built directly in natural languages ​​(flat sentences) and switch them to node structured networks (fat sentences). It has been confirmed that solutions based on NSL grammar will greatly speed up the process of developing solutions, and solution development is more intuitive and fun.

[0292] Asymmetry between human and digital agent interactions: Agent interactions are not limited to external agents. For all practical purposes, dual-mode internal agents also exist in NSL. One is the exploration agent inside NSL. The other is the answering agent inside NSL. NSL uses these internal dual agents quite extensively. For example, these dual agent interactions occur in batch mode in the following way:

[0293] a) Questioning Agent Ask yourself, “What shirt should I wear today?” b) Respond to the agent by saying, "Wear a white shirt."

[0294] c) The questioning agent will further ask "Is it new or old?" d) Respond to the agent by saying, “New.”

[0295] The problem may be solved just like that, or it may continue for a long time in batch mode.

[0296] Process and structure There is no fundamental difference between process and structure. They are about connected classes or constraints. Connecting more classes leads to further differentiation.

[0297] Consider the example of covering one hectare of land with tiles of equal area of ​​10,000 square meters. The tiles are numbered from 1 to 10,000. Consider tile number 4535. It is surrounded by eight tiles. The goal is to find the shortest path between the 4535th tile and the 10,000th tile. This can be achieved by repeatedly choosing the correct adjacent tile leading to the 10,000th tile. Each step taken has a previous tile connected to it and a desired next tile connected to it. The method used in this solution is called a procedure.

[0298] An alternative way to reach the 10,000th tile is to mark the starting segment. The destination tile is marked as the ending segment. The 10,000 tiles are divided into 100 segments of 100 square meters each.

[0299] In this method, the solution can be reached in 6 to 7 discrete moves by selecting the right segments. This method of obtaining the desired solution is called structured method.

[0300] In the case of a process, each step must be connected and the direction of change must be correct. In a structured approach, only the direction of movement is considered. In both cases, classification is prevalent.

[0301] In process, these classes are connected to each other on the basis of causal principles. In structure, the classes are coarser and many causal moves are considered implicit. The means to reach the destination are also ignored.

[0302] In both cases, the connectivity of the classes leads to directed differentiation, which results in solutions.

[0303] SCUBET: Our universe is made up of entities. Entities are unique and discrete. Any unique thing in a unique / discrete state can be represented in natural language, and any identical thing in a unique / discrete state can be counted and represented by a number. Therefore, discreteness is a subset of uniqueness. Consider a set of universal pens. Three colors of pens, red, blue, and green, can be considered as a subset of the superset of pens. In each color of pens, the number of pens, such as four blue pens, five red pens, and three green pens, will form a subset of red, blue, and green pens. All entities exist in space and time and interact with each other in them. If the space around the entity is considered as a cube, then the interaction of the entities within the cube produces different transformations in BET, resulting in the realization of the intention. The cube that contains space and time is called SCUBET, where S stands for space and T stands for time. Depending on the goal of the observation state and perspective, SCUBET can be divided into several smaller cubes at the nanometer and picometer levels. The SSA loop can capture each change that occurs at different levels within the cube. For example, in genome mapping, the physical distance between known DNA sequences (including genes) is calculated by the number of base pairs (AT, CG) between them. Three sets of such base pairs are mapped to one of the 20 amino acids. Such techniques are used for DNA fingerprinting. NSL SCUBET can scan a three-dimensional environment to find interactions and connections at different depth levels from nanometers to picometers; select members that are important to the solution; and act in a directed manner to fulfill the agent's wishes. NSL SCUBET reimagines the solution, embedding space and time into the solution and measuring it at the source.

[0304] SCUBET: SCUBET stands for Space Cube with Time. SCUBET is conceptualized to act as a four-dimensional CU. In NSL, CU is viewed as a two-dimensional node with interactions in a two-dimensional surface. The space and time entities in the CU are implicit because it is difficult to generate transactional value for them on an ongoing basis. Through SCUBET, NSL brings the real nature of space and time into play. According to Einstein, spacetime is a four-dimensional structure that brings together three dimensions of space and an additional dimension of time. The BET structure provides four-dimensional space cube and time (SCUBETS), which is three dimensions of space plus time, allowing to drill down to any level. The advancement of the digital world combined with the concept of the metaverse envisions the creation of a four-dimensional digital space. The metaverse layer creates a three-dimensional cube of any size, in which time is added. It can be achieved through CCTV or by tagging the space through a point cloud. For example, imagine a three-dimensional digital meter cube being held in place. This can serve as a digital representation of the four-dimensional real world. All entities that exist in these SCUBETs have digital versions of all physical entities. Agents can control changes in the four-dimensional CU. Space and time are no longer implicit, but actively participate in the creation of solutions as explicit BETs. With this model, it is possible to make solutions jump out of the 2D screen and seamlessly merge physical and digital representations. Digital representations can be real actors in the functional CU, and physical entity counterparts can be their representational counterparts. The boundary between digital and physical is blurred, as the boundary between real and representational is only contextually relevant. When the truth between physical and digital is firmly established, a world dominated by machine agents emerges. Machine agents first track changes at the higher perspective of SCUBET, and then drill down as needed. For example, if there are no changes at the meter cube level, there is no need to drill down. If changes are noticed, the machine will drill down to the decimeter cube (because there are thousands of decimeter cubes within a meter cube) to understand the true nature of the change. If changes are noticed in a specific decimeter cube, the machine can further drill down to the centimeter cube within the decimeter cube (of which there are thousands). In fact, the granularity of changes being managed can increase by a million times, providing unprecedented opportunities to draw inferences and guide actions.

[0305] BET creation and operation: The creation and operation of BET are important. For example, if the switch is on, then it is a real BET. If the switch is off, then it is a potential BET. BET creation includes BET connection. These conditions lead to one or more events and can be called creating a solution level BET at a centralized level, for example, a central switching station for an apartment. Each connection is an event. The NSL environment has BET creation and BET operation. BET operation is based on reality. This is within the potential flow. The potential flow consists of solution maintenance, operation, and planning.

[0306] Operational BET is part of solution BET. The type of solution depends on the type of species. There can be more or fewer transactions. If things remain the same, then the maximum number of transactions can be generated. These are valuable transactions. Stakeholders benefit from them and will return. This is the source of revenue and profit. The costs associated with the solution flow are absorbed by these transactions and generate revenue. There can be opportunities to reduce fixed costs and increase revenue and profit.

[0307] Solutions can be developed without creating new BETs. If anyone creates new BETs, the cycle time and cost of creation is more. In an NSL environment, each transaction is considered a BET. Solution BETs should be considered. Transactions create value. BETs are interdependent. For example, the benefits of a BET can be considered without missing something. If something in the sense of value could be missed, then the BET seller would not consider these BETs. Accounts can be balanced from a value perspective. Existing transactions can be identified with reference to value rather than with reference to BETs. These identified transactions make the BET complete.

[0308] If you can’t see BETs, it doesn’t mean they don’t exist. Things can be predicted about BETs based on available information or research into the past. As long as the expectations are well-founded, the principles are well understood. The process can be handled for machine agents.

[0309] BET is in binary state. For perspective, attributes are at the last level. At the lowest level, it is in binary state. One can move the perspective upward to CES which is composed of many BETs. Many of these loosely coupled BETs transform themselves into reality state. CES should be in reality state. There are a large number of potential shadows that must be crossed. NSL system is mainly based on CU-based conditions or conditions at GSI level. At higher perspective, regional points are driven by aggregation. This is connected by nearest neighbors. Connection starts at attribute level and entity level. CU triggers first, then aggregates. Aggregation arises from differentiation being systematically de-identified. New information appears in the form of potential or reality. If it can be systematically identified, the nearest neighbors will become the same. Systematic things are de-identified, and the same things are represented by numbers.

[0310] Words are abstractions and representations of unique characters. Numbers are representations of the same characters. It is important to systematically identify information from the agent's perspective. Aggregates can be generated and information can be identified. Once the GSI is completed, the transaction is complete. A master node that is in a realistic state and has no information can be identified. Any information counts as completing one transaction. If thousands of transactions are completed, they can be counted as thousands of transactions.

[0311] Aggregates come under BET and can be individual or collective. Aggregates are represented in attributes. Attribute quality is no different. It includes the color of a physical object. The colors replaced with digital aggregates are equivalent to less than 100, 200, and 300. The set is equivalent to attribute trim. A given string of colors leads to reality. This information is valuable. It generates insights and actions.

[0312] It is possible to have different differentiations for a given property. A collection is made up of aggregates, and has its own properties. An aggregate hanging on a given class is the same as a gate hanging on some BET as a value. It cannot be separated out. Assume there is an entity, with aggregates at a minimum. This means don't show an aggregate as a property.

[0313] There is a cycle time associated with BET. Every thing is in a binary state, except it is a constant. BET is a move to reality or reality to potentiality, an event is necessary. Events are output. The trigger state from the previous has properties like cycle time. These things take minutes and hours. It is driven by machine agents and takes only seconds. The goal is to maximize the amount of BET driven by machine agents. Effort is minimized and net value is maximized. Cost is low and realized value is high.

[0314] Cycle time is connected to BET. The expectation of cycle time is called budget. For example, it can be expected that this will be completed in 5 minutes, but it took 7 minutes, which is reality. The ideal time is at the solution level and the transaction level. The solution is at the higher perspective. For example, every transaction starts with a class at the country level and then goes down to states, cities, streets and houses. The house level is where the transaction takes place. The higher level perspective and transactions are foundational. There are composite entity states. For example, there can be state, city and street levels. Agents have roles and can branch off of them.

[0315] Higher view BETs as a string of lower view BETs: Higher view BETs are very valuable, these BETs open the door to any new solution. If the lowest view is an image, the higher view is like a video composed of many lower view frames. These frames are like attributes of independent entities.

[0316] BET creates value channels at all perspectives: In a similar way that value channels exist at every cellular level and organ level, nature is full of BETs, which are affected by energy and create random channels of change. One of the millions of channels will eventually deliver value to the agent. The agent tries to control these channels of change to obtain value for itself.

[0317] Each BET has a natural language layer and a programming language layer: Each of these BETs has a sub-layer for a specific language. Each BET has a bundle of programming language codes, one of which syntactically specifies the node structure and the other semantically fills in the node placeholders to complete the logic flow.

[0318] Each BET is a fractal of value streams: the BET structure is differentiated by the relationships it establishes with other BETs. Depending on the nature of the relationships, the structure of a BET is a sequential, alternative, parallel, embedded, nested BET, or the BET belongs to different perspectives, such as CU, GSI, and different superordinate levels. Each of these BETs is marked with its unique properties (the way they interact) that are appropriately provided for it. Likewise, each BET can have any number of layers and sub-layers (some sub-layers have been identified as IRDR, ML, blockchain, etc.). The BETs in these layers have relationships with the main BET to which they belong and with other BETs in the layer to which they belong as the context requires. Each BET in each layer has its own properties. All BETs in the layer together have collective properties. Some of these layers are labeled together as functional layers, UI, and IRDR. Concept groups are new technologies, supporting functions, and representations (natural languages, programming languages, and images). When a framework is provided for all identified layers and sub-layers, most layers can be closed if the situation does not warrant their presence. By the way, speech as a layer can be attached to BET immediately without much effort, because it is the decision of NSL, and word classes are also BETs. All CES and ECES are just composites of these word classes or individual BETs. The speech is taken from the dictionary with the pronunciation of each word and attached as a layer to each BET. It is enough to do this for attributes and independent entities. The rest are also composites of these word classes or individual BETs. All millions of BETs in the BET library have their speech counterparts. If there is a mandatory layer connected to the selected main layer, the trigger will only occur when all BETs in the mandatory layer become realistic. In other words, all entities in the mandatory layer operate in real time. All other activation layers, such as machine learning, will operate in batch mode. These layers will generate additional insights when the set conditions are met and the specified events occur. These insights can be used as additional information when they are pushed to qualified agents for use as needed, or sometimes, these insights automatically provide additional value.

[0319] BET fractals simulate neurons: DCDs (drivers of change drivers) are like neuron cells in the body. Change pathways that affect one or more CUs are like exons. Events that end up in another CU are like synapses. The potential states of BETs in other CUs are like dendrites, which connect to synapses of connected neurons, which fire when action potentials accumulate in them.

[0320] In solution design, if transactions occur at the house level, then regions and spaces are at a lower perspective. This applies to time and people. From a language perspective, the BET at the transaction level becomes a bit. For example, people to people, time to time. When these things are combined, the differentiation is huge. As far as space and time are concerned, they are never replicated together. Space and time exist in the life cycle of the universe. For example, a person is in a certain place at a specific time because time is always flowing. There can be no other "same" time and space. Each thing becomes different when it can be combined with other loosely coupled entities.

[0321] Things can be defined with degrees of freedom from country level to street level. There is a lowest level of freedom. For example, a house is a binary entity with classes adopted in it. House is in front and room is in back. There is a degree of freedom with branches, in a binary state. The system works within a range. If a subclass shows an error, the system sets itself for the new transaction. These are called allowed values. They can reach the implicit subclass and are qualified values.

[0322] If the chain of BET and value is not broken, the transaction is settled and moved to the past. Now it is a construction of the solution designer. The NSL environment introduces past and future time. If it is at the day level, then it is yesterday and tomorrow. In the solution BET, cycle time is involved. Transactional bits and cycle time can be analyzed. The cycle time between two transactions can be observed. For example, if the first transaction occurs at 10:00 hours and the second transaction occurs at 10:30 hours, the cycle time is half an hour. There is a given variance to capture its statistical level. With ideal time evaluation, BET is driven by tasks and human agents. For example, a person buys a pen instead of making it. At the GSI level, BET is accounted for and value is accounted for.

[0323] Clarity is built on the normalization processes of grandreconciliation. Each person wears the consumer hat of value creation. Human agents consume tasks. Value agents generate outputs. From the perspective of perspective, with inputs and outputs, it is possible to understand how the system works. For example, a person is an agent wearing the hat of receiving inputs. Agents are divided into two personalities - value consumption and value generation. A person can give his / her output to someone in the next scenario. A person has generated CU value and the structure is complete.

[0324] Functional layers generate events like the ones that trigger CES. A change in state means a change in effect. There is a difference. They generate null events and signal events. For example, whenever the state changes from 1, it does not always move to 2. When it moves to 1.1, another state moves in the rounding direction of the system.

[0325] Events happen at the functional layer. In the presentation and measurement layers, communication happens between the two. Information can be filtered, whether it is at the functional, information, or UX layer. For example, in prepared food, people can process the ingredients and then serve them to satisfy their hunger.

[0326] BET has three relationships. 1) The first relationship is equivalence. For example, ordering food and drinking water. 2) The second relationship is dependent coexistence. In CU, if A, B, C, and D entities are gathered together, they all coexist in this context. 3) The third relationship arises from interaction. Here, the nature determines the nature of the interaction. All potentials are realized according to the decision. Each switch in potential is a class. In the optimal solution, the last BET has been fully determined and forms a complete solution. The three relationships are as follows:

[0327] a. Equivalence relations: Agents have evolved to exploit established correlations between entities. There is merit in establishing equivalence between a person, a person's name, and an image of a person. Each of these related entities has properties that establish equivalence. This means that an entity can be referenced by examining the related entity. For example, if one asks who John is, only one person out of 100 will be accurately selected. Similarly, if one asks what a particular person's name is, only one name that reads John will be selected out of the 100 names displayed. Furthermore, entities that represent each other can have their own properties that are independent of the properties that establish equivalence. For example, there can be a related entity, John, a living person, and a statue of John. John has his own properties, such as his own weight, and he is made up of 100 trillion cells. The statue of John has its own properties, such as its own weight, shape, and size. All related entities are physical. Nothing can escape the fact that everything must exist in space and time, and that everything is made up of particles. While John has trillions of atoms that make him up, the name John written on a piece of paper will have billions of particles associated with the ink, which are also physical. Real entities are defined in context based on what is important to the CES placed in a given CU.

[0328] b. Coexistence relations: These are non-triggering CESs in the context of a defined CU.

[0329] c. Function (Extended Coexistence or Extended CES): Relationships arise from triggering CESs, leading to changes in CESs in one or more CUs (including itself). Entities or CESs that lead to other entities or CESs are also called functions. In spoken language, these are equivalent to verbs.

[0330] BETs are always in a binary state, whether they reside in attributes, entities, composite entity states (CES), or extended composite entity states (ECES). The solution flow includes the creation of solutions, maintenance of solutions, and operational planning. All BETs reside in the same flow, and when one class is added with another, more classes are brought together. A class is a choice of many or fewer possibilities. As things are continuously added, algorithms can be created. Solution events are operational and transactional events.

[0331] If we start from a higher CU perspective, there can be many branches of CU operating at different levels. Agents perform various tasks and are embedded in CU. At the transaction level, information can be identified based on different things. It is equally important to identify information or ignore it. The same things are represented differently by numbers, while unique things are represented by words, so each transaction becomes unique.

[0332] At the solution ecosystem level, things can be viewed from the perspective of the organization. The environment can be measured both inside and outside the organization. Therefore, any entity that enters the environment is considered an input. A profit and loss account statement can be generated by taking all the inputs from the external environment. For example, if a pen comes from the external environment, it is counted as an external input, and it is classified as a consumable. If a machine is purchased, it is considered an external input and goes into the category as an input. If the organization purchases a software license, it falls into the same category.

[0333] Constants, variables can be quantified and each transaction should be contextual. Questions cannot be asked out of context. Each transaction is context-driven, with a nested approach. BET is distributed across different functions and collectively expresses itself at the solution level. BET captures knowledge at the solution and transaction flow level.

[0334] Enterprise-level solutions can be handled both horizontally and vertically. Sequences that exist between environments can be established. Many intelligent systems can currently be made in the NSL environment, such as chatbots, analytics, and so on. Many functions can be handed over to machine agents. People must have bold vision to operate. If a person has a clear mind, then he / she can create a logical extension of the functionality to reach the destination. All interactions take place inside the MCC. Every time it is triggered, the BET changes its state. In the NSL environment, the MCC is customized to meet the needs of every internal and external stakeholder in the web and mobile environment. Based on IRDR, all interactions take place securely in a transparent and contextual manner.

[0335] NSL is integrated with accounting through the established accounting system. The paradigm has BET and value. Accounting combines these two disciplines together. BET can be considered in the solution or transaction flow. BET is value and is attached to the value. From the perspective of currency, the value is attached to the medium of exchange. Rupees or dollars can be attached to the medium of exchange.

[0336] A search engine on reference idiosyncrasies can be applied. In an NSL environment, language is the idiosyncrasy. The NSL environment dictates where additional information may reside and the properties driven by it. Everything must be converted to a reference frame base, which is a natural language base. The judgment is made based on the additional information.

[0337] The blockchain layer is connected to a given CU. Each CU has its own footprint. The owner is an individual or a team. If it is between CUs, teams like deliverymen, supervisors and managers connect CUs with different perspectives. In all cases, the footprints of teams and agents are machine-recognized with timestamps. These are solutions or transactions BET. Inside the organization, each thing is connected to CUs and agents with each other. If a given set of CUs is not called, no value is passed. These occasions are not limited to those CUs that face external stakeholders directly. The blockchain connects each CU with NFT. For each standard, there is a shadow blockchain system. At the operational level, the blockchain considers each secure and distributed thing. In the NSL environment, cryptocurrencies can be created and tokens can be allocated. These tokens can be directly exchanged for rewards and have monetary value attached. Tokens are secured in such a way that if the standard work is completed, then several tokens can be issued.

[0338] In the context of an agent, some unique, discrete states have significant value. Some of these states are formed from the perspective of evidence and proof. Information is built on the basis of evidence called knowledge. It can be linked to basic science. The structures used to capture BET are built at the basic science level.

[0339] The next level is from the knowledge level to the concept level. The concept level is invention and creation. It comes from finding some creative and effective applications and promoting them to the prototype level, which is equivalent to NSL.

[0340] Solution BET hangs on Concept BET. Concept BET hangs on Knowledge BET. Concept BET is a superset of Solution BET. Solution BET is a superset of Transaction BET. Between Concept, Solution and Transaction BET, everything is covered. Any action that leads to revenue is solved and the machine agent understands it. It can make agreements. Every BET is coupled with a value expressed in financial or monetary value. Value and BET are tightly coupled. Value represents weightage. For example, there are two BETs. One is Car BET and the other is Pen BET. Car BET has a weightage of Rs 10 lakh and Pen BET has a weightage of Rs 100.

[0341] In this century, the opportunity to create value revolves around knowledge. Tracking transactions is knowledge. The focus is on understanding its meaning in a way that the machine agent fully understands it by doing all the necessary things. The conceptual framework drives it through controlled and programmed forces. To capture knowledge BET has provided the world with access to extended knowledge through scientific papers in the public domain in a time-tested way. The solution has been provided by the nature called life. One can capture all the knowledge that exists in scientific papers. The system automatically generates alternative paths. Each correct path is equivalent to knowledge that passes the test of five potential answers, one of which is correct. It follows the core and essential things among many possibilities, only one or a few are correct.

[0342] Contextuality of BET: NSL applies contextuality to BET in a similar way to contextually determining the type of CU. In NSL, the attributes themselves are contextual. For example, red is an attribute of a pen. However, it can even be the case that red is an independent entity and it can be represented as an attribute in the form of a pen or a pencil. Similarly, independent entities, i.e., a pen, a paper, and a person, can produce a composite entity state (CES), which itself has its independent shape. All independent entities in this CES operate in the context as if they were attributes of the CES.

[0343] Contextuality of potential and reality in BETs: In the context of a solution, potential BETs are those BETs that are important to the solution; reality is about things being achieved. If the context is knowledge acquisition, the nature of the BETs changes accordingly. Here, potential becomes a knowledge BET supported by evidence (such as knowing that the sky is blue). Reality status is achieved when the specified agent correctly understands (or records) the true nature of the BET in the human mind. For example, if the agent thinks that the color of the sky is brown, the membership criterion is not met; if the agent correctly records it as blue, the membership criterion is met and the understood reality is established. The binary contextual interpretation of potential and reality can be extended to all layers of the CU, including the machine learning (ML) layer. If the human agent expects a pen based on the given background information, the system considers it potential. If the machine agent also correctly expects it, the potential pen achieves the actual status.

[0344] A Combined Entity State (CES) is always contextual. The coexistence of entities in the solution environment is always contextually related to what the agent is looking for. The agent is looking for a change that is contextually related to its desired context. This change occurs when the conditions for that change are met in the form of a desired Combined Entity State (CES), where all entities are in the actual state. It can also be called a triggered state. When there is only one binary entity and it is already in the potential state, there is only one degree of freedom within the BET. This is the base level relationship between potential and actual. If there is a CES consisting of 4 BETs, the number of states is , i.e. 16. The 16th state in which all entities are in the actual state is the CES actual state. All other combinations, 16-1 (CES actual state), i.e. 15, are collectively potential states. Since there are potentials that exist in different states starting from the base level potential in which all BETs are in potential, each of these potential states can be called a shadow of potential. BETs can allow any number of potential shadows, depending on the degree of freedom in a given context. The arrival or departure of an independent entity or attribute causes an event. Each causal event should cause an effect event. In a CU, there are several BETs. Each causal event causes an effect event at the CES level of the CU, resulting in a transfer of the potential shadow. If the CES state transfer is a causal event, the causal CES event produces an effect event that can be called a null event in the case of a non-triggered CES. Just like "0" (zero) is a number, any number in the digital system represents nothingness. From a solution point of view, a null event produces an event called nothingness. When a trigger occurs, it causes a combinatorial expansion in the ecosystem of the connected CU.

[0345] The world is filled with several possibilities in terms of entities and their functions. In this almost infinite set, a limited set of entities and functions are of substantial importance to the agent because they satisfy their expectations or goals. For all these almost infinite possibilities, the agent has neither the processing power nor the energy to take action on what is processed. The agent performs the sensing, selection, and action (SSA) function only on the entities and functions that are important. For example, imagine a combination locker in which there are six decimal numbers. This creates possibilities starting from 000000 combinations and going all the way to 999999. Assume that only 999999 combinations are important to a person. The remaining 999999-1 (i.e. 999998) combinations represent chaos, and only one combination number represents order. 999999 is like the password to open the locker that fulfills the wish. Only human agents, machine agents (guided by human agents), and natural agents guided by billions of years of evolutionary processes can overcome this randomness that is prevalent in nature. Independent entities and attributes are like separate numbers in this combination locker. CU represents the locker waiting for the right combination. Each BET is like a binary digit instead of a decimal digit. The connected CUs are like lockers in a locker, leading all the way to the innermost locker, which is the GSI. These combined lockers have different sizes. For example, some lockers have three binary digits, while others have eight binary digits. NSL simplifies all solutions to the desired entities and their relationships.

[0346] An event is any change that occurs in the solution ecosystem: An event is related to changes in the ecosystem that result from the creation or deletion of a BET. The creation and / or deletion of a BET is related to either a solution BET or a transaction BET. Events are also related to transaction BET operations. These operations result in changes in the potential shadow or the actual shadow. There are some cases where the output at the GSI level may become an input constant for every transaction that depends on it. For example, testbed preparation goes through a solution creation phase and an operation phase, which results in a testbed. Once the testbed is prepared, it becomes a constant for many transaction BETs related to the testbed operation. This essentially means that one can use that testbed. These scenarios are also encountered in the manufacturing of machines. Once a machine is produced by the GSI, it becomes a constant across transactions. Solution BETs are direction setters. Transaction BETs are those BETs whose directions are specific to qualified transaction agents. Transaction agents are further narrowed down to the class that fits their situation. For example, if the solution class specifies home delivery, the delivery person can stipulate on his own that he only delivers in the living room. The transaction agent can act freely because he / she does not step out of the home class. He / she simply created a subclass called Living Room within the Home class. This does not cause any conflicts, because the operations are within the specified boundaries. Instead, the operations are purely those that result in potential or actual shadows of the event changes allowed.

[0347] Two Worlds Hypothesis: Human agents live in two worlds simultaneously. The two worlds are 1. the perceived world and 2. the real world.

[0348] 1. Perceived World: This world operates in batch mode. In this world, entities and their relationships occur independently of time in a time-invariant manner. The boundaries between the past, present, and future can be easily crossed. For example, human agents can pick up entities and their relationships from the past, transpose them relative to present entities, and anticipate future entities.

[0349] 2. Real world: This world operates in real time. Everything is experienced only in the present moment. Entities and their relationships are here and now. The body as an actuator acts only in this world.

[0350] Commonalities and dependencies of two-world systems: The OSSA loop is common in both worlds. Actuation in the perceived world occurs through representational entity storage and retrieval. In the real world, the transformation of entities is affected by body actions. Both worlds are mediated by the brain. There is a seamless exchange of entities belonging to both worlds to overcome disorder in the world and bring order aimed at achieving the goals of human agency. The potential states in BET belong to the perceived world and the actual states belong to the real world. The emergence of binary entities (BET) stems from the "two worlds hypothesis".

[0351] Transformation and conversion: Transition: Changes within a CU are often called transitions. For example, a pen is delivered from a store to a leader. In this type of change, entities change their relationship to space, time, and other entities. Incidentally, it is important to mention that space and time are also entities. A special quality of time is that it is constantly changing. The measuring tool of time is rhythmic. Given this intrinsic quality of time, even if the pen stays in the same place, one can talk about its existence using tenses - past, present, and future. For example, the pen "was there", "is there", or "will be there".

[0352] Transformations: Transformations may occur when an existing entity is created, deleted, or modified. When a letter is written, the blank sheet is deleted and a written letter is created. All modifications involve the deletion of an entity and the creation of another entity. When an entity's path transforms itself into something else, that state is preserved in the system and recording that fact gives the modification as a separate state.

[0353] Implementation of solutions: Solutions can only be implemented at the transaction level involving transactional agents. This is based on the fact that all solutions require directed changes mediated by agents and through the interaction of identified entities called triggering CES. In all cases, space and time are also involved, either implicitly or explicitly. This proceeds from the fact that any change stems from the principle of cause and effect. In this respect, transactional agents and action agents are usually the same. Transactions create more fine-grained transaction classes, which are required to perform operations in order to create transaction potentials. The operations execute transaction potentials. Transaction potentials are considered transaction classes. Transaction classes become reality as transactions.

[0354] All representational entities have their own properties: one of these properties is the property of establishing equivalence resulting from natural associations (such as sunrise and daylight) or artificially prescribed associations (such as language associating the word pen with a fountain pen). All representational entities occupy their own space and time. All representational entities have their own physical properties. For example, a person is made up of trillions of cells, which in turn are made up of trillions of atoms. A representation of a person, such as the name John, is itself made up of billions of atoms, forming a pattern on a piece of paper. Such representational entities have their own unique properties, such as being erasable when written in pencil. Among the representational entities with equivalent properties, there is only one real entity determined by the context.

[0355] Levels of Representation or Representation of Representation or Extended Representation: Every entity can have one or more representations, e.g., a person, a name, an image, etc. Reality is represented through representations that human agents rely heavily on. This is the same as A equals B, B equals C, C equals D. By extension, A equals D. “A” in many cases requires a transformation of representation to establish equality with D. One of the real world examples is light reflecting off a rock creating a representational counterpart of light reflecting off a rock in the retina of the eye in the form of photoreceptors. Several other brain level representational transformations occur before the brain records the image as an extended representation in some molecular form. Representation of representation or extended representation is an effective representational tool used by human agents in context.

[0356] Representation and abstraction levels in NSL: The levels of abstraction are stacked along these lines: Two distinguishable states are produced by controlled electromagnetic forces through different voltages or through magnetized or demagnetized areas. These abstract states are labeled as 0 or 1 and are called bits. Once tied to electromagnetic forces, bits acquire the magical properties of propagating at the speed of light or performing billions of functions in a second. A group of 8 bits is a byte. Bytes represent letters, numbers or symbols. There is another accompanying supporting, standardized and commoditized abstraction like assembly language, compilers and operating systems. The NSL Solution Operating System (NSOS) takes sets of bytes and peers these with NSL constructs. These abstractions are contextually connected to higher level abstractions in the form of millions of BETs in NSL Digital Mind (NSL BET Library). NSL Digital Mind acquires the status of a full-fledged agent, ready to execute the OSSA cycle. The asymmetry between human and digital agents is completely eliminated. Interactions between human and digital agents can happen seamlessly, just like interactions between friends in the real world. Following the exhaustive approach, solutions can be implemented through interactive QA (Question and Answer) sessions between stakeholders seeking solutions and representatives of NSL Digital Mind. A higher level of abstraction in the form of standardized QAs is added on top of digital thinking to establish human-like interactions with digital agents. Each QA couplet gradually exhausts uncertainty as it descends to a plateau of solution. The millions and billions of connected BETs in NSL digital thinking are analogous to a network of roads. Each BET is like an intersection or a destination point (like a house). The lines connecting BETs are like roads that follow the nearest neighbor principle. Whenever a goal is born (like the desire to go to a destination), uncertainty around achieving the goal is born. A series of QAs between informed agents determine the potential for routes to achieve the goal or reach the destination. QAs are BETs separated by higher level BETs like highways, main roads, and side roads. CU-based BETs are like the inner roads and intersections closest to the destination or the destination itself. Imagining a well-directed question itself helps reduce uncertainty. “Q” is like a choice at a crossroads of questions where one has to choose from why, who, where, when, what, how, and which. By choosing any of these questions, uncertainty is reduced to a finite degree. For example, if the option is “who”, all other options are eliminated. If the answer to “who” is “John”, then the two classes are combined into a CES, i.e. “John the Person”. The QA pair is repeated until the BETs contributing to the solution are fully rooted in the CU.

[0357] Methodology for developing solutions: The interaction between the digital agent and stakeholders disambiguated all solutions in less than a few hours. This process can also be described as following an approach of exhausting uncertainty through QA pairs, descending from contextual uncertainty to solution certainty. Relatively limited QA, ultimately through voice, will place stakeholders at the closest BET. Last mile disambiguation should not exceed a limited set of QA to resolve the problem. When there is more than one contender as the ideal BET in the NSL digital mindset, a rating system can be introduced to guide the stakeholder’s choice.

[0358] Each word class is a BET: word classes are distributed across layers in the context. Incidentally, each interrogative word, such as what and why, is a class that defines a different type of uncertainty and acts as a bridge to resolve uncertainty in the context.

[0359] Standardized Solution Development Environment NSL Solution Operating System (NSOS): The old paradigm operating system can be called a technical operating system. In this new paradigm, the NSL runtime environment is integrated with the NSL BET library that holds millions of BETs. These BETs are modeled on colloquial languages ​​that will provide all imaginable scenarios and degrees of freedom around any solution development. This leads to NSOS and standardization and commoditization like a technical operating system.

[0360] The power of natural or spoken language is staggering: language as a representational system is deeply tied to the principles of how the world works. The basic structure of thousands of spoken languages ​​remains the same. English divides sentences into four types: prescriptive, descriptive (informative), interrogative, and exclamatory. NSL also uses interrogative sentences to complete the full circle of spoken language, making NSL an effective representational system. NSL is accomplished through the development of standardized solutions using the NSL Solution Operating System (NSOS), which sits on top of the Technology Operating System (TOS) and (potentially) billions of BETs are placed on NSOS. NSL paves the way for the democratization and commoditization of solutions by activating interrogative sentences. By doing so, NSL can implement any solution of any complexity in a matter of hours through agent-to-agent interaction. In the process, the asymmetry between human and machine agents is also eliminated. All solution needs are addressed through agent interaction of question-answer pairs.

[0361] Agent interaction disambiguates solutions: In NSL, controlled electromagnetic forces are directly connected to the structured spoken word classes of NSL grammar. NSOS is a composite of NSL constructs based on principles of how the world works. These NSOS constructs are classes of classes, known as BETs. By attaching a library of BETs to NSOS, a digital mind is created that simulates the human mind and has a million times more solutions BETs in it. By creating an NSL digital mind, a digital agent is created, which can interact with human agents on an equal footing. All asymmetries between human and digital agents are eliminated. It is almost a fact that all solutions of human agents are obtained through internal agent (QA agent) interactions or external agent interactions (including stored and documented knowledge about external agents). Similarly, all technical solution determinations can be fully completed in a few hours through interactions between stakeholder agents and digital agents. No other intervention is required.

[0362] Human agents are controllers of electromagnetic forces to meet their ultimate goals: evolution has influenced the development of the human phenotype. Digital agents also control electromagnetic forces to meet their ultimate goals artificially created by human agents. In both human and digital agents, there are efficient agents and inefficient agents relative to the context of the goals.

[0363] Words and Numbers in NSL: Both information and solutions are related to the context of the agent. Entities are creations of the agent through a classification process. Language representations are classes perceived by the agent. As we all know, spoken language represents entities in the real world. There are four types of sentences: prescriptive, descriptive, interrogative, and exclamatory. For convenience, descriptive sentences are considered informative sentences. Incidentally, NSL eliminates the need for any new technology-based solution development by standardizing processes that were originally handled through high-level programming languages. It is a seamless combination of the NSL runtime with the extensive BET library, and this combination is called the NSL Solution Operating System (NSOS). In this changed context, the operating system in the old paradigm should be called the Technology Operating System (TOS). Just as assembly languages, compilers, and TOS were standardized and commoditized in the old paradigm, NSL did so in a similar way to high-level programming languages: standardizing and commoditizing high-level programming languages ​​through NSOS. This technology is implemented in the new paradigm of NSL by calling the third type of sentence - interrogative sentences. NSL takes over the functionality of high-level programming languages ​​and hands it over to interrogative sentences. This approach is called the Solution Development Interactive Question and Answer Method (SD IQAM). A continuous interaction takes place between the internal question-answer dual voice, supplemented by interaction with external people (whether friends, enemies or experts, who are or have been speaking through text or voice) until a satisfactory solution to the problem is found. Through the Interactive Question-Answering Method (IQAM), NSL brings digital agents to the same footing and permanently solves the alienation of human agents from machine agents. NSL makes it possible for any stakeholder seeking any digital agent-assisted solution to come face to face with an NSL digital agent, with a structure assisted by a question-answering repository and an interactive question-answering session (IQAS), which follows the Interactive Question-Answering Method (IQAM). Each question and the ensuing answer will gradually narrow the uncertainty about the target solution (an approach that follows the principle of exhaustiveness). When all uncertainties are completely exhausted, the certainty of the solution will be achieved. The fourth type of sentence, the exclamatory sentence, is the same as the measure / measurement in the solution language. All it does is shrink the shadow of reality about any prescriptive sentence and express the feeling around it. For example, a sentence like, "It would be pleasant if the delivery was completed in less than 30 minutes". NSL has determined that all prescriptive sentences are animated and will satisfy the requirements of any solution. It is further supported by descriptive sentences (information layer). If spoken language is a combination of words and numbers, words represent unique entities and numbers represent the same entity. All solutions are strings of words or numbers that follow the framework formulated by NSL. NSL first captures all solutions using spoken language and calls those static sentences. It treats each part of speech as an entity and then structures these entities as belonging to different layers.After that, NSL animates these entities by converting them into BETs. The hierarchy followed by the word string is as follows a) Attribute: Attribute is the lowest possible perspective. Its presence is not mandatory; b) Entity: The presence of the entity is mandatory; c) CES: It is a combination or set of entities and attributes, which is the same as CU if it has a triggering nature; d) ECES: It consists of a set of CES; e) GSI: It is an ECES that is the final solution or transaction destination; f) Module: It is a combination of CU or GSI. Individual solutions and transactions occur in modules. In NSL, everything is contextually related to the selected perspective. If the perspective is a CES, the entities in it are its attributes. This means that all perspective combinations should be evaluated based on what is required in order for it to be in reality. Since it is mandatory for the entity to be in reality in order for the CES to be in reality, it is automatically considered as its attribute. Based on this logic, the CU and its composition become attributes of the GSI. This is true all the way up to the highest perspective. The direction of differentiation is set and unidirectional. For example, an egg can fall from a table and be broken, but a broken egg cannot jump onto the table and become an egg again. In other words, the direction of generalization and differentiation is set and absolute. If you look in the direction of differentiation from a certain general perspective, the differentiation node is outside many nodes. If you look from the differentiation node to the general perspective node, the general node is equally far away. When two or more words become the same, the words are converted into numbers individually or collectively. Two entities may be identical in nature. For example, there are two white pens on the table. When the agent closes the differences between the attributes and other perspectives BET, the attributes and other perspectives BET become the same. For example, when the colors of a white pen and a red pen are ignored, they become two pens. This type of information closure is called agent ignoring (masking / de-identifying) information, which is done selectively and contextually by the agent. Based on the optimization principle, this technique is widely used by agents to overcome complexity, condense or concentrate information, minimize effort, and maximize utility value. The widespread use of this technique has led to the dominance of numbers in everything. This technique has produced a very useful discipline, that is, statistics. Since modules are GSI-based and group modules are submodule-based, the information overload is very high at these levels. Therefore, it is observed that techniques of ignoring information (information that is not relevant for effectively acquiring the important content context) and generating numbers are widely used at these levels. This explains the dominance of numbers at the integration level.

[0364] NSL Digital Thinking: The abstraction (representation) layers in a computer are categorized as follows: a. Machine language, b. Assembly language, c. Compiler, d. Technical operating system. All four representation layers are a form of code designed to instruct the computer what to do. The last three representation layers (Assembly language, Compiler, and Technical operating system) use programming code, while machine language directly passes instructions through binary code of 0s and 1s. All four representation layers are standardized, which means that if any new programming logic is built, no changes need to be made in any of the above layers. In this way, the commoditization of these code layers has become possible. This is the same way that electronic transistors and circuits were commoditized. NSL replaces high-level programming languages ​​by adding three standardized layers on top of the four layers listed above (Machine language, Assembly language, Compiler, and Technical operating system), thereby standardizing higher-level solution development. Machine language is the NSL Solution Operating System (NSOS). Assembly language is the NSL Digital Thinking, which is placed on top of the NSOS and seamlessly integrates with it. NSL Digital Thinking is nothing more than the NSL BET library with over a billion BETs. The Compiler is a standardized repository of a set of questions and answers, which is expected to eventually reach hundreds of thousands for the sake of comprehensiveness. These will be seamlessly integrated with BETs from various perspectives in NSL Digital Mind. These Q&As will be connected to the node network in the same way that BETs are connected to the node-based network in Digital Mind. The Q&A network and BET network will be driven by the nearest neighbor principle. With the integration of NSOS, NDM and Q&A repository, NSL will commercialize the development of solutions based on advanced programming. It will only take a few hours of Interactive Q&A Sessions (IQAS) as per the Interactive Q&A Methodology (IQAM) between informed stakeholders and NSL Digital Mind Representatives (NHAA). With each Q&A, the uncertainty around the solution will be gradually reduced until the solution is fully implemented. NSL Digital Mind (NDM) will mimic human thinking. Its focus is not limited to just interaction with internal and external stakeholders (agents). NDM will keep itself busy 24 / 7 with constant internal introspection, just like humans do. Internal Q Agents and Internal A Agents will be constantly busy executing P-OSSA and R-OSSA cycles. Potential OSSA cycle is executed in batch mode and Reality OSSA cycle is executed in real time. Both are interdependent and constantly improving. In anticipation of future R-OSSA, P-OSSA stores, creates, deletes, modifies, and retrieves BETs as context requires. R-OSSA not only benefits from P-OSSA BETs, but also contributes to P-OSSA by introducing new reality BETs for P-OSSA to use in the future. A symbiotic relationship exists between P-OSSA and R-OSSA. Internal Q-agents (IQA) and internal A-agents (IAA) are higher order. In human agents, the interaction of IQA and IAA occurs throughout waking hours.In the case of a digital mind (digital agent), this interaction will be 24 / 7 as it does not need to rest. Digital agents are aided by new technologies such as machine learning and deep analytics; digital minds will continue to generate brilliant insights in real time, in batch mode, in the form of reusable and actionable BETs. There is no reason why the internal debate between IQA and IAA cannot lead to the most unexpected and game-changing BETs. NSL Digital Mind is a dynamic and living system that is constantly evolving, creating, removing and modifying BETs in the service of itself and its stakeholders. NSL Digital Mind not only houses the best BETs, but also acts as a BET exchange, like a stock exchange for qualified stakeholders. NSL Digital Mind is always thinking to improve itself and benefit from the insights brought by trillions of transactions. NSL Digital Mind is a BET language model that conforms to the NSL grammar. It can instantly implement solutions of any complexity through the interactive question and answer method (IQAM), which is about 5 times more efficient than normal programming.

[0365] Digital minds mimic human minds. Human minds dynamically add, remove, modify, store, and retrieve entities through the execution of P-OSSA loops. Minds also gather entities from the external environment (through the senses), add, remove, and modify entities (by directing the body to perform actuator functions), and store or retrieve entities through its R-OSSA loops. Minds rely on two internal QA agents and entities within them; multiple external agents and entities to process its transactions. Normalizing human agent behavior to NSLs will be a valuable exercise with the potential to yield rich dividends. A day in the life of an agent (human) will reveal that no more than a few dozen GSIs are executed in a day, carrying associated ECES, CES, entities, and attributes. The human brain will have a limited number of solution-level GSIs that are accumulated through years of experience. Transactional GSIs and their parts will scale with the age of the agent. Solution BETs and transactional BETs are interdependent to continuously improve the BET. Not all transactional BETs will remain in the mind, as evolution has equipped humans with the ability to selectively ignore information or forget. For example, there are only a limited number of solution BETs in the human mind. There are no more than a few hundred thousand words in the English dictionary, of which the average person will have a vocabulary of no more than 40,000 words. For transactions, one can expect that most of the memory is consumed in the shadows at the potential and actual levels. It is unlikely that there are more than a million BETs in the human mind if the solution BET is adhered to. Compare this to the NSL solution-level digital mind. The NSL digital mind will not be static. It will engage in the same inner reflection as the human mind, learn 24 / 7 through a constant dialogue with internal and external agents, deploy interrogative QA to constantly learn, and bring universal benefits to itself and all those agents it contacts. In this case, the NSL digital mind is about 10,000 times smarter than the human mind.

[0366] Mirroring Human Agent Functionality onto Digital Agents: Knowing that the P-OSSA cycle is executed in batch mode, they started mirroring the human agent functionality for all transaction BETs on a daily basis. It is completely certain that for every transaction executed in real time during the day, all the BET potentialities involved are gradually placed in place during the day, or sometimes earlier. For example, the decision to go to the movies may have been made in the morning, the decision to choose a particular movie may have been chosen two hours ago, and the decision to go to the theater may have been made an hour ago. There are implicit spatial and time stamps in the determination of all these batch mode transaction solution classes. The information of all these facts is stored in the digital mind through appropriate entries as they occur at the P-OSSA cycle level and the R-OSSA cycle level. The result is that all human agent functionality is completely mirrored in the digital mind, eliminating the difference. NSL is the only established system that can simulate the functionality of the human brain. Incidentally, in NSL, every change is a contextual event. NSL recognizes opportunities to analyze the cycle time associated with triggering CES - the start of the trigger, the end of the trigger, and the period associated with it; similarly, the cycle time between events in consecutive transactions is also considered an analysis opportunity. For example, when did the pen arrive in the first transaction and the second transaction? What was the time lapse between the two? In NSL, the contrast between P-OSSA and R-OSSA cycles provides another important opportunity for in-depth analysis. For example, the time lapse between the potential BET determination (deciding to go to the movie) and the actual state of the BET (actually going to the movie) might be 12 hours. But some potential and actual cycles can be very short, such as an hour or even a minute.

[0367] NSL aims to stamp technobytes directly onto NSL constructs. These constructs are modeled on principles of how the world works and, by extension, are parts of speech and numbers that are directly connected to spoken language. The quality of human agents performing OSSA cycles is also observed in the NSL approach in digital systems. Digital systems always have a goal for which they are built. It is also the case that digital systems need to repeatedly sense the environment, select things based on the context, and take appropriate actions. This is not different from how humans operate. NSL gives digital agents full-fledged agent status and treats them no differently than other human agents. One of the early findings was that the human brain played a role in first determining the survival augmented entities and their relationships before the body initiated them. This duality of brain and body function and the potential for connection that was first determined before reality descended resulted in the entity being transformed into a binary entity (BET). NSL found a way to breathe life into the entity. NSL found a way for the entity to inhale and exhale events to generate transactions from the perceived entity. The loop is executed in a fractal-like fashion with a self-similar structure of P-OSSA and R-OSSA, where each element of OSSA (goal, sense, select, and act) gradually brings order by overcoming disorder to ensure the defined goal. NSL can also quickly formalize any body of knowledge to benefit from and improve it, once the fundamental properties of all solutions and knowledge are identified as entities and their relationships.

[0368] Reconciling the old and new paradigms: It starts with the information that every thing is unique. In NSL, unique information about the agent and its target entities is considered. It should be noted that among trillions of unique things and their interactions, only one in a trillion (think of this number as a metaphor) of things are important to the agent. It is like there is a code about trillions of possible combinations. Entities achieve a binary status (dual nature), or BET status, due to the fact that agents essentially create contrasting environments for the entities they desire. NSL proposes a syntactic structure. The NSL Solution Operating System (NSOS) is based on the principles of how the world works in NSL. This is in stark contrast to the syntactic structures based on stored procedures, keywords, and propositional logic that high-level programming languages ​​rely on. NSL is further supported by digital thinking and QA layers, making interactive solution development possible.

[0369] The essence of the new paradigm and NSL Digital Thinking: Digital Thinking is the unification of NSOS Logic, NSL Digital Thinking, and the curated QA repository. NSL Digital Thinking eliminates the difference between humans and digital agents. NSL enables human agents and digital agents to interact like friends and collaborative agents. The world of human agents and digital agents is a world of seamless entities and their relationships that are important to them.

[0370] The essence of the old paradigm: It is driven by a higher level programming logic customized for each solution. All logical functions and machine driven solutions operate on principles similar to mathematics and propositional logic. This solution logic is guided by stored procedures and programming keywords that only experts like programmers can understand. All solutions happen behind the scenes, and only inputs and outputs are visible at the UI level in the form of spoken language. The old paradigm alienates humans and machines. Agents, entities and their relationships are foreign to the old paradigm and their existence is not recognized by the old paradigm.

[0371] Human Agency, Evolution, and Solutions: The universe is filled with two types of particles – fermions and bosons. Fermions are matter particles that represent all matter. Fermions have half-integer spin. When one thinks of fermions or matter, he / she thinks of nouns. Bosons represent the four fundamental forces of nature – strong nuclear force, weak nuclear force, gravity, and electromagnetic force. Bosons have integer spin. When one thinks of bosons or energy, he / she can think of verbs (because they represent change). While there are four fundamental forces of nature, only the electromagnetic force is essential to solutions for all practical purposes. The strong and weak forces are related to forces deep within the nucleus of atoms. These forces can neither be controlled nor influenced in any way. Gravity is always there and one cannot control it. It is like a constant across transactions. Evolution has shaped human agency to control electromagnetic forces to achieve their goals. For example, evolution has shaped the human ability to recognize colors. People have the ability to recognize various electromagnetic wavelengths between 400 and 700 nanometers as a range of colors, which can be represented by the acronym VIBGYOR. Color is unique to humans and it is deeply rooted as experience. There is no way to describe color to a person who is born blind. If there are extraterrestrials, it is likely that the same electromagnetic waves will be perceived as different colors by these aliens because the evolutionary process will be different. Evolution has also shaped humans to recognize entities and their relationships in unique discrete states. Given the limited storage and processing capacity of the human brain, humans convert their experience into discrete states in order to survive. The continuity and infinity of nature are beyond the ability of humans or any life form to handle. Converting experience into discrete states is similar to a video containing 30 frames per second. Evolution only recognizes entities in relevant perspectives. Although humans are composed of atoms, it was not until recent human history that their existence began to be understood. Recognizing entities and their relationships means that the uniqueness of the material level and the changes in the state of matter should be discerned. In order to recognize changes, it is inevitable to record the transition from one state to another. The smallest amount of change can be represented by 0 or 1. In mathematics, the smallest base system is binary. The logarithm of any base is a composite of this binary base. Applying the same principle, NSL converts each entity (and, by extension, the relationship of entities) into a binary state. Each binary entity (BET) acts as a switch that accommodates events and transitions. All transitions are about moving from one CES to another, and these controlled transitions produce solutions that are sought and controlled by the agent. These transitions occur in discrete steps driven by the nearest neighbor principle. All transitions are subject to the unique properties of the entity and the principles of how the world works. The properties of an entity are about how any entity uniquely interacts with any other entity in the universe. For example, if one throws a rubber ball against a wall, it bounces back. But if one throws slime against a wall, it sticks to the wall. While there may be an infinite number of entities and their relationships, they belong to a finite set of classes determined by the principles of how the world works.The constructs of NSL are these classes that represent the NSL Solution Operating System (NSOS) or NSL grammar. This is the same as a finite set of English grammar rules that guide millions of lines of text. NSL has NSL digital mind that sits on top of NSOS and integrates seamlessly with it. This eliminates the difference between human agents and digital agents. Human agents can solve any problem and get a solution by interacting with other agents in a QA format. The interaction between human agents and digital agents can implement any solution in a few hours. The interacting agents can be internal QA agents or external agents. NSL eliminates the asymmetry between human and digital agents and marks a new era in solution development. In NSL, sets of bits that collectively represent entities are frozen to create an environment of the law of the excluded middle and those frozen sets are connected to the NSL grammar. In the old paradigm, bits were connected to ill-defined data sets and their transformations. These technological transformations completely ignored the existence of agents, entities and their relationships, and the principles of how the world works. The old paradigm had its own solution grammar based on mathematics and propositional logic expressed through high-level programming. High-level programming relies on sets of stored instructions represented by keywords. The solutions are constructed by stringing together these stored programs to control the so-called data flow. The result is a solution that can only be handled by trained programmers and is 1000 times more difficult to develop. The resulting solutions are at least five times worse than the NSL solutions. Moreover, these solutions seem to have nothing to do with agents, entities and their relations. In all popular computer science textbooks, agents, entities and their relations are not even mentioned once.

[0372] Representational or Equivalence Layer: All entities of reality (entities in the functional or master layer) have their representational counterparts in the representational layer. These can be text, speech, images, videos, characters, statues, etc. Some of them have sub-layers, for example the language layer has all languages ​​as sub-layers. To qualify for the representational layer, truth values ​​need to be preserved. Some representations in the P-OSSA loop can be in the master layer in anticipation - transactional solution classes. When reality is in the physical layer, it may have to wait before it can turn to reality. When physical reality happens, the representational entities of those solution entities in batch mode also turn to reality. The presence of representational counterparts in the representational layer is a powerful tool for creative applications.

[0373] NSL Framework: NSL uses spoken language in the context of solutions, including numbers and all parts of speech. Parts of speech are representational unique entities. These are made up of implicit unique elements of composition frozen together. For example, words are made up of letters which in turn can be represented by a set of bits, or physical entities like pens are made up of trillions of atoms, operating with the law of excluded middle. NSL takes these static parts of speech or representational entities and transforms them into dynamic binary entities (BETs) with potential states and actual states. These dynamic parts of speech in the form of BETs act as channels of variation through a controlled flow of events that produce solutions. These dynamic parts of speech are guided not only by English grammar but also by a NSL grammar known as the NSL Solution Operating System (NSOS). NSL grammar is nothing but evidence-based, supported by scientific, world-works principles. All controlled variations are constrained by www principles and the NSL comprehensive grammar which provides all possible channels of allowed variations. For example, all variation flows must respect the nearest neighbor principle or all variations are about transitions or state changes in discrete binary entities. It is these NSOS (NSL grammar) constructions that tightly and seamlessly tie controlled electromagnetic forces together. These NSOS constructions, in turn, are loosely but contextually tied together with billions of eligible BETs in the NSL digital mind. This effectively means that the word classes are dynamic, taking actions at the speed of light driven by electromagnetic forces. In the NSL paradigm, the asymmetry between digital and human agents is eliminated as dynamic word classes and BETs are common between them. This paves the way for digital and human agents to interactively obtain any solution within a few hours. Each QA between them gradually disambiguates the solution until solutions that are several times better than them are fully implemented.

[0374] Natural Language (NL) Grammar: NL grammar is not expressive enough to fully capture the principles of how the world works in the context of technological solutions. Word classes in natural or spoken language have been tested for thousands of years. Therefore, they are very applicable and relevant as representational entities to build solutions. Human agents do not benefit from controlled electromagnetic forces because they are a new phenomenon only in the past 80 years. Controlled electromagnetic forces have the ability to move representational entities at the speed of light and perform billions of representational functions per second. Using these constructions, NSL grammar makes the principles of how the world works expressive enough to fully handle all the principles of humans in the context of technological solutions. NSL constructions can capture the essence of word classes in NL in the most natural way possible. NSL can simulate human agent functions by performing simple thought experiments (Gedankenexperiments) that conform to the principles of how the world works.

[0375] Agent behavior can be defined based on the principle of the ability to perform a Goal Sense Select Action (OSSA) cycle. Wherever the OSSA cycle is performed, there is an agent. This qualifies the NSL digital mind to operate on the same principles as human agents. The NSL world is a world of entities, their relationships in the agent’s context, and their goals based on the principles of how the world works. Human agents are constantly interacting with internal QA agents or external agents in one form or another to constantly narrow ambiguities and improve their solutions or transactional BETs. NSL has been able to elevate the status of digital agents to a level that eliminates the asymmetry between human and digital agents. The exercise of mirroring a day in the life of a human agent leads to mirroring that reality into the NSL digital mind, establishing the fact that both human agents and NSL digital minds equally adhere to the model of entities and their relationships. Controlled electromagnetic forces have the ability to move representational entities at the speed of light, and can store, process, retrieve, and exchange representational entities at least a million times faster. In contrast, human agents think at a speed of only about one tenth of a second. Both humans and digital agents control electromagnetic forces. The other three fundamental forces of nature, namely the strong nuclear force, the weak nuclear force, and gravity are not important because we cannot control them. One can harness gravitational potential energy, but to create gravitational potential energy, one must rely on electromagnetic force. Evolution shaped humans by controlling electromagnetic force. Humans, in turn, artificially created digital agents by harnessing the same electromagnetic force and made these digital agents more powerful than themselves in many cases. The ability of digital agents to drive and manipulate representational entities at least a million times faster makes it possible to handle representational entities (word classes) through principles that go far beyond NL grammar. So far, NL grammar has been sufficient to produce the existing literature. However, in a world where controlled electromagnetic force is required to meet all solution requirements of the world, NL grammar seems to be insufficient. A grammar that is more expressive to cater to all solution scenarios while being fully consistent with the principles of how the world works is the need of the hour. NSL grammar fits the bill. NSL grammar reinterprets and uses all NL grammar rules in one form or another. NSL grammar invented BET so that word classes can become dynamic. NSL grammar and its constructions can cater to any type of solution scenario. NSL grammar has ways to handle potential shadows, reality shadows, condense information by selectively ignoring it, add contextual layers and sub-layers, transitions across horizontal and vertical CUs, and more. NSL syntax is identical to the NSL Solution Operating System (NSOS) and is fully equipped to support NSL digital thinking. NSL digital thinking is able to interactively implement any solution instantly. To do this, one should connect controlled electromagnetic forces (at the 0 and 1 level) to the NSL syntax, consistent with the principles of how the world works, and enrich the syntax in context to get magical effects. In the 1940s, builders of electronic machines thought only in terms of computation and mathematical / propositional logic in the context of solutions.This led to the concept of stored programming, resulting in artificially programmed word units connected to controlled magnetic forces. Such unnatural results and counterintuitive methods involved in solution construction required complex expert training. As a result, ordinary people were completely alienated from the machine. In the early days of computers, no one realized that computers could simulate human behavior based on a model of entities and their relationships. NSL syntax eliminates the anomalies in the old paradigm and enables the construction of solutions a hundred times faster and with several times better quality. NSL syntax will mark a new era in solution development.

[0376] Naturally made human agents: Naturally made human agents require a natural language (NL) grammar to exchange linguistic representational entities. Consistent with the principles of the way the world works, human made digital agents need all the NL grammar constructs to function. This is because digital agents are driven by controlled electromagnetic forces and operate millions of times faster. The speed of human thought is 1 / 10 of a second. The speed of “digital agents processing representational entities” is 1 billion times per second. In addition, digital agents rely on other agents (digital and human) to make up for their functional deficiencies compared to human agents. For example, human agents are independent, have five senses, mental faculties, and physical actuators. There are also other differences in the way digital agents store, process, retrieve, and exchange representational entities with other agents in a seamless network environment. All of these differences require an extended grammar for digital agents in the form of NSL that is still consistent with the principles of the way the world works. NSL contains all the NL grammar constructs (directly or indirectly) and more to fully meet the requirements of digital agent functionality.

[0377] Natural Language (NL) Grammar vs Natural Solution Language (NSL) Grammar: NL grammar is about standardizing text based on a set of rules. NL consists of word classes that follow a given grammar. Human agents can generate language by associating artificial entities with entities in the physical world. For example, an object such as a pen or an action such as writing is associated with a language tag. According to NSL, anything that is unique and solution-important is an entity. Some entities also have relational or representational properties. For example, the physical object pen and the word pen are related and therefore representations of each other. Depending on the context, one entity becomes a realistic entity and the other a representational entity. Each entity is a class in itself. Anything that is unique is information. Entities are contextually relevant to agents. Entities refer to a set of unique things that can be gathered together and frozen into entities. The set of entities formed then operates based on the principle of the law of the excluded middle. An entity either exists in potentiality or in reality, there is no other acceptable state. The dual state or binary state (BET) of entities stems from the fact that in the agent world, perception and reality are inseparable. In the case of NL, all parts of speech also acquire entity status and thus implicitly become BET. NL grammar with its constructions and principles acts as a class of classes (parts of speech are also classes). Since language tags are assigned to entities in the real world, the behavior of real world entities has an impact on how NL grammar evolves. In other words, NL grammar always conforms to the principles of the way the world works. Without this consistency, the assigned parts of speech would lose their truth value and quickly become obsolete. The principles of NL grammar that have been tested for thousands of years will always be consistent with the principles of the way the world works. Natural Solution Language (NSL) grammar and constructions make WWW principles expressive enough so that all technical solution scenarios are fully handled and comply with all the principles that have shaped humans through the evolutionary process. In other words, NSL constructions capture the essence of all parts of speech of natural languages ​​and even more in the most natural way possible.

[0378] NSL syntax, NSL Solution Operating System (NSOS) and constructs (lemmas) are tightly coupled with controlled electromagnetic forces that power them millions of times. These remain constant across solutions, except for upgrades to NSL syntax. This is different in the case of stored programming constructs. Stored programming constructs (lemmas) – programming keywords, symbols, variables and constants – are like building blocks that are uniquely woven together for each solution. Each programming-based solution is not only unique but also very laborious. In contrast, NSL Digital Minds (NSL BET Library) are constants but can be continuously upgraded. NSL Solution Variables are interactive QA that disambiguates and finds solutions with limited effort. New solution creation is the process of discovering a solution path. In other words, existing BETs and their relationships are selected in context and additionally created or customized as needed. Any such new creation and customization becomes an integral part of NSL Digital Minds, further reducing the effort of the solution. Each solution is a contextual discovery of a path to a destination. NSL Digital Minds are like a road network, consisting of a three-dimensional network of BETs waiting to be used or reused as required by the solution context. All solution paths are automatically paved by digital thinking in the context of stakeholder goals.

[0379] The process of converting entities to BETs: Each entity is a class in itself because it is unique relative to the rest of the universe. It's like drawing a circle and saying things are either in it or outside it. NSL effectively converts entities into classes that accept a given entity or event but not others. In other words, BETs help animate entities (make them dynamic) in the context of agents and their goals.

[0380] Entity relationships: 1. Correlation: Correlation exists when there is mutual information between entities. When one can infer another entity while recognizing a given entity, the entities are related. These can also be called representational entities. Correlation can be established by mutual agreement. For example, spoken language is of this type. It was learned that at some point, a physical pen should be called a pen. When everyone in a community is on the same page, a language element is born. Correlation based on “cause and effect” can also occur when a correlation between a full moon and high tide is observed. Correlation is based on association relative to other classes of entities. Its classic example is the behavior of Pavlov’s dog. There is the presence of a bell and the arrival of food at a given time interval. The dog starts to associate food with the bell. Here, the reference class is time. This can also happen relative to all other classes. For example, if the spatial entity is a kitchen, it is possible to associate a stove and a gas tank because one entity can be inferred from the other. Establishing correlation in the context of uncertainty and associated probabilities will be handled as an attribute in NSL.

[0381] 2. Coexistence: Coexistence is especially in the context of entities gradually reaching the CU to achieve a goal. This is the same as non-triggering CES. When non-triggering CES undergo a transition from one to another, each such event is considered to produce a null event. Physics requires that the counterpart of the cause must be accounted for, which is the effect. In these non-triggering events, the effect is a null event. Just as 0 is also a number, a null event also qualifies as an event.

[0382] 3. Co-creation: Co-creation is about triggering a CES to cause one or more tangible events (events of non-null type) in one or more CUs, including itself. In mathematical and programming parlance, these are treated as functions. The summary statement here is that between correlation, co-existence and co-creation (functions), all entity relationships are taken into account.

[0383] Language level used for solution: Machine language is considered as low-level language. Assembly language is considered as medium-level language. Java, Python, C and other programming languages ​​are considered as high-level languages ​​(HLL). It is difficult for users to understand them. On the other hand, natural (spoken) language is easy to understand. One can call natural (spoken) language as HLL. NSL has proven that HLL can develop solutions of any complexity and can also do the following:

[0384] A. Make solution development independent of the use of any spoken language.

[0385] B. Eliminate the asymmetry between human and digital agents and enable dialogue between them.

[0386] C. Make the solution completely transparent.

[0387] D. Make the solution development time 1 / 1000 of the original, which is three orders of magnitude faster.

[0388] E. Ensure that the quality of the developed solution is at least 5 times that of the original one.

[0389] How NSL Digital Minds Work: The instruction sets stored in the machine language layer will be directly and tightly coupled to NSL grammatical constructs (now, they are indirectly coupled). NSL grammars, the NSL Solution Operating System (NSOS), which is based on principles of how the world works, act as filters in NSL Digital Minds to determine billions of eligible BETs. NSL Digital Minds can best be visualized as a 3D network of BETs in the shape of a sphere. As NSL Digital Minds become richer in BETs, the density of BETs within the sphere increases with the size of the sphere. This network of BETs is reminiscent of the tightly packed network of neurons in the human brain. As the number of BETs in this network of NSL Digital Minds grows, so does its intelligence. Compared to a human mind, NSL Digital Minds have orders of magnitude more knowledge. Not only does NSL Digital Minds host a significantly higher number of solution BETs, but the quality of the BETs is also much better. All NSL Digital Minds BETs are carefully curated based on evidence, science, and expert intervention, making these BETs highly reliable. Human agent solution BETs do not meet the same standards in terms of bias-free environments compared to NSL Digital Minds. Any new solution development is achieved through a process of interaction between stakeholders and NSL digital minds, as if they were friends. Through a series of structured questions and answers processed between stakeholders and NSL digital minds, following the Interactive Question and Answer Method (IQAM), any solution can be implemented in a few hours. This is possible because for all practical purposes, solutions are not created every time. Only when stakeholders seek new solutions, the path to the solution is established in the context. This is the same way that it operates from one place to another in the city based on the destination of the search and the current location of the stakeholders. IQAM gradually narrows the uncertainty and eventually produces the certainty of the solution. Once the computer has reached the status of digital mind (digital agent), eliminating the difference between human agent and digital agent, what remains is as intuitive as a normal interaction between people. The key to NSL's invention lies in the creative approach taken by NSL to transform computers into digital minds. NSL had to first establish the commonalities and differences between humans and computers (digital systems). Digital systems operate at the speed of light, while human agents move slowly and think at a speed of only 1 / 10 of a second. However, human agents are more independent in all elements of the OSSA cycle. They can determine their own goals and perceive things in the environment through all five senses. They can make their own decisions based on context and take actions on things through actuators like hands and legs. To turn computers into digital agents, NSL requires recognizing the need to create collaborative agent environments to maximize mutual benefit. It's like having the opportunity to put 1 and 1 together so that they become eleven (11) instead of two (2).It is as if the speed of electromagnetic forces (which operate billions of times faster) can be combined with all elements of the human solution OSSA cycle. Whenever there is a dependency on a part of the digital agent, the collaborative human agent will help, and when the human agent has the opportunity to use the controlled electromagnetic force, the digital agent will respond. While it is attractive to eliminate the difference between human and digital agents, it requires a significant expansion of the grammar of communication between humans and digital agents. Communication between human agents needs to adhere to the grammar of natural language (spoken language). There are more than 30 constructs in the grammar of English. For example, a sentence must have a verb associated with it, nouns can be distinguished from adjectives, verbs can be distinguished from adverbs, and so on. If any of these grammatical rules are violated, the text is considered non-compliant. Language evolves by labeling real-world experiences. If 100 native people without language were isolated on an island, 100 years later, they would have developed their own language. They would label a tree, a tiger, or an action (such as falling or running) to express their experience or their understanding of how the world works. However, in the context of the solution, the communication of humans and digital agents requires a grammar with a richer scope to account for all experiences based on the principles of the way the world works and associated with the existential context of the digital agent. Far beyond the 30+ constructions in English grammar, to meet the requirements in the context of digital agents, NSL has created an extended grammar with more than 100 constructions to consider all scenarios. These 100+ constructions also include all 30+ natural language grammar constructions (in one form or another) because they also respect the principles of the way the world works. For example, NSL introduced the BET model to account for the need to animate text. Its nearest neighbor principle takes into account the generation of events based on cause and effect, its selective ignoring of information leads to the required information condensation, and its CU types cover any type of transformation. Equipped with NSL, solutions can now be built in a few hours and with five times better quality by performing simple thought experiments (thought experiments). The alienation of the machine agent problem in the old paradigm is now fully solved. It is now possible to lay the highway for the implementation of artificial intelligence ...

Claims

1. A method (3700) for building a computer-implemented solution using a natural language understood by a user and without using programming code, the method (3700) comprising: Receiving ( 3702 ), by a processor ( 3504 ) of the computing system ( 3502 ), from a user a global intent statement indicating that the solution is constructed using the natural language, wherein the global intent statement is received in the form of the natural language and is set to a potential state; receiving (3704) by the processor (3504) from the user one or more local intent statements associated with the global intent statement and details of n entities and agents associated with each local intent statement, wherein each local intent statement and details of each entity and the agent are received in the form of the natural language and are respectively set to a potential state, wherein each local intent statement is a sentence indicating sub-steps for satisfying requirements for performing the solution, wherein each entity includes a noun phrase and participates in satisfying the requirements of the sub-step indicated by the corresponding local intent statement, and wherein the agent is at least one of a human agent and a machine agent; For each entity, receiving (3706) by the processor (3504) from the user in the form of the natural language one or more attributes, the one or more attributes defining characteristics of the corresponding entity and distinguishing the corresponding entity from other entities of the corresponding local intent statement, and being set to a potential state, wherein each attribute includes at least one of an adjective phrase and an adverb phrase; wherein the agent changes at least the potential state to an actual state for each attribute, each entity, each local intent statement and the global intent statement, The processor (3504) forms (3708) a combined entity state CES set for each local intent statement, the combined entity state CES set including the n entities of the corresponding local intent statement. possible combinations, wherein the CES formed based on all entities of the corresponding local intention declarations, the number of which is n, is a triggered combined entity state, i.e., a triggered CES, and wherein each CES in the set is in a potential state and changes to a real state in response to changing the associated entity to a real state; In response to determining that only one received local statement of intent is associated with the global statement of intent, identifying (3710) a triggering CES of the received local statement of intent as an end of construction of the solution; In response to determining that more than one received local intent statements are associated with the global intent statement, receiving (3712) by the processor (3504) from the user in the form of the natural language a plurality of unique relationships based on one or more of predefined rules, constraints, and formulas between the local intent statements, wherein each unique relationship is a unique path that satisfies requirements for executing the solution, wherein the relationship indicates whether a triggering CES of one local intent statement affects a set of CESs of another local intent statement or is an end to construction of the solution; and Receiving (3714), by the processor (3504), from the user in the natural language, one or more Natural Solution Language (NSL) stacks for the one or more local intent statements, wherein the NSL stacks received for the local intent statements are linked with the local intent statements to generate data during construction or execution of the solution, wherein the generated data is used to: providing predefined functionality to the local intent declaration; and / or Providing predefined functionality to one or more other local intent statements; and / or Perform data analysis, wherein the potential state is an empty binary state and the actual state is a non-empty binary state, and The information in the natural language is received via a handwriting-based interface, a touch-sensitive interface, a speech-based interface, or a combination thereof.

2. The method according to claim 1, wherein: The method comprises: for each entity of each local intent declaration, receiving, by the processor (3504), user input for the corresponding entity from the associated agent in the form of the natural language, wherein receiving the user input for the corresponding entity is a record of an event in which the potential state of the corresponding entity is changed to an actual state based on the received user input, wherein receiving user input for all entities associated with each local intent declaration is a record of an event in which the potential state is changed to an actual state for the corresponding local intent declaration, and wherein receiving user input for all entities associated with all local intent declarations is a record of an event in which the potential state is changed to an actual state for the global intent declaration; and For each attribute of each entity, the processor (3504) receives user input for the corresponding attribute from the associated agent in the form of the natural language, wherein receiving the user input for the corresponding attribute is a record of an event that changes the potential state to an actual state for the corresponding attribute.

3. The method according to claim 1, wherein: The NSL stack includes a language stack, wherein the language stack is linked to the local intent statement to generate data that provides predefined functionality for changing at least one of user input and output from a first natural language to a second natural language during construction or execution of the solution, wherein the changing is based on a language equivalence matrix.

4. The method according to claim 3, wherein: The method comprises: A selection of the second natural language is received, by the processor (3504), from the user in the form of the first natural language.

5. The method according to claim 1, wherein: The NSL stack includes a machine learning stack, wherein the machine learning stack is linked to the local intent statement to generate data that provides predefined functionality for evaluating and / or modifying and / or ignoring and / or recommending at least one of user input and output based on one or more machine learning techniques and / or one or more machine learning databases associated with the local intent statement and / or with one or more other local intent statements during construction or execution of the solution.

6. The method according to claim 1, wherein: The NSL stack includes a blockchain stack, wherein the blockchain stack is linked to the local intent statement to generate data that provides the following predefined functions: During construction or execution of the solution, protecting at least one of user input and output with respect to the local declaration of intent and / or one or more other local declarations of intent based on one or more blockchain technologies; and / or During construction or execution of the solution, non-fungible tokens and / or personalized tokens for at least one of user input and output are issued for the local intent statement and / or for one or more other local intent statements based on one or more blockchain technologies.

7. The method according to claim 1, wherein: The NSL stack includes an analysis stack, wherein the analysis stack is linked to the local intent statement to generate data that provides the following predefined functions: providing data analysis of at least one of user input and output for the local intent statement and / or one or more other local intent statements based on one or more statistical functions during construction or execution of the solution.

8. The method according to claim 1, wherein: The NSL stack includes a knowledge stack, wherein the knowledge stack is linked to the local intent statement to generate data that provides the following predefined functions: determining, during construction or execution of the solution, a knowledge score of an agent associated with the local intent statement or one or more other local intent statements based on a set of predefined questions and answers; and The knowledge score of the agent is stored in a knowledge database.

9. The method according to claim 8, wherein: The method includes generating, by the processor (3504), a prompt to change one or more proxies of the local statement of intent or one or more other local statements of intent based on respective knowledge scores of one or more proxies of the local statement of intent or one or more other local statements of intent.

10. The method according to claim 1, wherein: The NSL stack includes an integration stack, wherein the integration stack is linked to the local intent statement to generate data that provides predefined functionality that enables integration of one or more NSL application programming interfaces with the processor (3504) during construction or execution of the solution.

11. The method according to claim 1, wherein: The NSL stack includes an Internet of Things (IoT) integration stack, wherein the IoT integration stack is linked to the local intent statement to generate data that provides predefined functionality for implementing one or more IoT device interfaces, and / or one or more sensor interfaces, and / or IoT application programming interfaces integrated with the processor (3504) during construction or execution of the solution.

12. The method according to claim 1, wherein: The NSL stack includes a Metaverse stack, wherein the Metaverse stack is linked to the local intent declaration to generate data, the data providing predefined functionality for implementing one or more virtual reality device interfaces, and / or one or more augmented reality device interfaces, and / or one or more mixed reality device interfaces, and / or holographic device interfaces, virtual reality application programming interfaces, and / or one or more augmented reality application programming interfaces, and / or one or more mixed reality application programming interfaces, and / or holographic application programming interfaces integrated with the processor (3504) during construction or execution of the solution.

13. The method according to claim 1, wherein: The NSL stack includes a value stack, wherein the value stack is linked to the local intent declaration to generate data that provides the following predefined functionality: receiving a monetary value for at least one of each entity, each attribute, and the agent associated with the local intent statement; and Based on the received monetary value, a total monetary value of at least one CES in the set of CESs associated with the local intent statement is generated.

14. The method according to claim 13, wherein: The generating is performed during execution of the solution and when changing the at least one CES to the actual state.

15. The method according to claim 1, wherein: The NSL stack includes an energy stack, wherein the energy stack is linked to the local intent statement to generate data that provides the following predefined functions: Energy and / or storage consumed by at least one of each entity, each attribute, the agent, and each CES associated with the local intent statement during construction or execution of the solution is determined.

16. The method according to claim 15, wherein: The determination is performed when the corresponding entities, attributes, agents, and CES are changed to the actual state.

17. The method according to claim 1, wherein: The NSL stack includes a base stack, wherein the base stack is linked to the local intent declaration to generate data that provides predefined functionality to determine a medium for at least one of a user input and an output prior to executing the solution.

18. The method according to claim 17, wherein: The medium is at least one of text, audio, video frame, image, and gesture.

19. The method according to claim 1, wherein: The NSL stack includes a security stack, wherein the security stack is linked to the local intent declaration to generate data that provides predefined functionality for providing security to at least one of user input and output based on one or more personalization techniques and / or one or more encryption techniques during construction or execution of the solution.

20. The method according to claim 1, wherein: The NSL stack includes a privacy stack, wherein the privacy stack is linked to the local intent declaration to generate data that provides predefined functionality for providing privacy to at least one of user input and output based on one or more cryptographic techniques and / or based on one or more encryption techniques during construction or execution of the solution.

21. The method according to claim 1, wherein: The NSL stack includes a masking stack, wherein the masking stack is linked to the local intent declaration to generate data that provides predefined functionality to mask at least one of user input and output during construction or execution of the solution.

22. The method according to claim 1, wherein: The NSL stack includes an implicit stack, wherein the implicit stack is linked to the local intent declaration to generate data, which provides predefined functionality for adding one or more implicit entities and / or one or more implicit attributes and / or one or more implicit agents to the local intent declaration during construction or execution of the solution.

23. The method according to claim 1, wherein: The NSL stack includes a game stack, wherein the game stack is linked to the local intent declaration to generate data that provides predefined functionality that implements integration of one or more game application programming interfaces with the processor (3504) during construction or execution of the solution.

24. The method according to claim 1, wherein: The NSL stack includes a behavior determination stack, wherein the behavior determination stack is linked to the local intent statement to generate data that provides predefined functionality for determining the behavior of an agent associated with the local intent statement or the behavior of one or more agents of other local intent statements based on analysis of user input during construction or execution of the solution.

25. The method of claim 1, wherein: The method includes receiving, by the processor (3504), a unique identifier (ID) of an NSL stack of the one or more NSL stacks.

26. The method of claim 1, wherein: When building the solution, the one or more NSL stacks are set to a latent state by default.

27. The method of claim 1, wherein: The machine agent includes a questioning (Q) agent and / or an answering (A) agent, wherein receiving one or more of the global intent statement, the local intent statement, the details of the entity and the agent, the attributes, the unique relationship and the NSL stack is in response to an interactive question-and-answer session between the Q agent and the A agent or between the Q agent, the A agent and the human agent based on a question-and-answer repository.

28. The method according to claim 2, wherein: The machine agent includes an answer (A) agent, and wherein the user input is received from at least one of the A agent and the human agent.

29. A computing system (3502) for building a computer-implemented solution using a natural language understood by a user and without using programming code, the computing system (3502) comprising: Processor(3504); and A memory (3506) coupled to the processor (3504), the method comprising instructions executable by the processor (3504) to implement the method according to any one of claims 1 to 28.

30. A non-transitory computer readable medium having stored thereon instructions for constructing a computer-implemented solution using a natural language understood by a user and without using programming code, the non-transitory computer readable medium comprising machine executable instructions which, when executed by a processor (3504), cause the processor (3504) to perform a method according to any one of claims 1 to 28.

Images