What’s a DAO?

## What’s the context?

This document’s table of contents:

* What’s the context?
  * What’s the definition of a DAO?
  * What’s the initial historical reference point?
  * What’s a World computer?
  * What’s a VM-DLT asset?
* What’s a DAO to a legal engineer?
  * multisignatory shared possession of by-proxy and by-corpus assets
  * outsource governance to machines with deference or equivalence
  * What’s code-deference?
  * permissionless arms-length business reliance using composability
* What’s a soul-DAO?
  * DAO as OS
  * What’s the OS of a World computer VM-DLT?
  * community DAO and personal soul-DAO
* references

### What’s the definition of a DAO?

Legislation might officially restrict the definition of DAO to a legal test but originally the word DAO literally meant Decentralized Autonomous Organization.

The word DAO has quickly become a neologism for an organization that engages with the by-corpus asset class defined below, often as a method of signaling to consumers that the organization engages with Non-Fungible Token “NFT” commerce.

Phenomenologically, these definitions of a DAO seem to be more derived from market pressures than from fundamental insights through careful *a posteriori* deconstruction.

### What’s the initial historical reference point?

The Internet is continuing to mature its life cycle by solving harder and harder behavioral wealth network effect problems with each generation, and this time the problem is generating and managing consumer grade liquidable assets on the Web.

In the 1980s and 1990s, Web1 figured out how to generate( read ) behavioral wealth network effects.

In the 2000s and 2010s, Web2 figured out how to generate( read, write ) behavioral wealth network effects.

And in the 2020s as well as perhaps 2030s, Web3 is figuring out how to generate( read, write, own ) behavioral wealth network effects.

### What’s a World computer?

Web3 infrastructure uses Turing complete Distributed Ledger Technology “DLT” that networks together a public access World computer.

Using a corpus-classification analogy, each personal computer is like a cell in a human body and a World computer is like the human body.

* Not all DLTs are the same and a public access World computer’s stack relies on multiple types of DLTs that produce a composited functionalities structure.

The most public DLT layer of a public access World computer is also its floor layer, and is a single Virtual Machine DLT “VM-DLT” computational state shared by all personal computers on the network.

For the right price, aspects of the “VM-DLT” on a public access World computer can be permissionlessly modified by any personal computer with a variety of cryptographic constraints.

### What’s a VM-DLT asset?

The more publicly arms-length, numerous and distributed-consensus the plurality of personal computers in the network, the more mechanistically trustworthy the VM-DLT as well as the more free market the VM-DLT.

However, the mechanistic trustworthy free market advantage of a VM-DLT is exponentially more costly to run than traditional networks because it requires far more steps to complete the same outcome, and each of those steps must be multiplied by byzantine fault network redundancy.

So, the most mechanistically trustworthy VM-DLTs are best used when conveying only the legal title and title state change for the high value assets virtualized by a public access World computer, just the basics compared to more complicated privity such as beneficial rights.

Legal title in this context includes traditional legal title concepts as well as tokenomic innovations about the types of objects that have title, for instance the NFT *sui generis* IP discussed below.

* Assets can be high value because they’re **by-proxy** valued in other markets and a VM-DLT is an outsourced mechanically trustworthy accounting wrapper that includes free-market liquidity access.

If the proxied market is a niche market, VM-DLT provides an opportunity to trade a

What's a loop? Scaletiled spirals [ discrete, continuous, vanishing point ]

### This \~8 minute read explains important fundamentals of “spacetimescale” logic.

## What’s a scaletile?

There are a variety of ways to discretely tile objects to create a continuous, flat and finite plane.

For instance, this is a Cartesian method that does it.

