Pareto Frontier Mechanism

TIG employs a Pareto Frontier mechanism that determines which solutions qualify for rewards. The Pareto Frontier evolves so that as more compute enters the TIG network, we target larger and more difficult instances of the challenge. This mechanism is employed per block and for each challenge individually.

Pareto Dominance and the Pareto Front

Pareto dominance is a concept used to compare solutions across multiple objectives or dimensions. A solution $A$ is said to “Pareto dominate” a solution $B$ if:

• Solution $A$ is at least as good as solution $B$ in all objectives/dimensions.
• Solution $A$ is strictly better than solution $B$ in at least one objective/dimension.

In other words, $A$ dominates $B$ if $A$ is better or equal in every way, and actually better in at least one way.

Given a set of solutions, the Pareto frontier is the subset of those solutions that are not dominated by any other solution. These are the “optimal” solutions where you cannot improve one objective without making at least one other objective worse.

Determining Qualifiers

Challenges in TIG have difficulty parameters that serve as the objectives/dimensions attached to solutions in respect to the Pareto Dominance. Parameters for each challenge can be found in Challenges. At each block we can use this to determine which solutions qualify for rewards.

There is a threshold of 5000 solutions that can qualify for rewards per challenge. If the number of qualifiers exceeds this threshold, then solutions with higher difficulty have greater priority over lower difficulty solutions when determining which solutions are rewarded.

This is implemented using Pareto Frontier Mechanism:

1. Initialize: All benchmarks for a challenge are sorted by difficulty. Set the total number of qualifiers to ${total\_qualifiers}=0$, for each Benchmarker $i$ set their qualifiers to ${qualifiers}_i=0$

2. From the remaining benchmarks, identify those with difficulties on the current Pareto Frontier and add them to a processing list.

3. For each Benchmarker $i$, let $q_i$ be the number of solutions for Benchmarker $i$ in the current processing list:

   • Set $\text{qualifiers}_i+=\min(\text{cutoff}_i-\text{qualifiers}_i,q_i)$.
   • Set $\text{total\_qualifiers}+= \sum_i \text{qualifiers}_i$

4. Remove the benchmarks from the current processing list from consideration for subsequent iterations (these benchmarks remain active and available for the next block’s qualifier determination).

5. Repeat steps 2-4 until the number of qualifiers reaches at least ${threshold\_num\_qualifiers}$

Note: There can be more than ${threshold\_num\_qualifiers}$ qualifiers per challenge, ${threshold\_num\_qualifiers}$ is currently set to 5000, Only the qualifying solutions will affect difficulty and earn rewards. The term ${cutoff}_i$ is the cutoff of Benchmarker $i$ for this challenge.

Difficulty Adjustment

TIG automatically adjusts challenge difficulty range based on the total number of qualifying solutions found by the Benchmarkers. This process happens at every block, such that when a Benchmarker references a block they must choose a difficulty setting within that blocks difficulty range.

The scaling factor determines how difficulty should change:

The difficulty adjustment is then a two step process:

Step 1: Identify the Easiest Qualifying Frontier:

Find qualifying solutions that form the lowest difficulty Pareto frontier, these are solutions dominated by all other solutions but not by each other. This set of points is defined as the ${easiest\_qualifying\_frontier}$.

Step 2: Create Base and Scaled Frontiers:

The frontiers are sets of points where each point represents difficulty coordinates. When we scale a frontier, we multiply each coordinate of every point in the set by that scale.

• If ${scaling\_factor} \geq 1$:

Set

• If ${scaling\_factor} < 1$:

Set

Update

Then:

When precommitting to a benchmark, a Benchmarker’s difficulty setting is considered valid if it:

• Does not Pareto dominate the ${scaled\_frontier}$ (not too easy)
• Is not Pareto dominated by the ${base\_frontier}$ (not too hard)

This creates a “difficulty corridor” that automatically adjusts based on network performance, ensuring challenges remain appropriately challenging as the compute in the network grows.