Common Task Framework Rules

All information used for portfolio construction at time t must be available at or before time t. Portfolio weights cannot use future information in any form.

Feature selection must be entirely algorithmic. Manual selection of features based on historical performance knowledge is prohibited. All feature engineering must be performed programmatically within the submitted code.

Only the provided CTF dataset is permitted. External data sources, including macroeconomic indicators, alternative data, or web-scraped information, are prohibited. Feature engineering through mathematical transformations of provided characteristics is permitted.

Submissions must be fully reproducible. All code must be self-contained with complete dependency specifications:

• Python: Use requirements.txt or pyproject.toml for package dependencies
• R: Use renv.lock for reproducible package versions

Dependencies must be available from PyPI (Python) or CRAN (R). Private package repositories or local packages are not supported. See Rule 8 for pre-installed packages.

Required submission components:

• Model Script (required): A self-contained Python or R script that implements the main() function with the specified signature (see Rules 11-12)
• Portfolio Weights (generated): CSV file with portfolio weights for all observations where ctff_test is True
• Methodology Document (encouraged): A PDF describing your approach is encouraged but not required

See the Python and R guides for more details.

Portfolios must be rebalanced monthly. No constraints are imposed on portfolio construction methodology. Shorting, leverage, position limits, and turnover constraints are permitted at the submitter's discretion.

Submissions of prior published work are encouraged. Multiple submissions are permitted to allow iterative improvement. Standard academic citation practices are recommended for methodology descriptions.

Each execution environment includes a baseline set of packages. Additional dependencies may be specified in your dependency file.

Python Pre-Installed Packages:

• pandas (≥2.0.0)
• numpy (≥1.24.0)
• pyarrow (≥10.0.0)
• boto3 (≥1.26.0)
• scipy
• scikit-learn
• polars
• joblib

R Pre-Installed Packages:

• arrow (required for Parquet I/O)
• data.table (high-performance data manipulation)
• dplyr (tidyverse data manipulation)
• tidyr (data tidying)

Additional packages may be installed by including a requirements.txt (Python) or renv.lock (R) file with your submission. All additional packages must pass security scanning before installation.

Submissions execute on high-performance computing infrastructure with the following resource allocations:

Submissions that exceed memory limits will terminate with an out-of-memory error. Submissions that exceed the time limit will be terminated and marked as failed.

Note: Resource specifications may be updated. Check this page for current values.

Submitted code executes in a fully isolated network environment:

• No outbound network access: Attempts to connect to external URLs, APIs, or services will fail
• No internet connectivity: The execution environment has no route to the public internet
• Build-time network access: Network access is available only during the container build phase for package installation

Any code that requires runtime network access will fail. All data required for model execution is provided via the function arguments.

Your submission must define a main function with the exact signature specified for your language:

def main(chars: pd.DataFrame, features: pd.DataFrame, daily_ret: pd.DataFrame) -> pd.DataFrame:
    """
    Args:
        chars: Stock characteristics (ctff_chars.parquet)
        features: Computed features (ctff_features.parquet)
        daily_ret: Historical daily returns (ctff_daily_ret.parquet)

    Returns:
        DataFrame with columns: id, eom, w
    """
    # Your model logic
    return output_df

main <- function(chars, features, daily_ret) {
    # chars: data.frame from ctff_chars.parquet
    # features: data.frame from ctff_features.parquet
    # daily_ret: data.frame from ctff_daily_ret.parquet

    # Return data.frame with columns: id, eom, w
    return(output_df)
}

Submissions without a valid main function will fail validation.

Your main() function must return a DataFrame with the following schema:

Example output:

Validation Requirements:

• DataFrame must be non-empty
• Column names must be exactly id, eom, w (case-sensitive)
• No missing values in any column
• Output size must not exceed 50 MB when serialized

The pipeline infrastructure automatically captures your function's return value and writes it to the output file. Your results must be returned exclusively via the main() function's return value. Do not attempt startup scripts, container entrypoints, or direct output file writing.

Source code files must meet the following requirements:

Files exceeding these limits will be rejected during validation.

Your main() function receives three DataFrames as arguments, loaded from the following Parquet files:

The pipeline loads these files and passes them to your function. You do not need to read files directly.

The CTF_EXECUTION_MODE environment variable indicates which mode is running, but most models do not need to check this.

The following operations are prohibited and will cause submission rejection:

Network Operations:

• socket, urllib, requests, http.client (Python)
• download.file(), url(), httr calls (R)

Shell Execution:

• subprocess, os.system, os.popen (Python)
• system(), system2(), shell() (R)

Dynamic Code Execution:

• eval(), exec(), compile() (Python)
• eval(), parse() with arbitrary strings (R)

Filesystem Access:

• Reading or writing files outside permitted temporary directories
• Attempts to access system files, environment secrets, or other submissions

Credential Exposure:

• Hardcoded API keys, passwords, or tokens in source code

All package dependencies are scanned for known vulnerabilities before installation:

Scanning Tools:

• Python: OSV-Scanner, pip-audit, GuardDog (malware detection)
• R: ROSV (R OSV wrapper)

Standard output and error streams from your code are captured:

• Use print() (Python) or print()/cat() (R) for debugging output
• Adding logging output helps CTF administrators diagnose issues with your submission
• Avoid logging sensitive information

Consider logging progress updates, timing information, and intermediate results to aid troubleshooting.

For reproducible results:

• Set random seeds explicitly (e.g., np.random.seed(42) or set.seed(42))
• Avoid operations with non-deterministic ordering unless seeded
• Test locally to verify consistent outputs

While not strictly enforced, reproducible code helps with debugging and validation.