Percentile Rank

An important premise. QANTHOS is an analysis and validation tool, not a financial advisor. The examples, formulas and parameters suggested in this guide are educational starting points to illustrate how the tools work, not investment recommendations or “right” configurations valid in absolute terms. Every trader has different capital, operating costs, risk tolerance, experience, broker and objectives. The metrics and filters QANTHOS produces are information, to be interpreted with your own knowledge and experience to reach operational decisions. Thresholds such as “Profit Factor > 1.5 = solid” or “6-month lookback for quarterly rotation” are reference conventions from systematic trading literature: useful as orientation, not as law.

1. The fixed-threshold problem

Anyone developing systematic strategies knows this dilemma well. You want a quality filter: “keep only strategies with Sortino Ratio above X”. But which X?

• Set Sortino > 1.0: in favourable periods everything passes, in difficult periods almost nothing passes and the portfolio stays empty.
• Set Sortino > 0.3: things always pass, but in favourable periods you drag along mediocre strategies too.
• Set Sortino > 0.7: a compromise… but a compromise for which year? The threshold reasonable in 2020 might be too high or too low in 2024.

Fixed thresholds are like driving by looking only at the speedometer, ignoring the road. They work as long as the context stays the same; at the first regime change, problems start.

The Percentile Rank Filter elegantly solves this problem: it shifts the reasoning from absolute to relative. You no longer ask “does this strategy exceed threshold X?” but “is this strategy among the top N% of the group being evaluated right now?”. The threshold becomes self-calibrating, and with it the portfolio selection.

2. What Percentile Rank is, in practice

The mathematical concept is simple but its applications in systematic trading run deep. A strategy’s percentile rank on a metric is a number between 0 and 100 indicating where it stands in the ranking relative to the other strategies in the group.

• A strategy with Percentile Rank Sortino = 99 has a Sortino Ratio better than 99% of the strategies currently evaluated. Practically at the top of the ranking.
• A strategy with Percentile Rank Sortino = 50 is exactly in the middle of the group. It’s median.
• A strategy with Percentile Rank Sortino = 5 is among the worst in the group.

Three important observations:

The percentile is computed on the current universe, not the global one. If preceding filters have already narrowed the initial pool to a smaller subset, each strategy’s percentile is computed on that subset, not on the initial pool. This is a crucial detail we’ll return to below.

The percentile changes from rotation to rotation. In one rotation a strategy might have percentile 95, in the next 60. Not because it changed, but because the group around it may have changed. And this is exactly the mechanism’s power: the filter automatically adapts to the evolving context, without the trader having to intervene.

A precise technical formula: in QANTHOS the percentile is computed as (rank − 0.5) / N × 100, where rank is the strategy’s position in ascending order and N is the total number of strategies in the group. Strategies with identical values receive the same percentile (average rank). The implementation details aren’t important for everyday use, but it’s good to know the calculation is deterministic and repeatable.

3. The Percentile Rank Filter’s two modes

Here lies one of QANTHOS’s most interesting design choices: the Percentile Rank Filter has two distinct behaviours controlled by a single parameter, the threshold. Same interface, same configuration, but two completely different roles in the pipeline. Understanding this duality is key to making full use of the tool.

3.1 Filter mode — threshold > 0

The intuitive behaviour. If you set threshold = 70, the filter lets through only strategies with percentile greater than or equal to 70, i.e. the top 30% of the current universe.

threshold = 70 → only the top 30% passes
threshold = 50 → only the better half passes
threshold = 90 → only the top 10% passes

Practical example. You have a pool of strategies after quality filters — say 100 for simplicity. You set a Percentile Rank Filter on Sortino with threshold = 70. Result: roughly 30 strategies pass, those with Sortino better than 70% of the others. The exact number can vary by one or two due to ties (equal values).

3.2 Injector mode — threshold = 0