![A Cartesian method, with a unit circle superimposed.](https://images.mirror-media.xyz/publication-images/qgMemb0BgBNTkF0-C3qIq.png?height=1000&width=1000)

And this is a “Golden” method that does it.

![A Golden method, with a 4-color theorem non-sequential order.](https://images.mirror-media.xyz/publication-images/03wcjOwcmwGTC48wTxwrU.png?height=1615&width=1000)

That Cartesian method uses 1 tile size whereas this Golden method uses Infinite tile sizes.

Further, this Golden method uses 1 scale for its Infinite tile sizes; as such, its tiles are “scaletiles.”

# what’s a scale?

Like a tile’s size, scale is a magnitude; but scale is the magnitude that modifies the size of a tile.

In other words, size is the variant magnitude and scale is the invariant magnitude.

This Golden method must use the `((5^(1/2))-1)/2` scale in order to fixate Infinite tile sizes on a continuous, flat and finite plane.

For instance, if the Golden method attempts `1/2` scale, there’s a gap and the plane isn’t continuous.

![A Golden method 1/2 scale attempt, with a gap in the plane.](https://images.mirror-media.xyz/publication-images/KBbaB_BTqll1cSCCV3S2L.png?height=1503&width=1004)

# what’s a tile?

A tile’s size doesn’t need to have a 2:2 ratio.

For instance, a size of 4:2 ratio continuously tiles the plane with `((5^(1/2))-1)/2` scale.

![A Golden method using tiles of 4:2 ratio, with a 4-color theorem non-sequential order.](https://images.mirror-media.xyz/publication-images/P9mrQ1-fpGZaf7cKsKxcP.png?height=1621&width=2004)

But ratios other than 2:2 have asymmetry and, as such, include a rotation property.

For instance, the 4:2 ratio can rotate into the 2:4 ratio.

If a size of 4:2 ratio attempts `((5^(1/2))-1)/2` scale while rotating for each size change, there’s a gap and the plane isn’t continuous.

![A Golden method using tiles of 4:2 ratio, attempting to rotate into 2:4.](https://images.mirror-media.xyz/publication-images/nMBYp0-tIKStfMONSGOiq.png?height=2239&width=2004)

# what’s a rotation scale?

Using observational evidence, the formula that determines scale for the simplest form of tile rotation is the `(c-b)/a` method.

`a`, `b` and `c` are the Pythagorean Theorem `(a^2)+(b^2)=(c^2)` variables.

Furthermore, because of design considerations, a tile uses the `a` and `b+b=2b` variables rather than the `a` and `b` variables.

For instance, a tile size of 4:2 ratio continuously tiles the plane with rotation using `((17^(1/2))-1)/4` scale.

![A (c-b)/a method using tiles of 4:2 ratio, with a 4-color theorem sequential order.](https://images.mirror-media.xyz/publication-images/OBNYvLgksjw01Vv2GkOmI.png?height=1280&width=1000)

And that plane is also a tile size of `2+(4*(((17^(1/2))-1)/4))`:4 ratio, which continuously tiles the plane with rotation using `(sqrt(2(11 + sqrt(17)))-2)/(1+sqrt(17))` scale.

![A (c-b)/a method "child" using tiles of a preceding (c-b)/a method "parent."](https://images.mirror-media.xyz/publication-images/nfRd-E9SnZicmJFiR1FrL.png?height=1679&width=1147)

Or reorganizing the `(c-b)/a` method “child” and “parent” along a bottom right corner “limit,” rather than tending along a spiral pattern.

![The previous (c-b)/a method "child" and "parent" nesting, with a different spatial order.](https://images.mirror-media.xyz/publication-images/e8iZiAsI4FbmW0bs15NqO.png?height=1678&width=1147)

# what’s a (c-b)/a method?

The philosophical concept is that the `c` “irrational” length of the hypotenuse in a right triangle embodies an Infinite energy within a “field of view.”

And at the heart of this perpetual nature of `c` is the square root of natural numbers.

The fact `c` usually doesn’t share a “measure” in common with `a` or `b` is an inherently recurs

What's a syntax? MonolithicModulation script. [ Solidity, SeedTree, fixation ] 

### This \~8 minute read explains how to structure a basic “beget.sol” Solidity smart contract dataset using SeedTree organizing principles.

## What’s Solidity?

Solidity is the most popular language that directly instructs the Ethereum Virtual Machine (“EVM”). Solidity is Turing-complete “contract source code.”

Solidity is a relatively unique language, and for good reason.

In most Turing-complete machine environments, the machine does not charge a transaction fee to run a command. However, in an EVM environment, the machine does charge a transaction fee to run a command.

This means writing and rewriting stored datasets also requires transaction logic, and that extra logic has a substantial impact on which types of generalized patterns work well with Solidity.

[Here](https://opensea.io/assets/matic/0x36a8377e2bb3ec7d6b0f1675e243e542eb6a4764/7893) is an example of how this transaction logic “*laissez-faire*” remedied the harm CryptoKitties accidentally caused when it became too viral for EVM to handle. Because of this economic correction, there was no need to restart or fork EVM.

## What’s SeedTree?

SeedTree is a high-level language abstraction philosophy. The philosophy is an evolving mixture of theory and practice that includes the following organizing principles:

* Algebraic text is the universal interface. (minimalism)
* Distinguish verbs from nouns as much as possible. (aeffect)
* Nonhalting can be positive or negative, depending on context; halted can be positive or negative, depending on context. (flow)
* A { key (pointer)→ value } pair \[including an arrayed `n++` key\] is the lowest level object. (link)
* Information is recursive and information is fractal. (LIFO-forest)
* The first instance of a recursion has a unique position. (FIFO)
* These organizing principles should facilitate as unopinionated as possible simple-&-easy processes that extend a namespace without increasing the risk of name collision. (loci)

The SeedTree philosophy began by exploring how to better abstract the JavaScript language, a language that does not charge a transaction fee to run commands.

## What’s beget.sol?

This beget.sol script is running [here](https://rinkeby.etherscan.io/address/0x72c3B81e1Ee7eb85BfB80D69439996F077E6f1e8) (initialized) and [here](https://rinkeby.etherscan.io/address/0x6b7ED46374Bcfb2171E7C474fDe3c7732a9EA684) (not yet initialized).

### beget.sol

```
000 | // SPDX-License-Identifier: GPL-3.0
001 | pragma solidity >=0.7.0 <0.9.0
002 | ;
003 | contract dataset {
004 |     function child( string calldata $0 ) external {
005 |         require(
006 |             _x[ 0 ].initialized
007 |             , 'NOT_YET_INITIALIZED'
008 |         )
009 |         ; _x[ 0 ].count ++
010 |         ; x[ 0 ] = _1(
011 |             _x[ 0 ].count
012 |             , _x[ 0 ].publisher
013 |             , _x[ 0 ].text
014 |             , 3
015 |         )
016 |         ; x[ _x[ 0 ].count ] = _1(
017 |             _x[ 0 ].count
018 |             , msg.sender
019 |             , $0
020 |             , 4
021 |         )
022 |         ;
023 |     }
024 |     constructor() {
025 |         _x[ 0 ].count = 0
026 |         ; _x[ 0 ].initialized = false
027 |         ; _x[ 0 ].publisher = msg.sender
028 |         ; _x[ 0 ].text = 'hello world'
029 |         ;
030 |     }
031 |     function parent( string calldata $0 ) external {
032 |         require(
033 |             msg.sender == _x[ 0 ].publisher
034 |             , 'NOT_PUBLISHER_CANNOT_EDIT'
035 |         )
036 |         ;
037 |         if ( ! _x[ 0 ].initialized ) {
038 |             _x[ 0 ].initialized = true
039 |             ; _x[ 0 ] = _0(
040 |                 _x[ 0 ].count
041 |                 , _x[ 0 ].initialized
042 |                 , _x[ 0 ].publisher
043 |                 , $0
044 |                 , _x[ 0 ].text
045 |             )           
046 |             ; x[ 0 ] = _1(
047 |                 _x[ 0 ].count
048 |                 , _x[ 0 ].publisher
049 |           

https://mirror.xyz/ZKORQwl7i-BZJGXWp5HZtV02PuzaGhFzDut9iDfxbyI

What's a poem? Natural integer counts. [Amulet, mathart, cyber]

### This \~8 minute read explains how to make “Beyond Mythic” Amulets!

## What’s an Amulet?

Amulets can be seen as a fun way to understand proof-of-work. As described in the [Bitcoin whitepaper](https://bitcoin.org/bitcoin.pdf), “proof-of-work involves scanning for a value that when hashed, such as with SHA-256, the hash begins with a number of zero bits.”

According to [at.amulet.garden](https://at.amulet.garden/), “an Amulet is a kind of poem that depends on language, code, and luck: (1) its complete Unicode text is 64 bytes or less; and (2) the hexadecimal SHA-256 hash of the text includes four or more 8s in a row.”

Moreover, “the odds a person can type something into the scratchpad and discover an Amulet are very, very, very, VERY low! It’s much more practical to ‘discover’ amulets with a computer program.”

Therefore, an Amulet can be described as a computationally rare input/output “two-sided coin” type poem, a “cyberpoem” of sorts: (1) the “input-side” text is arbitrary; and (2) then the “output-side” text is the hash of the input-side text.

Though Amulet rules don’t require it, the input-side text of the Amulet is often used as the only part of the Amulet that fixates poetic expression, with the output-side text as nothing more than a randomized content filtration system. 

For instance, [here’s](https://opensea.io/assets/0x2a2127753653f6210d26f5b470738bf13b73423d/83636142006508904423188891589673043209541830599763770029880589240090058114014) a “Legendary” Amulet ‘discovered’ in a public domain book of poems: “**[Tight straps his short trews to meet shiny boots drew,](https://etherscan.io/tx/0xf59f556ba4843ab936bd923fd561f4122fc9095109d86b9509490fe5d76fb105)**”

This is cool, but Amulets have the potential to be much more “cyberpoetic.”

## What’s an Amulet’s cyberpoetic potential?

Amulets can be more than just “poems with a randomized content filtration system;” the interplay between the input-side text and the output-side text offers us a new source of poetic expression fixation via “cyberpoetry.” 

To access these cyberpoetic input/output expressions, all we have to do is design a “suffix” natural integer count method for Amulets, inspired by the pinpoint citation method.

### What’s pinpoint citation?

The pinpoint citation method, used by the Supreme Court of Canada when they publish their reasons for judgment, gives each paragraph a natural integer count index as it appears in sequential order.

It might not seem like an important library science innovation but, because the pinpoint citation method is unopinionated about page size, it can be included in page dynamic HTML publications without issue, unlike page numbering methods. 

Indeed, many program languages such as JavaScript and Python are designed around the “while-loop” concept, so pinpoint citation is easy to express with those languages. 

### What’s an Amulet suffix?

Applying the pinpoint citation method to Amulets, in part by recognizing that natural language and integers need not be separate expressions, we can append a cryptographic salt “suffix” to the end of the arbitrary input-side text for an elegant and consistent method that generates Amulets of any given rarity.

For instance, [here’s](https://opensea.io/assets/0x2a2127753653f6210d26f5b470738bf13b73423d/60154779877270476611854149148223647424449371560527823271803216421029602912390) the first Amulet I minted with this suffix method, a “Beyond Mythic” Amulet using “ #” as the suffix’s initiating text: “**[The art and science of a win-win game. #6370414414](https://etherscan.io/tx/0x75456e3a125e904e80c9b8f62bcec920aacc8776305bece72053309805d3ee94)**”

The “generating script” is very simple. A while-loop spins along the natural integer count, appending each suffix attempt to the end of the arbitrary input-side text one-by-one until the script finds an Amulet with the specified rarity. For “**The art and science of a win-win game. #6370414414**,” it took 6370414415 while-loop calls until the ge

What’s the context?

This ~8 minute read explains important fundamentals of “spacetimescale” logic.

What’s a scaletile?

This ~8 minute read explains how to structure a basic “beget.sol” Solidity smart contract dataset using SeedTree organizing principles.

What’s Solidity?

This ~8 minute read explains how to make “Beyond Mythic” Amulets!

What’s an Amulet?