Skip to main content
SUBMIT A PRSUBMIT AN ISSUElast edit: May 24, 2024

Emissions

In this document we describe how the network, via Yuma Consensus, calculates emissions for a subnet. This calculation is based on the weights that are provided by the root network (subnet 0).

Before you proceed

Read the Root Network document before you proceed.

Summary

The emission process works like this:

  • Every block, i.e., every 12 seconds on the Bittensor blockchain, a single TAO (τ\tau) is minted, i.e., newly created.
  • A percentage portion of this single TAO (τ\tau) is allocated to each subnet in accordance with the subnet's performance. The root network determines the percentage portion for each subnet. Hence, all such partial percentage allocations will sum to 100%, i.e., one TAO (τ\tau).
    Taostats

    See the percentage numbers in each "SN" column on the root network page on Taostats. These percentages for all SNs add up to 100.

  • At the end of every tempo, i.e., every 360 blocks in a user-created subnet, the TAO (τ\tau) accumulated for each subnet is emitted into the subnet. This emitted TAO for the subnet is then distributed within the subnet as:
    • Dividends to the subnet validators, and
    • Incentives to the subnet miners.

Before you proceed

Read the Root Network document before you proceed.

In the rest of this document we consider the subnet weights (set by the root validators) as inputs and proceed to present emission calculations as outputs.

Subnet weights, trust, rank, consensus, emission

Read root network metagraph

Consider a snapshot of root network at a given block. You can read the root network metagraph with the below metagraph call:

import torch
metagraph = bt.metagraph(netuid=0, lite=False)
metagraph.weights.shape

Running the above code will give you the shape of the weight matrix of the root network. For example, when total number of subnets are 32 (there is no limit to the number of subnets):

torch.Size([64, 33])

As expected, the shape of the weights reflects the 64 root network validators that set the weights for the example case of 32 subnets. The root network itself is counted, hence 33 in the above output, instead of the example number 32.

You can then read the weights matrix WW from the metagraph as below. See the metagraph API documentation.

# Create a weight matrix with FP32 resolution
W = metagraph.W.float()

Next, read the stake vector SS. See metagraph property S documentation.

# Create "normalized" stake vector
Sn = (metagraph.S/metagraph.S.sum()).clone().float()

Next, we describe how to compute the below quantities that are defined on a subnet.

  • Trust (TT)
  • Consensus (CC)
  • Rank (RR)
  • Emission (EE)

Trust

Trust is defined as a sum of only those stakes that set non-zero weights.

T=WnTST = W_n^T \cdot S

where WnW_n is defined as:

Wn(i,j)={1if W(i,j)>threshold0otherwiseW_n(i, j) = \begin{cases} 1 & \text{if } W(i, j) > \text{threshold} \\ 0 & \text{otherwise} \end{cases}

Python

T = trust(W, Sn)

where, trust() is defined as below:

def trust(W, S, threshold=0):
"""Trust vector for subnets with variable threshold"""
Wn = (W > threshold).float()
return Wn.T @ S

Rank

Rank RR is the sum of weighted stake SS.

R=WTS(WTS)R = \frac{W^T \cdot S}{\sum (W^T \cdot S)}

Python

R = rank(W, Sn)

where rank() is defined as below:

def rank(W, S):
"""Rank vector for subnets"""
R = W.T @ S
return R / R.sum()

Consensus

Consensus CC is κ\kappa-centered sigmoid of trust.

C=sigmoid(ρ(Tκ))C = \text{sigmoid}(\rho \cdot (T - \kappa))

where:

sigmoid(x)=11+ex\text{sigmoid}(x) = \frac{1}{1 + e^{-x}}

Python

C = consensus(T)

where consensus() is defined as:

def consensus(T, kappa=0.5, rho=10):
"""Yuma Consensus 1"""
return torch.sigmoid( rho * (T - kappa) )

Emission

Emission EE is rank RR scaled by consensus CC.

E=CR(CR)E = \frac{C \cdot R}{\sum (C \cdot R)}

Python

E = emission(C, R)

where emission() method is defined as below:

def emission(C, R):
"""Emission vector for subnets"""
E = C*R
return E / E.sum()