This is the less intuitive mode but also the most powerful: it’s the real engine of multi-metric workflows. When the threshold is zero the filter filters nothing, but still computes the percentile for each strategy and “injects” it into its profile, as a special field added on the fly.

It seems counterintuitive at first: what’s the point of computing a percentile if you’re not going to filter on it? The answer opens up the system’s real potential: it serves a Custom Index downstream in the pipeline, which will use it to build multi-dimensional composite rankings. Without Injector mode, percentiles would stay confined to the role of single filters; with it, they become raw material for any ranking formula the trader wants to build.

Visualized (numbers are illustrative, depending on your strategy pool):

[N strategies in input]
        ↓
[Quality filters] → K strategies survive
        ↓
[Percentile Rank Filter on Sortino, threshold=0]
        ↓                ← doesn't filter, but writes the percentile
[K strategies, each with a "pct_sortino_ratio" field = 0…100]
        ↓
[Composite Custom Index using pct_sortino_ratio]
        ↓
[Top M by Custom Index] → M final selected strategies

The Percentile Rank in Injector mode is the playing-field preparer for the Custom Index. It works silently in the background, but it’s the piece that enables the whole multi-metric selection architecture. It’s an example of clean design: a single feature with two well-distinguished modes, each with its precise role.

When do I use one mode or the other? Filter mode when you want a direct cut on a single metric (e.g. “I only want the top 50% by Sortino, regardless of everything else”). Injector mode when you want to combine several metrics into a single ranking, and the Percentile Rank is there to prepare data for a downstream Custom Index. Injector mode is what enables the multi-metric workflows described below; Filter mode is useful for surgical cuts on single dimensions.

3.3 Interface configuration

When you add a Percentile Rank Filter to the Builder, you see these fields:

When you configure a Percentile Rank Filter in Injector mode, remember that the irrelevant fields (Operator, Value, N) will appear visually inactive: they aren’t used, and even if filled in by mistake they have no effect because the filter ignores these parameters when operating as an Injector.

4. The Custom Index — combining metrics into a single ranking

The Custom Index is one of the Builder’s most expressive features. It’s a metric the trader builds custom, combining other metrics with arbitrary weights and formulas. In essence, a “composite quality index” defined by the trader themselves: instead of looking at one metric at a time, several are evaluated together through a formula reflecting one’s own selection philosophy. (The full Custom Index dialog is covered in its own dedicated sub-chapter; here we focus on how it combines with the Percentile Rank.)

4.1 Visual Builder — weighted, with a graphical interface

The Visual Builder is the click-based mode. You add components one at a time, each with its metric (Metric Key), Weight (relative weight), Power (exponent, default 1.0) and Invert (flips the sign, for metrics where “lower is better”). Then you choose a combination method (weighted sum, weighted average, weighted product) and a normalization (none, 0–1, 0–100).

Suited for those who want to experiment quickly without writing formulas. A practical difference from the Formula Editor: the interface automatically handles inversion for lower-is-better metrics (Max Drawdown is inverted under the hood, so strategies with smaller DD get a higher score). This reduces the risk of sign errors, at the cost of less expressive flexibility.

4.2 Formula Editor — Excel-like text expression

The Formula Editor is the mode that unlocks the Custom Index’s full potential. You write a text formula using metric names as variables, exactly as in a spreadsheet:

(pct_sortino_ratio + pct_ulcer_performance_index + pct_k_ratio) / 3

profit_factor * sharpe_ratio / (max_dd_pct + 1)

(net_profit / max_dd_peak_to_valley) * win_rate / 100

The syntax is the standard spreadsheet one: operators + − * / ( ), parentheses, variable names. QANTHOS’s parser validates the formula on the fly and flags unrecognized metrics or syntax errors in real time, avoiding surprises at execution time.

Unlike the Visual Builder, the Formula Editor doesn’t apply automatic inversions for lower-is-better metrics. If you want max_dd_pct to count as “negative in the ranking”, you must put it in the denominator or prepend a minus sign yourself. That’s the price of maximum expressiveness: full control, but also full responsibility for the formula’s logic.

