# Emission weights (/docs/concepts/emission-weights)

Every subnet carries a five-slot **emission weight vector**

```
[burn, recycle, owner, validator, miner]
```

that says how each block's alpha emission is divided. Each slot is a `u64`
share of `u64::MAX`, so the five slots sum to exactly one. The subnet owner
(or root) sets it with
[`set-subnet-emission-weights`](/docs/tx/set-subnet-emission-weights); anyone
reads it with [`subnet-emission-weights`](/docs/query/subnet-emission-weights)
or `btcli subnets emission show`.

New subnets start at the historical split — `[0, 0, 0.18, 0.41, 0.41]` on
mainnet — so nothing changes until an owner decides it should.

## What each slot does [#what-each-slot-does]

| Slot | Name        | Paid to                                                        | v1 rule                                                         |
| ---- | ----------- | -------------------------------------------------------------- | --------------------------------------------------------------- |
| 0    | `burn`      | nothing — alpha is destroyed                                   | must be 0 (reserved)                                            |
| 1    | `recycle`   | nothing — alpha returns to the unissued pool                   | must be 0 (reserved)                                            |
| 2    | `owner`     | the subnet owner's hotkey at each epoch                        | `0 ≤ owner ≤ 0.33`; lease-created subnets `≥ 0.18`              |
| 3    | `validator` | validator dividends (root TAO stakers are paid from this slot) | `validator ≤ 0.50`, and root's baseline share must be reachable |
| 4    | `miner`     | miner incentive, split across the subnet's mechanisms          | `miner ≥ 0.33`                                                  |

The owner slot at zero means "no owner cut"; the legacy `owner_cut_enabled`
hyperparameter is now simply `owner > 0`. Burn and recycle are present in
the vector so the format does not change when they are enabled later, but a
non-zero value in either is rejected today.

Per block, `alpha_out × owner` accrues to the owner, `alpha_out × validator`
to the validator bucket and `alpha_out × miner` to the miner bucket. Root's
share is carved out of the validator bucket by the subnet's consensus-side
root proportion (`consensus_root_proportion` in
[`block_step.rs`](/code/pallets/subtensor/src/coinbase/block_step.rs)), so
shrinking the validator slot would, on its own, shrink what root TAO stakers
receive. The effective TAO weight below prevents that.

## The effective TAO weight [#the-effective-tao-weight]

Root TAO is weighted against alpha by a TAO weight `w`. Each block, root's
alpha on a subnet is

```
root_alpha = V × x / (x + A) × alpha_out        with x = root_tao × w
```

where `V` is the validator slot and `A` the subnet's alpha issuance. Every
subnet carries its own **effective TAO weight** `w_s` (`SubnetTaoWeight`),
used on the **consensus side** of that subnet only: the root share carved out
of the validator slot, the TAO-vs-alpha split of validator dividends, and the
stake weighting inside Yuma Consensus. A subnet with no entry simply follows
the global `TaoWeight` (0.18 on mainnet today), exactly as before emission
weights existed.

Every accepted set call solves `w_s` **once**, at that block, from live chain
values and the new validator slot alone:

1. root's **baseline** share of emission, `r = V0 × x_g / (x_g + A)` with
   `x_g = root_tao × TaoWeight` — what root would earn on this subnet right
   now with the default validator share `V0` (0.41 on mainnet, derived from
   the default owner cut) and the global `TaoWeight`;
2. the weight that pays `r` under the new slot,
   `x_new = r × A / (V_new − r)`, `w_s = x_new / root_tao`.

Root TAO stakers therefore earn, the block after any change, exactly what an
untouched subnet would pay them at that block. The solve never reads the old
vector or the old `w_s`, so an owner cannot ratchet root's share by raising
`V` while the subnet is young and lowering it later: the target is recomputed
from scratch every time, and a round trip (raise `V`, let issuance grow,
lower it back) lands on the same `w_s` as making the final change in one
step. Afterwards `w_s` is left alone and everything scales with stake and
issuance as usual, until the next set. Setting `V` back to exactly `V0`
clears the entry, so the subnet follows the global `TaoWeight` again (the
solve would land there anyway).

The weight is capped at one — root TAO never counts more than 1:1 against
alpha — so not every `V` is reachable. The call fails with
`ValidatorEmissionTooLowToPreserveRoot` when `V_new ≤ r` or the solved
weight would exceed one; equivalently the floor at this block is
`r × (1 + A / root_tao)`. On a mainnet subnet with 5.4M TAO on root, 6.5M
alpha issued and `TaoWeight = 0.18`, the validator share can go down to about
11.8%. The floor moves with root stake, issuance and the global weight, so
`btcli subnets emission show` prints the current value. With no root stake
or no alpha issued there is nothing to preserve: any valid `V` is accepted
and `w_s` is untouched.

The **pool side** never sees `w_s`. `tao_in`, `alpha_in` and the
alpha-injection cap in `get_subnet_terms` use the pool-side
[`root_proportion`](/code/pallets/subtensor/src/coinbase/block_step.rs) with
the global `TaoWeight`, exactly as before emission weights existed. Changing
a subnet's vector changes how its alpha is distributed; it does not change
how much TAO or alpha is injected into its pool.

## Changing the vector [#changing-the-vector]

Updates are **sparse**: name the slots you are changing and their new shares;
omitted owner/validator/miner slots keep their current value. Because the
five slots must still sum to one, lowering one slot means raising another in
the same call. `btcli` does the arithmetic:

```bash
# see the vector, root's share and baseline, every allowed range, and the next change window
btcli subnets emission show --netuid 12

# set one slot; the other two are rescaled proportionally
btcli subnets emission set-value --netuid 12 --slot owner --value 0.10

# nudge one slot up or down
btcli subnets emission increase --netuid 12 --slot miner --by 5%
btcli subnets emission decrease --netuid 12 --slot validator --by 0.02

# write the whole split at once
btcli subnets emission set --netuid 12 --owner 0.10 --validator 0.40 --miner 0.50
```

Every write validates against the rules locally first and prints each broken
rule in the same words the chain error carries, with the allowed range, so a
rejected change teaches the constraint. Add `--dry-run` to preview the plan —
the before/after vector, root's share now and after (its baseline), and the
resulting effective TAO weight — without signing; add `--json` for the same
as a machine-readable record.

Owners may change the vector **once per week** per subnet (50,400 blocks).
The limit is keyed by subnet, not by owner coldkey, so handing the subnet to
a new owner does not reset it; the first change on a subnet is never
rate-limited, root is exempt, and dissolving a subnet clears the key so a
reused netuid starts fresh. Both owner and root must obey every rule,
including the lease floor. Changes take effect on the next block's emission
and are announced by the `SubnetEmissionWeightsSet` event, which carries the
full post-merge vector.

## Related [#related]

* [Emissions](/docs/concepts/emissions) — the full per-tempo flow
* [`owner_emission`](/docs/hyperparameters/owner-emission),
  [`validator_emission`](/docs/hyperparameters/validator-emission),
  [`miner_emission`](/docs/hyperparameters/miner-emission)
* [`set-subnet-emission-weights`](/docs/tx/set-subnet-emission-weights) — the intent
* [`subnet-emission-weights`](/docs/query/subnet-emission-weights) — the read