# 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).

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 $W$ 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 $S$. 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**($T$)**Consensus**($C$)**Rank**($R$)**Emission**($E$)

### Trust

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

$T = W_n^T \cdot S$where $W_n$ is defined as:

$W_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 $R$ is the sum of weighted stake $S$.

$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 $C$ is $\kappa$-centered sigmoid of trust.

$C = \text{sigmoid}(\rho \cdot (T - \kappa))$where:

$\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 $E$ is rank $R$ scaled by consensus $C$.

$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()