💬glossary / ontology

Terms you might encounter

tree

aka: multiverse

Loom is a tool for generating and reading text trees, or multiverses.

Trees are branching texts: texts which diverge into multiple different futures. Choose-your-own-adventure stories, for instance, are trees. Each path through the tree corresponds to a different "playthrough" of the multiverse.

Language models naturally generate trees, because they output a probability distribution which is sampled to yield a particular next token, and sampling multiple times from the same distribution results in different continuations each time.

In Loom, trees are composed of nodes associated by the parent-child relation, which binds the directional flow of time.

node

In Loom, a node is a container for a segment of text. The relation of a node to other nodes determines the text which comes before that segment and text that can come after.

Nodes can be into multiple nodes and merged.

child

aka: continuation, successor, direct descendant

A node is a child of another node (its parent) when its text is a direct continuation of the parent's text. A node can have multiple children, because a segment of text can have multiple futures.

When you generate completions with a language model, its completions are children of the last node in the path that composes the prompt. child and its implied inverse parent are the only elementary relation in a tree. Other relations like sibling and subtree are derived from it.

parent

aka: direct predecessor

A node is always the child of its parent (if it has one) and the parent of its children (if it has any).

Currently, in Loom, nodes can only have one parent. However, it is perfectly coherent to imagine that text could have multiple pasts. If a node has no parent, it is a root.

sibling

aka: variation, alternative, counterfactual, alternate completion

Sibling nodes share a parent. In other words, they are continuations of the same text.

When you generate multiple completions from the same prompt, the alternate completions are siblings of each other.

ancestor

aka: predecessor, past (node)

A node is an ancestor of another node if it is in the past of that node: if it is either the node itself, its parent, or its parent's parent, or its parent's parent's parent, etc. The root is an ancestor of every node in the tree.

path

aka: ancestry, timeline, (the) past, past lightcone, branch, prompt, version, playthrough, (world) history

A path through the tree corresponds to a length of text, constructed by concatenating the text of each node in the path, starting from the root. A path is composed of ancestors of the last node in the path, so a path can also be called an ancestry.

When you generate from a node, the prompt is taken from the text of the current path. Since language models have a finite context window, only the last 6000 characters of the path are taken.

The entire path is displayed in the story textbox in Loom, regardless of prompt length or the virtual root.

Each path can be thought of as a version or playthrough of the multiversal story. Alternate paths through a tree may share a past up to a certain point.

subtree

aka: descendants, downstream multiverse, (the) future, future lightcone

Whereas the past of each node is a linear path , its future is a potentially branching subtree.

Unlike the past path, the future subtree does not correspond to any individual piece of text, but a family of potentialities.

Subtrees are an important concept in Loom. They can be collapsed, assigned a chapter, or moved to a different parent.

root

The root node is the node at the top of the tree. It is the piece of text from which all other texts initially branch.

The root node is the beginning of time. It is an ancestor of every node in the tree, and part of every path .

virtual root

aka: subtree root, relative root

In Loom, you can display only a subtree on the map, which is useful when the entire tree is massive. Then, the root of the subtree is called the virtual root or relative root.

Adding or changing the virtual root only affects the tree map, not the story textbox.

See hoisting, collapsing, and portals for more about conditions under which virtual roots may occur.

portal

aka: hole, gateway

When a tree is segregated into subtrees on the map, for example via hoisting / collapsing, a portal appears which you can click to enter different regions of the map. Portals are either afuture portal or a past portal.

future portal

A future portal conceals and offers passage to the future subtree .

past portal

A past portal conceals and offers passage to the past (and its counterfactuals). Clicking on a past portal will bring you to its root in its "parent scope".

If the portal is permanent, such as in the case of chapters, the old virtual root will appear as a future portal to the subtree you were previously in:

If the portal is temporary, such as in the case of hoisting, after going through it you will see the subtree attached back onto its generalized past:

Entering a future portal and entering a past portal are inverse operations: doing one after the other brings you back to the place where you began.

See hoisting, collapsing, and portals to learn how to create and delete portals.

selected node

aka: end of active path, frontier (node)

In Loom, the selected node is the node at the end of the currently visible path and the last piece of text displayed in the textbox. It is colored in black on the map and in the textbox.

active node

aka: focused node, editing node

In Loom, the active or focused node is the node in which the caret (the blinking text insertion cursor) is currently position. It is indicated by a yellow highlight in the textbox and the map and a black blinking border on the map.

The active node is always in the current path, because those are the nodes whose text shows up and can be edited in the textbox.

If the caret is not in the textbox, then no node is active.

branching

aka: forking

Branching is the action of expanding a tree by creating new paths which branch off the existing tree. Adding a new child to an existing node is the elementary operation that constitutes all branching. It is possible to branch from the middle of an existing node, in which case that node is split into two nodes, parent and child, and the new branch departs from the parent.