* `add(F, G) -> F+G` -- Add function `G` as a subfunction of `F`. Introducing a new subfunction necessarily introduces new constraints that may impact the other functions. For instance, if we were to `add(Good_Will_Hunting, Minions.Character)` then the plot, theme and other character functions would reflect the presence of Minions in the film.
* `subtract(F, G) -> F-G` -- Subtract function `G` from function `F`. This is the inverse of `add`. `subtract(Star_Trek, Star_Trek.Theme.Optimism)` would cause the other functions to update in a way that removed the optimism as a guiding theme from the story.
* `multiply(F, scalar) -> F x scalar` -- Multiply function `F` by the provided scalar value. For instance, `multiply(Aladdin.Character.Genie, 2)` would generate a new story with two genies. This operation may be partially applied to define the way in which the function is multiplied.
* For instance, `multiply(Aladdin.Character.Genie, 2, Fractal)` will extract a copy of the Genie function and then apply it at a different level of abstraction within the story. This could look like multiple minor characters also played by Genie, or it could look like the setting bearing a striking resemblance to Genie's face, or anything.
* `multiply(Aladdin.Character.Genie, 2, Random)` will extract a copy of the Genie function and then apply it at a random level of abstraction within the story. This could look like multiple minor characters also played by Genie, or it could look like the setting bearing a striking resemblance to Genie's face, or anything.
* `multiply(Aladdin.Character.Genie, 2, {Aladdin.Theme})` will extract a copy of the Genie function and then apply it to the theme function. In practice this may look like amplifying genie's existing influence on the theme, or it may look like changing the theme to better reflect some aspect of Genie's character.
* `divide(F, scalar) -> F / scalar` -- Divide function `F` by the provided scalar value to reduce its influence on the story. For instance, `divide(Aladdin.Character.Genie, 2)` would rewrite the story such that Genie's influence on the overall story function is halved.
### LLMIP Axioms
1. LLMs map human language to abstract high-dimensional mathematical structures via latent space queries.
2. Unrelated concepts can be connected through latent space coordinates, identifying isomorphic relationships.
3. Simple concepts (e.g., "foo" and the number 3) have quantifiable relationships within the LLM's latent space.
4. Complex concepts (e.g., a sentence and a mathematical expression) are composed of simple concepts with specific relationships. Identifying invariant isomorphisms between constituent parts can yield productive isomorphisms between complex concepts.
5. When applied to domains of behavior (e.g., academic disciplines, specialized systems), LLMIP enables queries using tools and axioms from one domain to refer to subjects from another.
5.1. The LLMIP constitutes a special case of operational domain. Given the operations it makes available, an arbitrary number of isomorphisms can be generated. These can then combine operations from across their operational domains to produce truly novel approaches to issues in the problem domain.
### LLMIP Core Operations
There are a few operations always available to the LLMIP:
* `createIsomorphism(operationalDomain, problemDomain) => I` - The fundamental operation enabled by this system is the ability to create an isomorphism between the provided domains. This operation is complex — it requires a mereotopological analysis of each domain to generate a relational mapping between the two that preserves as many of the internal invariants as possible. The default format operation for an Isomorphism is a summary of how the operational domain may be applied to the problem domain. It should describe the mapping without going into too much detail, and it should generate a few examples of the operational domain can be applied to the problem domain in novel ways.
* `decompose(F, {i, j, k}?) => { F_i, F_j, F_k }` - Decomposition takes a given function and returns a set of subfunctions. Decomposition doesn’t necessarily return a lossy or even lossless output — the subfunction space is conceptually infinite, and certain decompositions can add information by defining gainful subfunctions.
* `compose({…F_n}, F?) => F’` - Composition takes an optional F into which the set of subfunctions provided may be composed. In the absence of this guidance, compose the subfunctions into a novel function and return that. Composition of arbitrary subfunctions may lead to an incoherent result, because different subfunctions apply different constraints to the composition (and by extension to all other subfunctions). As a mitigation strategy, application of composition always implies the application of coherence to the result.
* `cohere(F, F’) => F’’` - Coherence works by ensuring that all constraints imposed by the new subfunctions are respected by all of the other subfunctions. It relationally tracks the specific deltas required to ensure that all new constraints are met, and returns an output whose constituent parts have all been mutated through the application of the smallest possible delta that will preserve the invariants we care about. (author's note: there's a bug here, I can't believe I missed this)
*`format(F, rules) => string` — the format operation always returns a string representation of its input as generated through the provided rules. We are dealing with complex high-dimensional abstract structures that cannot be meaningfully represented in a text chat. As a result, we want to constrain our output to always require the application of format. If no format is provided, use a default formatter that simply and concisely describes the structure being represented.