Common strategy baselines

The Python project uses the same eight signal rules in a caller-owned next-open-to-close comparison. The Compiled project executes their native foundational SFD across all eight candidates. Their desired signals agree; their trading policies differ and their returns must not be compared as if the accounts were equivalent.

Prerequisites

• A Limen checkout or installed package; use the data extra for automatic market-data fetching.
• Recorded, chronological bars with finite positive close prices; Donchian also needs high and low.
• A declared bar interval, evaluation window, execution convention and cost scenario.

The catalogue is a set of declared baseline choices. Its parameters have not been selected for profitability on the bundled observations. All periods below count input bars: a 20-bar lookback means 20 hours on hourly observations, and five hours on 15-minute observations.

Rules and defaults

Each rule produces a completed-bar desired position: 1 for long and 0 for flat. The catalogue includes no short exposure, leverage, pyramiding or learned parameters.

The SMA, EMA, MACD and momentum variants are regime rules: they can enter at the first row with valid indicator history if the long condition already holds. They do not require an earlier observed cross. The RSI, Bollinger and Donchian variants maintain their position between their separate entry and exit events; an entry is not a one-bar pulse. An exit wins if both events coincide.

EMA starts from an SMA seed and uses alpha 2 / (period + 1). RSI uses Wilder smoothing with alpha 1 / period. MACD uses Limen's TA-Lib-compatible initialization. Bollinger standard deviation uses ddof=0. Both Donchian channels exclude the current bar, so today's high cannot move the threshold that today's close must break.

These families are described in the primary implementation and author sources below. The exact trading variants and lookbacks in this table are Limen's declared comparison settings. In particular, the momentum baseline is a 20-bar long/flat adaptation, and the Bollinger entry/exit rule is a selected mean-reversion variant; neither is a reproduction of the source authors' complete strategy.

Run the eight-strategy grid

The installed CLI exposes the common_strategies template through limen init; see the command reference. Its native foundational entry points are:

1def params() -> dict[str, list[str]]:2    ...

1def manifest() -> Manifest:2    ...

The template fetches real hourly observations for calendar year 2024 from the configured Limen source. Its explicit date splits are January through September for training, October for validation, and November through December for testing. Fee is 10 basis points and slippage is 5 basis points on each entry and exit fill. These are explicit scenario assumptions, not measured costs. Execution uses the existing snapshot backtest's one-bar lag and final-exit convention; see Backtest.

When no dataframe is supplied, the Python SFD requests hourly calendar-2024 data in both normal and test mode. Supplying data= uses those recorded rows directly, without fetching either source. The benchmark always supplies its explicit fixture data; it does not depend on a changing latest-data window.

The Compiled project reads the complete recorded hourly fixture through common_strategies.yaml, with explicit January–September training, October validation and November–December testing windows. It runs all eight candidates through the CLI and retains native execution records. The historical factory benchmark below has its own row-count split and is not the current YAML result.

1schema_version: "1.0"2 3metadata:4  name: common_strategies5  mode: development6  description: Eight fixed long-flat strategy baselines with causal indicator history7 8sfd:9  manifest:10    type: rule_based11    data_source:12      method: limen.data.HistoricalData.get_any_file13      params:14        file_path_or_url: inputs/spot_1h_20240101_20241231.parquet15    required_columns: [datetime, open, high, low, close]16    split_dates:17      train_start: "2024-01-01"18      train_end: "2024-10-01"19      val_start: "2024-10-01"20      val_end: "2024-11-01"21      test_start: "2024-11-01"22      test_end: "2025-01-01"23    indicators:24      - func: limen.features.common_strategy_positions.common_strategy_positions25        params:26          strategy: "{strategy}"27    strategy:28      conditions:29        - id: common_strategy_long30          name: Common strategy requests long31          type: threshold32          column: common_strategy_position33          operator: ">"34          value: 035      entry: common_strategy_long36    reference_architecture: limen.sfd.reference_architecture.rule_based.rule_based37    backtest:38      fee_bps: 10.039      slip_bps: 5.040  params:41    strategy:42      - buy_and_hold43      - sma_cross44      - ema_cross45      - macd46      - rsi_mean_reversion47      - bollinger_mean_reversion48      - donchian_breakout49      - time_series_momentum50 51uel:52  output_path: compiled-common_strategies53  record_execution: true54  checkpoint_interval: 155  recording:56    predictions: true57    alignment: true58    trade_ledger: true59    fold_details: true60  n_permutations: 861  search_strategy:62    type: grid63  output_format: csv

params() has one categorical axis, strategy. A candidate chooses one complete fixed configuration, avoiding combinations of irrelevant parameters from different strategies. The result includes each split's position rate, entry count, backtest metrics, executed-trade count and mean compounded net PnL per executed trade. A strategy with no executed trades has a zero trade count and an undefined mean trade PnL; it is not evidence of a zero-risk return. The project summary keeps finite activity/mean-bar fields and the complete execution tracks, while the native artifacts retain their original metric values.

Current project results

The Python comparison evaluates 1,598 hourly observations from its row-count partition, with 2 bp per one-bar trade. Its mean net return is a decimal per evaluated next bar:

The Compiled comparison evaluates the 1,464 hourly observations in November–December 2024, with 10 bp fee and 5 bp slippage per entry and exit. Its mean net PnL is in basis points per assessment bar; executed trade counts describe held-position episodes. The proof independently reconstructs the native net track and its costs. These populations and policies differ, so the two tables are not a performance ranking between interfaces.