When do I use the Formula Editor instead of the Visual Builder? Every time you use injected percentiles (pct_* fields). The Visual Builder only works on pre-computed standard metrics; injected percentiles are dynamic variables computed at runtime by the Percentile Rank Filter and are only referenced by name in a text formula. Formulas combining percentiles of different metrics — the heart of the Composite Multi-Percentile workflow — must therefore be written in the Formula Editor.

4.3 How the Custom Index combines with the Percentile Rank

This is where the system shows its full elegance. The Custom Index can reference two types of variables, and it’s precisely from combining the two that the mechanism’s real potential emerges:

Standard metrics (e.g. sortino_ratio, profit_factor, max_dd_pct). The value is computed over the lookback period configured for the Custom Index.

Injected percentiles (e.g. pct_sortino_ratio, pct_ulcer_performance_index). The value is read from the field injected by the Percentile Rank Filter applied before the Custom Index in the pipeline.

Fundamental rule: if a formula writes pct_<metric>, a Percentile Rank Filter on <metric> must exist higher up in the pipeline, applied before the Custom Index. Without that upstream filter, the percentile doesn’t exist and the formula produces an error or, in some compatibility edge cases, zero. The order of filters in the Builder therefore matters as much as their configuration: the pipeline is an ordered sequence, not a set of independent elements.

5. An example workflow: Composite Multi-Percentile

Now that we have the two separate pieces, let’s see an example of how they can be composed in practice. What follows is an educational scheme illustrating the tools’ potential, not a recipe to copy mechanically. The specific choices (which metrics, which lookback, how many filters, how many final strategies) depend on your strategy pool, rotation frequency, capital, and objectives.

The three-stage scheme presented here reflects three distinct logical questions that anyone building a systematic portfolio ends up asking, and shows how QANTHOS’s tools naturally combine to answer each one.

Stage 1 — Quality Gate (absolute filters)

Goal: eliminate “non-tradable” strategies based on absolute thresholds. Possible examples:

• Avg Trade / Min Avg Trade > 1.0 over an extended lookback — excludes strategies whose costs exceed average margin.
• Profit Factor > 1.0 over a recent lookback — excludes strategies that have recently lost more than they’ve gained.

Generally these are a few strict filters, designed to reduce the initial pool to a subset of “living” candidates. Choosing which filters to put here and how strict to be is a trader decision: it depends on how large the starting pool is, average strategy quality, and tolerance for the number of candidates to evaluate in later stages.

Stage 2 — Ranking Composite (Percentile Rank + Custom Index)

Here the system’s heart comes into play. Among Stage 1’s survivors, the goal is to pick the best based on a multi-criterion judgement instead of a single metric. An example configuration (among many possible):

1. A Percentile Rank Filter on Sortino Ratio with threshold = 0.
2. A Percentile Rank Filter on Ulcer Performance Index with threshold = 0.
3. A Percentile Rank Filter on K-Ratio with threshold = 0.
4. A Top N by Custom Index, where the Custom Index is the formula (pct_sortino_ratio + pct_ulcer_performance_index + pct_k_ratio) / 3, with N = the desired number of strategies in the final portfolio.

The choice of the three metrics is illustrative: Sortino, UPI and K-Ratio are often cited as a good trio because they measure complementary dimensions of a strategy’s behaviour — risk-adjusted return (Sortino), equity curve quality (UPI) and growth linearity (K-Ratio). But the beauty of the Custom Index is that nothing stops you from building formulas with different metrics, different weights, or more than three components, based on the trader’s priorities.

What happens under the hood is elegant in its simplicity. The three Percentile Ranks in Injector mode compute the percentile of the three metrics on Stage 1’s survivors. Each strategy accumulates three percentile fields. The downstream Custom Index computes the average of the three percentiles, producing a composite 0–100 score. The Top N selects the strategies with the highest composite score. Three distinct stages, each with its role, together producing a much more sophisticated selection system than any single filter.

