How PolyScore Is Calculated

High-level summary

One score, updated each time a signal is verified.

Every time one of your signals is verified, we compute a performance score \(S \in [0, 1]\) for that signal and update your PolyScore using an ELO-like rule:

R_new = R_old + K × (S - E)

• R is your PolyScore (0–100), starting at 50.
• K is the sensitivity (currently 10).
• S is how well this specific signal performed (0 = terrible, 1 = outstanding).
• E is the expected performance based on your current PolyScore.

If a signal does better than expected (S > E), your PolyScore goes up. If it underperforms (S < E), your PolyScore goes down. The higher your score already is, the harder it becomes to move it further up.

Per-signal performance score S

We blend direction and % move into a single score.

For each verified signal, we currently use two components:

• Direction (D): Was the prediction direction correct? (LONG vs SHORT)
• Magnitude (P): How strong was the move, in percentage terms?

Direction component:

D = 1 if the prediction was correct (the signal is verified as is_correct = true), otherwise D = 0.

Magnitude component (based on the verified accuracy percentage):

From the verification step we have accuracy_percentage, which measures how far the outcome moved in the predicted direction. We normalise its magnitude as:

P = 0 if the signal was incorrect or the move was non-positive in the predicted direction.

Otherwise:

P = min(|accuracy\_percentage| / 100, 1.0)

This means:

• +5% move in the right direction → P = 0.05
• +50% move in the right direction → P = 0.50
• +100% or more in the right direction → P = 1.0 (capped)

Blended performance score:

We combine direction and magnitude as:

S = 0.7 × D + 0.3 × P

Direction correctness drives most of the score, while larger profitable moves add extra credit.

ELO-style update and score bounds

Higher PolyScore means we expect you to produce strong signals.

PolyScore is bounded between 0 and 100 and starts at 50 for every user. For each verified signal, we compute:

E = 1 / (1 + 10^{(BASE - R) / 400})

• BASE = 50 is the neutral anchor.
• R is the current PolyScore.

If your PolyScore is above 50, we expect you to perform better than average (E moves closer to 1). If it’s below 50, expectations are lower (E moves closer to 0).

The final update is:

R_new = clamp( R_old + K × (S - E), 0, 100 )

• K = 10 controls how fast the rating moves.
• S - E is positive when you outperform expectations, negative when you underperform.

As scores get higher, expectations increase and each additional “good” signal moves the score less. Conversely, a large, incorrect call from a highly-rated user can move the score down more sharply.

Design rationale & future extensions

Why we chose this structure, and what might evolve.

• Direction first. Getting LONG vs SHORT correct is the foundation. That’s why it receives most of the weight (70%) in S.
• Magnitude matters. Among correct calls, larger percentage moves represent higher information content and are rewarded via P.
• Bounded & interpretable. A 0–100 scale with a 50 baseline is easy to compare across users over time.
• Order-aware but time-stable. Signals are processed in verification order; we don’t currently decay older signals, but can introduce recency weighting later if needed.

In the future, we may add an explicit entry-price-based profit component once we record entry prices for all signals. That would allow us to distinguish between:

• “Right direction, but tiny move” vs.
• “Right direction, very strong move from entry price.”

The current design already moves in this direction by using the magnitude of the verified percentage move, while keeping the system simple, bounded, and robust enough for live use.