word.site

...

A mote is a quantity of gold, used as a unit of value. The amount of gold that one mote represents varies over time: it decays by 2% each year, compounded on a per-second basis. The “initial” value was 1.0 grams of gold on the first second of the year 2000.

More precisely:

1 mote = (0.98 ^ ((t - t0) / y)) grams of gold
  where
    t0 = 946684800  (UTC timestamp of y2k)
    y  = 31557600 (seconds in one year)
    t  = current UTC timestamp

Mr Land’s essay TX2 hints at an approach towards a new gematria that leaves behind problems with the base-ten numerology.

CSW oracles are worse-is-better.

Let’s examine the modal logic of thin client proofs in Bitcoin and in Ethereum.

This post gives a visual description of the UTXO architecture described in post which introduced manaflow. An important characteristic of the extra functionality is that it does not change the asymptotic validation complexity of a UTXO system - it is the same as Bitcoin.

This post is part of a series on how to achieve sublinear-span chain validation for UTXO systems. It is a follow-up to the post on RTXI.

A manaflow transaction is a shardlet.

A shardlet locks exactly the state it needs to continue execution, for exactly as long as it needs it. Shardlets can be validated concurrently and all of their resources are statically declared so they can be scheduled optimally. A beacon shard is an emergent phenomenon that comes from application logic.

The primordial miniflow action is the unique well-formed action which consumes its own output and emits (0,0).

Block 0 has 1 action:
  Action 0 has 1 input and creates 2 spendable outputs (out of 3 total outputs):
    * Input 0 consumes output 0 of 0th action itself.
    - Output 0 emits emits (0,0), which is the output consumed by input 0.
    + Output 1 emits (0,1)
    + Output 2 emits [1-2^256-1].

Double-life fee is a simple model for state rent.

If the chain started at time t0, then an new object (a UTXO or whatever it may be) which is confirmed at time t0 + t expires and can be garbage collected at time t0 + 2*t.

When an object becomes eligible for garbage collection, that means it has existed for more than half the age of the chain.

Pixelfight is a multiplayer minigame and collaborative art piece.

• There are 16 colors
• There is a 1024x1024 pixel arena (1 megapixel)
• A pigment is a colored particle that interacts with a pixel
• 1 pigment costs 1 satoshi, paid to a special OP_TRUE OP_RETURN output

CSW is right that Bitcoin is designed for big blocks in data centers.

The real reason is that Bitcoin’s transactions are logically sequential but validate in logarithmic parallel time.

Soon we will learn team Ethereum was wrong for giving up on UTXO.

Nullary expressions can be represented with two dimensional diagrams. The 2d syntax corresponding to a set of matching parenthesis is simply a circle containing the diagram of the sub-expression.

Below is a table with some example diagrams of basic nullary expressions.

Manaflow is a transaction architecture and processing engine that validates in logarithmic parallel time like Bitcoin while enabling user-defined, consensus-validated state transitions like Ethereum.

This applies to batches of transactions, an entire block, or even the entire chain.

A UTXO system like Bitcoin has the property that transactions are logically sequential but can be validated in polylog-span. This is why Bitcoin is scalable.

To understand the log-time parallel algorithm, it helps to understand how to validate a chain in reverse.

RTXI means Required Transaction Input. The RTXI set is matched against UTXO from “incoming” transactions in reverse order.

(This post is a retro-summary of 4 posts made from 2019-11-24 to 2020-02-01. You can see the precise history in this website’s repository. Latest revision: 2020-02-02)

The glifs are a character set which have a handwritten form (meant for fast writing), a canonical pixel-character form (a sort of runic font), and a dedicated keyboard key (with corresponding ASCII character).

EVM and Bitcoin Script are equally expressive if speaking strictly of which pure functions they can compute. The important way in which the two programming environments are different is unrelated to turing completeness, which has outlived its allowance as a layman’s catch-all for “programmable”.

Suppose these requirements are given for a cryptographic hash function:

1) x != y  ->  hash(x) != hash(y)  (with high probability)
2) hash(x) != hash(y)  ->  x != y  (with high probability)
3) It is intractable to discover x given only hash(x)

None of them prohibit the existince of a fixed point:

Not a rule:  hash(x) != x

base32cx is a base-32 encoding with letter-case checksums inspired by Ethereum’s EIP55.

It is designed for encoding short byte string identifiers as human-skimmable strings, with use cases like file hashes or cryptocurrency addresses in mind.

The alphabet maximizes the number of alpha characters to increase the average number of checksum bits per string.

The rarity of an event is the number of coin flips you need to make an all-heads result as rare as that event.

Rarity is just a new term for (binary) “self-information” or “surprisal”, which is the logarithm of the inverse of the probability of an event.

Rarity uses log2 instead of the natural log because it is intended to be accessible to programmers for back-of-envelope calculations.

Proof-of-work consensus works without a target inter-block time, difficulty, or even a timestamp.

This is called ‘continuous’ or ‘dynamic’ POW.

A minch, or metric inch, is 2.5 centimeters. That’s 127/125 minches per imperial inch.

An imperial foot is 12 inches. A metric foot is 12 minches. That’s 30 centimeters.

An imperial yard is 36 inches. A metric yard is 36 minches. That’s 90 centimeters.

UPDB is a universally unique authenticated key/value store.

UPDB aims to be a base PKI, object ID, and namespacing layer for the next wave of web protocols.

It can be used for:

• assigning numbers to things
• assigning things to symbols
• building signed directed graphs

Nullary is a base-less numeric encoding. Unlike unary, which requires O(n) symbols to encode the number n, nullary encoding still requires just O(log(n)) symbols.

Nullary is the foundation of real numerology.