The result is a ranking rewarding strategies with good values across all three dimensions rather than excellent in just one. Whether this is the behaviour you’re looking for depends on your risk profile: those who prefer to concentrate on a single strong metric can instead give more weight to one dimension (e.g. pct_sortino_ratio * 0.7 + pct_upi * 0.3).

Stage 3 — Diversification (correlation filters)

After the Top N, it can be useful to add the Correlation stage (or a Co-Loss check) to prevent the selected strategies from being substantially correlated with each other — which would reduce the portfolio’s diversification benefit. Whether to include them, and how selective to be, depends on the pool’s composition: portfolios with strategies on very different instruments may need this less, portfolios concentrated on few tickers often benefit from it. Correlations are covered in detail in their dedicated sub-chapter.

A recommendation on lookback

The three Percentile Ranks use a 6-month lookback in this example because we’re building a quarterly rotational portfolio. As a rule of thumb the lookback should be at least 2× the rotation frequency, and in any case wide enough to guarantee a meaningful number of trades for each strategy (roughly no fewer than 30 trades in the period, below which statistical metrics lose reliability).

In practice:

• With monthly rotation, minimum 2-month lookback if strategies are high-frequency, but longer (4–6 months) for low-frequency strategies producing few trades a month.
• With quarterly rotation, 6 months is a good average compromise; portfolios of slower strategies may need 9–12 months.
• With semi-annual rotation, 12-month lookback or more.

The trade-off is statistical: too short a lookback = noisy measurement with few trades, the ranking becomes unstable rotation after rotation. Too long a lookback = the ranking reacts slowly to regime changes, and a strategy that has stopped working stays in the portfolio longer than it should. It’s one of the most important decisions at setup time, and the final choice depends on your pool’s average trade frequency. QANTHOS facilitates this exploration by letting you compare different lookback configurations via Walk-Forward Analysis on the same strategies.

6. Available metrics table

All the metrics listed below are available both in the Percentile Rank Filter as a Target Metric, and in the Custom Index as a formula variable. The Higher column indicates whether high values are better (✓) or worse (✗). The When column suggests in which context the metric is most useful.

The threshold values cited in the descriptions (e.g. “Profit Factor above 1.5 = solid”) are reference conventions borrowed from systematic trading literature. They serve as orientation for those approaching the metric for the first time. A threshold’s validity in your specific case depends on the market, the timeframe, the costs and the strategy: the trader is always the final judge.

6.1 Profitability

6.2 Drawdown and tail risk

6.3 Risk-adjusted return

6.4 Consistency and equity quality

6.5 Returns distribution

6.6 OOS / IS robustness

These metrics compare Out-of-Sample performance (after the strategy’s configured OOS date) with In-Sample performance. Crucial for identifying overfit.

A word of caution on OOS metrics: they only make sense if you’ve correctly configured each strategy’s OOS date in the Strategies tab. Without correct separation they aren’t reliable.

7. Common issues and how to avoid them

The Percentile Rank + Custom Index system is powerful but has three points worth knowing before getting hands-on.

7.1 Filter order

The Percentile Rank Filter (even in Injector mode) must be above the Custom Index using its percentiles. If the order is reversed, the Custom Index will read a percentile field that doesn’t exist yet and produce errors. In QANTHOS filter order is what’s shown on screen, top to bottom: drag filters into the right sequence. The ideal tool to check this is the Filters Analysis Tab, which shows row by row how many strategies each filter lets through and how many it discards.

7.2 Percentile computed on the current universe

This is the least intuitive detail. If you place the Percentile Rank after a strict quality gate, the percentile is computed only on the survivors. Numeric example (exact values depend on your portfolio):

• Initial pool of N total strategies.
• The quality gate eliminates a good portion. K remain (with K < N).
• Percentile Rank Sortino: percentiles range from ~0 to ~100, calibrated on the K survivors.