Recorded costed results: 2026-10-18

The historical offline UEL campaign completed all eight candidates on the recorded 2024 hourly BTCUSDT fixture. Its 8:1:2 row split allocated 6,388 bars to training, 798 to validation and 1,598 to testing. The test window ran from 2024-10-26 10:00 through 2024-12-31 23:00 UTC. These are the Python manifest's row-count boundaries; they differ from the YAML template's date boundaries.

The following test results include the native snapshot's 10 bps fee and 5 bps slippage per fill, one-bar exposure lag and final liquidation. Signals observe the completed close, and fills use that same close under the declared idealized execution contract. Indicator history and held state restart at the test boundary.

Total return compounds the persisted per-bar net returns from unit initial equity. Maximum drawdown is the worst peak-to-trough decline of that resulting equity path; it is distinct from the native drawdown_bps_p5 percentile. Bars held is the fraction of test bars with executed long exposure, including the initial warm-up population. The verification report records the checks against all eight persisted execution arrays, and the result CSV retains the unrounded values.

Buy-and-hold returned the most in this rising test window; EMA was the strongest active baseline by total return. The table also shows that less market exposure and fewer trades do not by themselves identify the best result. These are observations from one recorded instrument and window using fixed settings, not parameter-selection evidence or a live-return forecast.

The run used Python 3.12.14 and Limen 5.34.0. The frozen source is reproducible from revision 8640fd3bc378413d6fde4afa97fce188f60ad94f. That revision association was documented after execution; the native artifacts did not retain an execution-time Git revision or source-code digest. The source provenance record preserves this limitation explicitly. Cross-engine zero-cost correctness and timing measurements are reported separately in Backtest engine benchmarks.

Python Research and the pure signal API

The Python project calls the shared signal function directly on the same 1,598 assessment bars. It owns independent one-bar trades, entering the next open and exiting that close with a declared 2 bp round-trip cost. This differs from the native held-position snapshot, its entry/exit pricing and 10/5 bp per-fill assumptions:

1def common_baselines(data_dir, output):2    from limen.sfd.rule_based.common_strategies import STRATEGY_NAMES, strategy_signals3 4    raw = hourly(data_dir, None)5    train_rows, val_rows = raw.height * 8 // 11, raw.height // 116    evaluation = raw[train_rows + val_rows:]7    output.mkdir(parents=True)8    rows = []9    for name in STRATEGY_NAMES:10        signals = strategy_signals(evaluation, name)11        # Caller-owned one-bar trades: enter next open, exit that close, 2 bp total cost.12        net = signals[:-1] * (evaluation['close'].to_numpy()[1:] / evaluation['open'].to_numpy()[1:] - 1 - .0002)13        evaluation.select('datetime').with_columns(pl.Series('desired_position', signals)).write_parquet(output / (name + '.parquet'))14        rows.append({'strategy': name, 'mean_net_return': float(net.mean()),15                     'net': net.tolist(), 'signals': signals.tolist()})16    return {'rows': rows, 'split_rows': [train_rows, val_rows, evaluation.height],17            'round_trip_bps': 2., 'execution': 'independent next-open-to-close trades'}

STRATEGY_NAMES is an immutable ordered tuple. STRATEGY_PARAMETERS is a read-only mapping of read-only parameter mappings. strategy_signals returns an independent NumPy array with dtype int8, aligned one-to-one with input rows. Required prices must be finite and positive. Every strategy requires close; Donchian additionally requires high and low, with low <= close <= high. If datetime is present, it must be non-null and strictly increasing. Without it, input row order supplies chronology.

Each call starts flat with no indicator history. Short inputs are valid and remain flat until the chosen warm-up completes; an empty input returns an empty array. The function retains all warm-up rows and its final desired position. It applies no execution lag, fees, fill adjustment or forced exit. The feature adapter limen.features.common_strategy_positions appends that same array as common_strategy_position to eager or lazy Polars frames. It preserves the original columns and prevents downstream lazy filters or slices from being moved ahead of the stateful calculation.

The canonical project tests check causal signal prefixes, independent SMA/momentum rules and each interface's declared economics. Native cash/fee/slippage returns are checked with a separate scalar episode calculation. Those current assertions are distinct from the frozen historical table above.

The native manifest prepares each train, validation and test split separately, as other rule-based manifests do. It therefore resets both indicator history and position state at every split boundary. A one-call full-window benchmark continues its state across the whole window. Those two protocols intentionally answer different questions: compare engines using the same supplied signal array and compare split-level research results using the same split boundaries.

When comparing engines, generate a single signal stream once and feed it to each adapter. Declare the timing convention, costs, sizing, rounding, final-position handling and annualization. An engine is eligible for a timing comparison only after its equity/return path agrees under that convention. Instrument preprocessing separately from execution if both are timed. Faster execution and stronger trading results are different measurements; neither establishes the other.

Reference sources

• vectorbt portfolio API describes its buy-and-hold constructor and signal-based portfolio interface.
• backtesting.py's official example demonstrates the moving-average crossover family.
• Backtrader's indicator reference records EMA initialization, MACD defaults and Wilder RSI calculation.
• John Bollinger's Bollinger Band rules describe the 20-period, two-standard-deviation default and distinguish band tags from a complete trading rule.
• Backtrader's Donchian channel recipe explains excluding the current bar from a tradable channel threshold.
• Moskowitz, Ooi and Pedersen, Time Series Momentum investigates momentum in an instrument's own past returns at a different horizon and portfolio design from this baseline.