The practical consequence: a strategy with percentile 95 after the quality gate isn’t necessarily in the top 5% of the initial pool of N. It might have been average in the initial pool, but become “top 5%” among the K survivors. This is not a bug, it’s exactly how it should work: we’re building a ranking relative to the pool of valid candidates, not to the pool of all existing strategies. If you want a ranking over the complete universe, put the Percentile Rank before the quality gates — but that’s generally not what you want.

7.3 Minimum number of strategies

Computing the percentile requires at least 2 strategies in the group. If preceding filters let through 0 or just 1 strategy, the Percentile Rank Filter behaves as a passthrough (strategies pass through unchanged, without injected percentiles). This means that if your pipeline is too restrictive, downstream Custom Indexes will receive strategies without percentile fields and produce zeros. The fix is to loosen the quality gates upstream.

8. Practical Custom Index examples

The formulas below are educational examples showing the syntax and possible combinations. They’re meant to provide a starting point; they aren’t optimal recipes, and in particular they haven’t been validated for your specific strategy pool. Every trader must test and validate their own formulas via Walk-Forward Analysis before putting them into production.

8.1 Composite Multi-Percentile

(pct_sortino_ratio + pct_ulcer_performance_index + pct_k_ratio) / 3

Requires three Percentile Rank Filters (Sortino, UPI, K-Ratio) in Injector mode before the Custom Index. Produces a 0–100 score measuring the strategy’s balance across three dimensions: risk-adjusted return (Sortino), equity curve quality (UPI) and growth linearity (K-Ratio).

8.2 Quality + OOS bias

(pct_sortino_ratio * 0.6) + (pct_oos_is_profit_ratio * 0.4)

Combines Sortino with the OOS/IS Profit ratio, giving weight to strategies that showed continuity between the development period and the following one. An example of a formula where the two components were deliberately weighted differently.

8.3 Smooth Equity Premium

equity_r_squared * k_ratio / (max_dd_pct + 1)

A Visual-style formula: no percentiles, uses metrics directly. Looks for very linear equity curves (high equity_r_squared), with high K-Ratio, and penalizes drawdown percentage. Less adaptive than Composite Multi-Percentile but more immediate to read.

9. Example workflow

For those who want to experiment with the scheme seen in this chapter, here’s an example step sequence. It should be read as an exploration path, not a recipe to apply literally:

1. Open the Portfolio Analyzer → Builder tab.
2. Set one or more absolute quality gate filters (the examples above are just starting points: actual strictness depends on your pool).
3. Add Percentile Rank Filters for the metrics you want in the ranking, with threshold = 0 (Injector mode). Set the lookback based on rotation frequency and your strategies’ trade frequency.
4. Open the Custom Index Manager from the Builder and create a new Custom Index in Formula Editor mode. Write a formula combining the injected percentiles in the way that best represents what you’re looking for.
5. Add a Top N filter for the Custom Index to the Builder, with N = the desired number of strategies in the portfolio.
6. Consider adding the Correlation stage downstream to manage diversification.
7. Generate Portfolio and analyze the result in the Equity and Filters Analysis tabs. Compare Walk-Forward performance against other configurations before deciding.

The Percentile Rank mechanism has the remarkable property of self-calibrating as the pool and market context change: the relative threshold keeps working even when absolute conditions change radically. A valuable property for portfolios that must go through different market regimes without requiring constant manual tweaks. The responsibility of validating that the scheme’s behaviour matches your expectations remains with the trader, through Walk-Forward Analysis, stress testing and monitoring over time: the tool is powerful, but interpretation stays human.

10. To learn more

• Portfolio Rules — the rule chain, lookback settings, scope and money management.
• Custom Index — the full composite-index building dialog (Visual Builder and Formula Editor).
• Correlations — the decorrelation stage and diversification filters.
• Builder tabs — Equity and walk-forward validation, Filters Analysis (reading filters’ rotation-by-rotation impact).