update

2 weeks ago · d3777d856e
parent 41ef816a81
commit d3777d856e
26 changed files with 1583 additions and 40 deletions
--- a/AlphaGenerator.py
+++ b/AlphaGenerator.py
@ -35,6 +35,14 @@ def read_prompt():
        return None
    return prompt

+def read_operator():
+    with open("wqb_operator.txt", 'r', encoding='utf-8') as f:
+        operator = f.read().strip()
+    if not operator:
+        print("operator.txt是空的，请填入操作符")
+        return None
+    return operator
+

 def create_result_folder():
    # 修改这里：创建 generated_alpha 文件夹
@ -96,7 +104,7 @@ def get_ai_config(config):

 def get_user_info():
    # 获取用户信息
-    with open('config.json', 'r') as f:
+    with open('ai_config.json', 'r') as f:
        config = json.load(f)
        siliconflow = config['siliconflow']
        token = siliconflow['api_keys']
@ -130,6 +138,11 @@ def main():
    if not config_result:
        return

+    operator = read_operator()
+
+    if operator:
+        prompt = prompt + "\n\n以下是我的账号有权限使用的操作符以及操作符的使用方法, 请严格按照操作符, 进行生成,组合因子\n\n" + operator
+
    service_name, service_config = config_result

    print(f"使用服务: {service_name}")
--- a/FactorSimulator.py
+++ b/FactorSimulator.py
@ -32,7 +32,7 @@ class AlphaSimulator:
        print(f"登录状态: {response.status_code}")

        if response.status_code == 201:
-            print("登录成功!")
+            print(f"登录成功!:{response.json()}")
            return True
        else:
            print(f"登录失败: {response.json()}")
--- a/FieldDownloader.py
+++ b/FieldDownloader.py
@ -187,8 +187,8 @@ if __name__ == "__main__":
        downloader = DataSetDownloader(client)

        endpoint_list = ['data-sets', 'data-fields']
-        endpoint = endpoint_list[1]
-        data_set_id = 'news18'
+        endpoint = endpoint_list[0]
+        data_set_id = 'analyst4'

        downloader.download_data_set(endpoint, data_set_id)
    else:
--- a/VerificationAlpha.py
+++ b/VerificationAlpha.py
@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+import os
+import httpx
+from requests.auth import HTTPBasicAuth
+from urllib.parse import urlencode
+
+
+class BrainLogin:
+    def __init__(self, credentials_file='account.txt'):
+        self.credentials_file = credentials_file
+        self.client = None
+        self.brain_api_url = 'https://api.worldquantbrain.com'
+
+    def load_credentials(self):
+        if not os.path.exists(self.credentials_file):
+            print("未找到 account.txt 文件")
+            with open(self.credentials_file, 'w') as f:
+                f.write("")
+            print("account.txt 文件已创建，请填写账号密码, 格式: ['username', 'password']")
+            exit(1)
+
+        with open(self.credentials_file) as f:
+            credentials = eval(f.read())
+        return credentials[0], credentials[1]
+
+    def login(self):
+        try:
+            username, password = self.load_credentials()
+            self.client = httpx.Client(auth=HTTPBasicAuth(username, password))
+
+            response = self.client.post(f'{self.brain_api_url}/authentication')
+            print(f"登录状态: {response.status_code}")
+
+            if response.status_code in [200, 201]:
+                print("登录成功!")
+                return self.client
+            else:
+                print(f"登录失败: {response.json()}")
+                return None
+
+        except Exception as e:
+            print(f"登录过程中出现错误: {e}")
+            return None
+
+    def get_alphas(self, **params):
+        if self.client is None:
+            print("请先登录!")
+            return None
+
+        try:
+            encoded_params = urlencode(params, doseq=True)
+            url = f"{self.brain_api_url}/users/self/alphas?{encoded_params}"
+
+            response = self.client.get(url)
+
+            if response.status_code == 200:
+                return response.json()
+            else:
+                print(f"获取alpha列表失败: {response.text}")
+                return None
+
+        except Exception as e:
+            print(f"获取alpha列表过程中出现错误: {e}")
+            return None
+
+
+# 使用示例
+if __name__ == "__main__":
+    brain = BrainLogin()
+
+    if brain.login():
+        alphas = brain.get_alphas(
+            limit=50,
+            offset=0,
+            status="UNSUBMITTED",
+            order="dateSubmitted",
+            hidden="false"
+        )
+
+        if alphas:
+            print("获取alpha列表成功!")
+            print(alphas)
+            print(f"一共 {len(alphas)} 个 alpha")
--- a/alpha.txt
+++ b/alpha.txt
@ -1 +1,20 @@
-group_mean(ts_rank(volume, 252), industry)
+ts_delta(ts_mean(close, 5), 10)
+ts_rank(ts_corr(volume, close, 20), 5)
+ts_zscore(ts_std_dev(close, 10), 20)
+subtract(ts_mean(close, 10), ts_mean(close, 30))
+ts_delta(ts_arg_max(high, 20), 5)
+ts_rank(ts_sum(volume, 5), 10)
+ts_zscore(ts_decay_linear(close, 15), 30)
+ts_corr(ts_delta(close, 1), ts_delta(volume, 1), 10)
+ts_rank(ts_mean(vwap, 20), 5)
+ts_delta(ts_std_dev(close, 5), 10)
+ts_rank(ts_sum(market_cap, 10), 20)
+ts_zscore(ts_corr(close, market_cap, 15), 30)
+subtract(ts_mean(high, 5), ts_mean(low, 5))
+ts_delta(ts_rank(volume, 10), 5)
+ts_mean(ts_decay_linear(close, 20), 10)
+ts_rank(ts_zscore(close, 15), 5)
+ts_corr(ts_delta(high, 1), ts_delta(low, 1), 10)
+ts_delta(ts_mean(vwap, 10), 20)
+ts_rank(ts_std_dev(volume, 5), 10)
+ts_zscore(ts_sum(close, 20), 30)
--- a/alpha_prompt.txt
+++ b/alpha_prompt.txt
@ -1,37 +1,35 @@
-【重要平台约束】
-平台：WorldQuant WebSim
-可用函数：ts_*(时间序列), group_*(横截面), 基础数学运算
-可用字段：open, high, low, close, volume, vwap, sector, industry, country, market_cap
-禁用函数：pandas, numpy, 自定义Python函数，机器学习库
-输出格式：严格一行WebSim表达式，使用WQ平台函数
-表达式要求：必须能直接在WebSim中运行
-
-我正在WorldQuant研究行业轮动策略，请设计行业选择因子：
-
-**策略背景**：
- 目标：在不同经济周期中选择强势行业
- 数据：使用sector, industry分类字段
- 频率：月度调仓
- 风险：控制行业集中度
-
-**需要5个行业因子**：
-1. 行业动量因子（相对强度）
-2. 行业估值修复因子（均值回归）
-3. 行业资金流向因子（量价结合）
-4. 行业波动率特征因子（风险调整）
-5. 行业间相对强度因子（横截面）
-
-**具体要求**：
- 必须使用group函数处理行业分组
- 每个因子包含清晰的行业轮动逻辑
- 考虑行业特性的持久性
- 提供经济周期适应的解释
-
-**输出格式**(一行一个, 不要输出多余的东西)：
-[表达式]
-[表达式]
-[表达式]
+作为WorldQuant因子挖掘专家，请基于以下多维度框架生成20个原创alpha因子。请严格遵循WebSim语法规范：
+
+因子设计维度(也可以你自己设计维度)：
+
+价格趋势 - 动量/均值回归/突破策略
+
+量价关系 - 成交量确认/量价背离
+
+波动特征 - 波动率变化/波动聚集性
+
+横截面特征 - 行业中性/市值因子
+
+技术形态 - 价格位置/高低点突破
+
+流动性特征 - 成交量分布/VWAP关系
+
+约束条件：
+
+仅使用：使用我提供的操作符
+
+可用字段：open, high, low, close, volume, vwap, sector, country, market_cap
+
+禁用：pandas, numpy, 自定义函数，机器学习
+
+每个表达式必须独立有效且可直接在WebSim运行
+
+输出要求：
+严格按以下格式，一行一个WebSim表达式，不包含任何解释：
+
+[表达式1]
+[表达式2]
 ...
+[表达式20]

-请提供具体的WQ表达式。
-重申：请确保所有表达式都使用WorldQuant WebSim平台函数，不要使用pandas、numpy或其他Python库函数。输出必须是一行有效的WQ表达式。
+注意： 确保因子逻辑清晰，避免过度拟合，保持表达式简洁高效。优先考虑具有经济直觉的因子组合。
--- a/generated_alpha/20251125100124.txt
+++ b/generated_alpha/20251125100124.txt
@ -0,0 +1,20 @@
+ts_zscore(close, 20) / ts_std(close, 20)
+group_rank(ts_mean(close, 5) / ts_mean(close, 20), sector)
+ts_corr(volume, close, 10) * ts_std(close, 5)
+ts_mean(high - low, 10) / ts_mean(close, 10)
+group_zscore(ts_max(high, 20) - close, market_cap)
+ts_mean(close / vwap, 5) - ts_mean(close / vwap, 20)
+ts_min(low, 5) / ts_max(high, 5) - 1
+group_rank(ts_std(close, 10), sector) * ts_mean(volume, 5)
+ts_mean(close, 3) - ts_mean(close, 10)
+ts_slope(close, 15) * ts_std(volume, 5)
+group_zscore(ts_max(high, 10) - ts_min(low, 10), country)
+ts_mean(volume / ts_mean(volume, 20), 5)
+ts_corr(close, volume, 5) * ts_mean(close, 3)
+group_rank(ts_zscore(close, 10), market_cap)
+ts_mean(high - close, 5) / ts_mean(close - low, 5)
+ts_mean(close / ts_mean(close, 20), 3) - 1
+group_zscore(ts_mean(volume, 10), sector) * ts_zscore(close, 5)
+ts_max(high, 10) / ts_min(low, 10) - 1
+ts_mean(close > ts_mean(close, 5), 3) - ts_mean(close < ts_mean(close, 5), 3)
+ts_mean(vwap / close, 10) - ts_mean(vwap / close, 30)
--- a/generated_alpha/20251125133756.txt
+++ b/generated_alpha/20251125133756.txt
@ -0,0 +1,20 @@
+ts_zscore(ts_delta(close, 5), 20)
+ts_rank(ts_corr(volume, close, 10), 20)
+group_neutralize(ts_av_diff(close, 10), sector)
+ts_scale(ts_std_dev(close, 15), 30)
+ts_rank(ts_decay_linear(volume, 5), 20)
+ts_rank(ts_delta(vwap, 3), 10)
+group_zscore(ts_delta(high, 5), sector)
+ts_rank(ts_mean(volume, 10) / ts_mean(volume, 30), 20)
+ts_rank(ts_delta(close, 1) / ts_delay(close, 1), 10)
+ts_rank(ts_mean(ts_delta(close, 1), 5), 20)
+group_neutralize(ts_zscore(ts_delta(high - low, 5), 15), country)
+ts_rank(ts_corr(close, volume, 5), 10)
+ts_rank(ts_backfill(volume, 5, 1), 15)
+ts_rank(ts_mean(ts_delta(close, 1), 20) / ts_std_dev(close, 20), 30)
+ts_rank(ts_arg_max(high, 10), 20)
+ts_rank(ts_av_diff(vwap, 5), 10)
+group_scale(ts_delta(close, 5), sector)
+ts_rank(ts_delta(ts_mean(close, 3), 5), 10)
+ts_rank(ts_quantile(ts_delta(close, 1), 10), 20)
+ts_rank(ts_delta(ts_mean(close, 5), 10), 20)
--- a/generated_alpha/20251125144246.txt
+++ b/generated_alpha/20251125144246.txt
@ -0,0 +1,20 @@
+ts_delta(close, 5) / ts_mean(close, 20)
+ts_rank(volume, 10) * ts_zscore(close, 20)
+ts_av_diff(close, 10) / ts_std_dev(close, 20)
+group_neutralize(ts_delta(close, 3), sector)
+ts_corr(close, volume, 15) * ts_delta(close, 5)
+ts_scale(close, 30) * sign(ts_delta(close, 5))
+ts_rank(ts_delta(vwap, 5), 10) - 0.5
+ts_std_dev(close, 10) / ts_mean(close, 20)
+ts_zscore(ts_delta(close, 3), 10) * ts_rank(volume, 5)
+ts_decay_linear(ts_delta(close, 1), 10, dense=false)
+ts_arg_max(high, 20) - ts_arg_min(low, 20)
+ts_mean(close, 5) / ts_mean(close, 60) - 1
+group_zscore(ts_delta(close, 5), sector)]
+ts_rank(ts_product(close, 3), 10) * sign(ts_delta(close, 1))
+ts_covariance(close, volume, 15) / (ts_std_dev(close, 15) * ts_std_dev(volume, 15))
+ts_mean(ts_delta(close, 2), 10) * ts_rank(volume, 20)
+ts_quantile(close, 20, driver="uniform") - 0.5
+ts_delta(close, 1) / ts_delta(vwap, 1) - 1
+group_scale(ts_delta(close, 5), sector)
+ts_rank(ts_delta(ts_mean(close, 3), 1), 10) * sign(ts_delta(volume, 3))
--- a/simulator_result/fail/fail_results_1764035934.json
+++ b/simulator_result/fail/fail_results_1764035934.json
@ -0,0 +1,100 @@
+[
+  {
+    "expression": "group_rank(ts_rank(close, 10)) - group_rank(ts_rank(volume, 10))",
+    "time_consuming": 6.76,
+    "status": "error",
+    "timestamp": "2025-11-25 09:51:58",
+    "message": "Invalid number of inputs : 1, should be exactly 2 input(s)"
+  },
+  {
+    "expression": "group_std(ts_returns(close, 1), 5) * -1",
+    "time_consuming": 6.79,
+    "status": "error",
+    "timestamp": "2025-11-25 09:53:27",
+    "message": "Attempted to use inaccessible or unknown operator \"group_std\""
+  },
+  {
+    "expression": "group_neutralize(ts_scale(close - vwap), sector)",
+    "time_consuming": 6.54,
+    "status": "error",
+    "timestamp": "2025-11-25 09:54:53",
+    "message": "Required attribute \"lookback\" must have a value"
+  },
+  {
+    "expression": "ts_regression(volume, close, 10, 2)",
+    "time_consuming": 6.56,
+    "status": "error",
+    "timestamp": "2025-11-25 09:55:00",
+    "message": "Invalid number of inputs : 3, should be exactly 2 input(s)"
+  },
+  {
+    "expression": "ts_max(ts_delta(vwap, 3), 5) - ts_min(ts_delta(vwap, 3), 5)",
+    "time_consuming": 6.54,
+    "status": "error",
+    "timestamp": "2025-11-25 09:55:06",
+    "message": "Attempted to use inaccessible or unknown operator \"ts_max\""
+  },
+  {
+    "expression": "group_rank(ts_returns(close, 1)) * group_rank(market_cap)",
+    "time_consuming": 12.66,
+    "status": "error",
+    "timestamp": "2025-11-25 09:55:19",
+    "message": "Attempted to use inaccessible or unknown operator \"ts_returns\""
+  },
+  {
+    "expression": "ts_sum(close - open, 5) / ts_std(close - open, 5)",
+    "time_consuming": 6.66,
+    "status": "error",
+    "timestamp": "2025-11-25 09:55:25",
+    "message": "Attempted to use inaccessible or unknown operator \"ts_std\""
+  },
+  {
+    "expression": "group_rank(ts_rank(volume, 5)) * group_rank(ts_rank(close, 5))",
+    "time_consuming": 6.58,
+    "status": "error",
+    "timestamp": "2025-11-25 09:55:32",
+    "message": "Invalid number of inputs : 1, should be exactly 2 input(s)"
+  },
+  {
+    "expression": "ts_corr(group_rank(close), group_rank(volume), 10)",
+    "time_consuming": 6.52,
+    "status": "error",
+    "timestamp": "2025-11-25 09:55:39",
+    "message": "Invalid number of inputs : 1, should be exactly 2 input(s)"
+  },
+  {
+    "expression": "group_std(ts_returns(vwap, 1), 10) * -ts_returns(close, 1)",
+    "time_consuming": 6.48,
+    "status": "error",
+    "timestamp": "2025-11-25 09:57:10",
+    "message": "Attempted to use inaccessible or unknown operator \"group_std\""
+  },
+  {
+    "expression": "ts_scale(ts_sum(volume * close, 10)) - ts_scale(ts_sum(volume, 10))",
+    "time_consuming": 6.51,
+    "status": "error",
+    "timestamp": "2025-11-25 09:57:16",
+    "message": "Required attribute \"lookback\" must have a value"
+  },
+  {
+    "expression": "ts_regression(close, volume, 15, 1) * group_rank(market_cap)",
+    "time_consuming": 6.53,
+    "status": "error",
+    "timestamp": "2025-11-25 09:58:47",
+    "message": "Invalid number of inputs : 3, should be exactly 2 input(s)"
+  },
+  {
+    "expression": "ts_delta(ts_mean(close, 10), 5) / ts_std(close, 10)",
+    "time_consuming": 6.54,
+    "status": "error",
+    "timestamp": "2025-11-25 09:58:54",
+    "message": "Attempted to use inaccessible or unknown operator \"ts_std\""
+  },
+  {
+    "expression": "group_rank(ts_returns(close, 5)) - group_rank(ts_returns(volume, 5))",
+    "time_consuming": 0.53,
+    "status": "error",
+    "timestamp": "2025-11-25 09:58:54",
+    "message": "Attempted to use inaccessible or unknown operator \"ts_returns\""
+  }
+]
--- a/simulator_result/fail/fail_results_1764037554.json
+++ b/simulator_result/fail/fail_results_1764037554.json
@ -0,0 +1,65 @@
+[
+  {
+    "expression": "ts_zscore(close, 20) / ts_std(close, 20)",
+    "time_consuming": 6.54,
+    "status": "error",
+    "timestamp": "2025-11-25 10:06:20",
+    "message": "Attempted to use inaccessible or unknown operator \"ts_std\""
+  },
+  {
+    "expression": "ts_corr(volume, close, 10) * ts_std(close, 5)",
+    "time_consuming": 6.5,
+    "status": "error",
+    "timestamp": "2025-11-25 10:08:00",
+    "message": "Attempted to use inaccessible or unknown operator \"ts_std\""
+  },
+  {
+    "expression": "group_zscore(ts_max(high, 20) - close, market_cap)",
+    "time_consuming": 25.63,
+    "status": "error",
+    "timestamp": "2025-11-25 10:09:46",
+    "message": "Attempted to use inaccessible or unknown operator \"ts_max\""
+  },
+  {
+    "expression": "ts_min(low, 5) / ts_max(high, 5) - 1",
+    "time_consuming": 6.57,
+    "status": "error",
+    "timestamp": "2025-11-25 10:11:17",
+    "message": "Attempted to use inaccessible or unknown operator \"ts_min\""
+  },
+  {
+    "expression": "group_rank(ts_std(close, 10), sector) * ts_mean(volume, 5)",
+    "time_consuming": 18.7,
+    "status": "error",
+    "timestamp": "2025-11-25 10:11:36",
+    "message": "Attempted to use inaccessible or unknown operator \"ts_std\""
+  },
+  {
+    "expression": "ts_slope(close, 15) * ts_std(volume, 5)",
+    "time_consuming": 6.51,
+    "status": "error",
+    "timestamp": "2025-11-25 10:13:07",
+    "message": "Attempted to use inaccessible or unknown operator \"ts_slope\""
+  },
+  {
+    "expression": "group_zscore(ts_max(high, 10) - ts_min(low, 10), country)",
+    "time_consuming": 6.51,
+    "status": "error",
+    "timestamp": "2025-11-25 10:13:14",
+    "message": "Attempted to use inaccessible or unknown operator \"ts_max\""
+  },
+  {
+    "expression": "group_rank(ts_zscore(close, 10), market_cap)",
+    "time_consuming": 6.67,
+    "status": "error",
+    "timestamp": "2025-11-25 10:17:02",
+    "message": "Attempted to use unknown variable \"market_cap\""
+  },
+  {
+    "expression": "ts_max(high, 10) / ts_min(low, 10) - 1",
+    "time_consuming": 6.68,
+    "status": "error",
+    "timestamp": "2025-11-25 10:23:01",
+    "message": "Attempted to use inaccessible or unknown operator \"ts_max\""
+  }
+]
--- a/simulator_result/fail/fail_results_1764039167.json
+++ b/simulator_result/fail/fail_results_1764039167.json
@ -0,0 +1,51 @@
+[
+  {
+    "expression": "-ts_argmax(high, 20) * ts_rank(close, 10)",
+    "time_consuming": 6.49,
+    "status": "error",
+    "timestamp": "2025-11-25 10:36:11",
+    "message": "Attempted to use inaccessible or unknown operator \"ts_argmax\""
+  },
+  {
+    "expression": "ts_mean((close - open) / (high - low + 1e-6), 10)",
+    "time_consuming": 2.37,
+    "status": "error",
+    "timestamp": "2025-11-25 10:36:13",
+    "message": "Unexpected character 'e' near \"- low + 1e-6), 10)\""
+  },
+  {
+    "expression": "-ts_zscore(ts_mean(volume, 20), country)",
+    "time_consuming": 6.55,
+    "status": "error",
+    "timestamp": "2025-11-25 10:40:41",
+    "message": "Got invalid value for attribute \"lookback\", must be constant or string"
+  },
+  {
+    "expression": "(close - ts_min(low, 10)) / (ts_max(high, 10) - ts_min(low, 10) + 1e-6)",
+    "time_consuming": 6.49,
+    "status": "error",
+    "timestamp": "2025-11-25 10:40:48",
+    "message": "Unexpected character 'e' near \"w, 10) + 1e-6)\""
+  },
+  {
+    "expression": "group_rank(ts_corr(close, ts_delay(close, 5), 60), sector)",
+    "time_consuming": 66.39,
+    "status": "error",
+    "message": "The read operation timed out",
+    "timestamp": "2025-11-25 10:43:13"
+  },
+  {
+    "expression": "-ts_product(ts_rank(close, 10), ts_rank(volume, 10))",
+    "time_consuming": 7.27,
+    "status": "error",
+    "timestamp": "2025-11-25 10:43:20",
+    "message": "Got invalid value for attribute \"lookback\", must be constant or string"
+  },
+  {
+    "expression": "group_zscore(ts_argmin(low, 20), sector) * -1",
+    "time_consuming": 6.86,
+    "status": "error",
+    "timestamp": "2025-11-25 10:46:54",
+    "message": "Attempted to use inaccessible or unknown operator \"ts_argmin\""
+  }
+]
--- a/simulator_result/fail/fail_results_1764050897.json
+++ b/simulator_result/fail/fail_results_1764050897.json
@ -0,0 +1,16 @@
+[
+  {
+    "expression": "ts_rank(ts_backfill(volume, 5, 1), 15)",
+    "time_consuming": 88.18,
+    "status": "error",
+    "timestamp": "2025-11-25 13:59:21",
+    "message": "Invalid number of inputs : 2, should be exactly 1 input(s)"
+  },
+  {
+    "expression": "ts_rank(ts_delta(ts_mean(close, 5), 10), 20)",
+    "time_consuming": 11.3,
+    "status": "error",
+    "message": "The read operation timed out",
+    "timestamp": "2025-11-25 14:08:17"
+  }
+]
--- a/simulator_result/fail/fail_results_1764054880.json
+++ b/simulator_result/fail/fail_results_1764054880.json
@ -0,0 +1,9 @@
+[
+  {
+    "expression": "group_zscore(ts_delta(close, 5), sector)]",
+    "time_consuming": 6.88,
+    "status": "error",
+    "timestamp": "2025-11-25 15:05:03",
+    "message": "Unexpected character ']' near \"), sector)]\""
+  }
+]
--- a/simulator_result/fail/fail_results_1764057125.json
+++ b/simulator_result/fail/fail_results_1764057125.json
@ -0,0 +1,9 @@
+[
+  {
+    "expression": "reverse(divide(ts_covariance(ts_rank(close,10),ts_rank(volume,20),20),add(ts_std_dev(volume,20),1e-5)))",
+    "time_consuming": 6.7,
+    "status": "error",
+    "timestamp": "2025-11-25 15:24:00",
+    "message": "Unexpected character 'e' near \"lume,20),1e-5)))\""
+  }
+]
--- a/simulator_result/fail/fail_results_1764058900.json
+++ b/simulator_result/fail/fail_results_1764058900.json
@ -0,0 +1,37 @@
+[
+  {
+    "expression": "ts_rank(divide(close - vwap, ts_std_dev(close, 20)), 10) - ts_rank(volume, 10)",
+    "time_consuming": 98.86,
+    "status": "error",
+    "message": "The read operation timed out",
+    "timestamp": "2025-11-25 16:01:34"
+  },
+  {
+    "expression": "rank(ts_delta(log(volume), 3)) * rank(divide(close - open, open))",
+    "time_consuming": 29.52,
+    "status": "error",
+    "message": "The read operation timed out",
+    "timestamp": "2025-11-25 16:08:15"
+  },
+  {
+    "expression": "group_zscore(ts_regression(close, ts_mean(close, 10), 20, 0, 0), sector) - rank(ts_std_dev(volume, 10))",
+    "time_consuming": 7.69,
+    "status": "error",
+    "timestamp": "2025-11-25 16:09:50",
+    "message": "Got invalid value \"0\" for attribute \"lookback\", should be a positive integer"
+  },
+  {
+    "expression": "rank(divide(close - ts_min(low, 20), ts_max(high, 20) - ts_min(low, 20))) - ts_rank(volume, 10)",
+    "time_consuming": 6.82,
+    "status": "error",
+    "timestamp": "2025-11-25 16:16:40",
+    "message": "Attempted to use inaccessible or unknown operator \"ts_min\""
+  },
+  {
+    "expression": "if_else(close > vwap, rank(ts_corr(high, volume, 5)), reverse(rank(ts_corr(low, volume, 5))))",
+    "time_consuming": 5.0,
+    "status": "error",
+    "message": "The read operation timed out",
+    "timestamp": "2025-11-25 16:18:41"
+  }
+]
--- a/simulator_result/success/success_results_1764035934.json
+++ b/simulator_result/success/success_results_1764035934.json
@ -0,0 +1,37 @@
+[
+  {
+    "expression": "ts_corr(ts_delta(close, 5), ts_delta(volume, 5), 10)",
+    "time_consuming": 90.78,
+    "status": "success",
+    "timestamp": "2025-11-25 09:51:51",
+    "alpha_id": "P0draRVp"
+  },
+  {
+    "expression": "ts_rank(ts_decay_linear(close - open, 10), 5)",
+    "time_consuming": 82.31,
+    "status": "success",
+    "timestamp": "2025-11-25 09:53:20",
+    "alpha_id": "3qZYZLMQ"
+  },
+  {
+    "expression": "ts_rank(ts_covariance(high, volume, 10), 5)",
+    "time_consuming": 79.62,
+    "status": "success",
+    "timestamp": "2025-11-25 09:54:46",
+    "alpha_id": "d5A8Alzw"
+  },
+  {
+    "expression": "ts_rank(ts_decay_linear(high - low, 15), 10)",
+    "time_consuming": 84.54,
+    "status": "success",
+    "timestamp": "2025-11-25 09:57:03",
+    "alpha_id": "d5A8AWmE"
+  },
+  {
+    "expression": "group_neutralize(ts_rank(close, 10), country)",
+    "time_consuming": 84.58,
+    "status": "success",
+    "timestamp": "2025-11-25 09:58:41",
+    "alpha_id": "Grp0p530"
+  }
+]
--- a/simulator_result/success/success_results_1764037554.json
+++ b/simulator_result/success/success_results_1764037554.json
@ -0,0 +1,79 @@
+[
+  {
+    "expression": "group_rank(ts_mean(close, 5) / ts_mean(close, 20), sector)",
+    "time_consuming": 93.45,
+    "status": "success",
+    "timestamp": "2025-11-25 10:07:53",
+    "alpha_id": "MPolAmaM"
+  },
+  {
+    "expression": "ts_mean(high - low, 10) / ts_mean(close, 10)",
+    "time_consuming": 80.68,
+    "status": "success",
+    "timestamp": "2025-11-25 10:09:20",
+    "alpha_id": "pwAJgVx6"
+  },
+  {
+    "expression": "ts_mean(close / vwap, 5) - ts_mean(close / vwap, 20)",
+    "time_consuming": 84.65,
+    "status": "success",
+    "timestamp": "2025-11-25 10:11:11",
+    "alpha_id": "A1MJdQxe"
+  },
+  {
+    "expression": "ts_mean(close, 3) - ts_mean(close, 10)",
+    "time_consuming": 85.02,
+    "status": "success",
+    "timestamp": "2025-11-25 10:13:01",
+    "alpha_id": "ZYewLv70"
+  },
+  {
+    "expression": "ts_mean(volume / ts_mean(volume, 20), 5)",
+    "time_consuming": 108.98,
+    "status": "success",
+    "timestamp": "2025-11-25 10:15:03",
+    "alpha_id": "O0Pm5YvR"
+  },
+  {
+    "expression": "ts_corr(close, volume, 5) * ts_mean(close, 3)",
+    "time_consuming": 112.42,
+    "status": "success",
+    "timestamp": "2025-11-25 10:16:55",
+    "alpha_id": "akq2JdN6"
+  },
+  {
+    "expression": "ts_mean(high - close, 5) / ts_mean(close - low, 5)",
+    "time_consuming": 113.83,
+    "status": "success",
+    "timestamp": "2025-11-25 10:18:56",
+    "alpha_id": "rKv6kNkJ"
+  },
+  {
+    "expression": "ts_mean(close / ts_mean(close, 20), 3) - 1",
+    "time_consuming": 132.39,
+    "status": "success",
+    "timestamp": "2025-11-25 10:21:08",
+    "alpha_id": "78Eqg7JZ"
+  },
+  {
+    "expression": "group_zscore(ts_mean(volume, 10), sector) * ts_zscore(close, 5)",
+    "time_consuming": 105.74,
+    "status": "success",
+    "timestamp": "2025-11-25 10:22:54",
+    "alpha_id": "Wj6wKX1o"
+  },
+  {
+    "expression": "ts_mean(close > ts_mean(close, 5), 3) - ts_mean(close < ts_mean(close, 5), 3)",
+    "time_consuming": 85.48,
+    "status": "success",
+    "timestamp": "2025-11-25 10:24:26",
+    "alpha_id": "88dkgp2q"
+  },
+  {
+    "expression": "ts_mean(vwap / close, 10) - ts_mean(vwap / close, 30)",
+    "time_consuming": 88.46,
+    "status": "success",
+    "timestamp": "2025-11-25 10:25:54",
+    "alpha_id": "KPjYx5Jl"
+  }
+]
--- a/simulator_result/success/success_results_1764039167.json
+++ b/simulator_result/success/success_results_1764039167.json
@ -0,0 +1,93 @@
+[
+  {
+    "expression": "ts_rank(ts_mean(close, 10), 20)",
+    "time_consuming": 78.74,
+    "status": "success",
+    "timestamp": "2025-11-25 10:30:02",
+    "alpha_id": "1YQVVomk"
+  },
+  {
+    "expression": "-ts_corr(close, volume, 20)",
+    "time_consuming": 71.61,
+    "status": "success",
+    "timestamp": "2025-11-25 10:31:13",
+    "alpha_id": "mLM22jQx"
+  },
+  {
+    "expression": "ts_delta(close, 5) / ts_delay(close, 5)",
+    "time_consuming": 194.4,
+    "status": "success",
+    "timestamp": "2025-11-25 10:34:28",
+    "alpha_id": "MPolqMjz"
+  },
+  {
+    "expression": "group_zscore(ts_rank(volume, 60), sector)",
+    "time_consuming": 96.81,
+    "status": "success",
+    "timestamp": "2025-11-25 10:36:04",
+    "alpha_id": "LLAbqqka"
+  },
+  {
+    "expression": "-ts_corr(vwap, volume, 5) * ts_rank(volume, 20)",
+    "time_consuming": 94.52,
+    "status": "success",
+    "timestamp": "2025-11-25 10:37:48",
+    "alpha_id": "bl52VdMp"
+  },
+  {
+    "expression": "group_neutralize(ts_delta(log(close), 1), sector)",
+    "time_consuming": 85.6,
+    "status": "success",
+    "timestamp": "2025-11-25 10:39:13",
+    "alpha_id": "d5A8g92g"
+  },
+  {
+    "expression": "ts_rank(ts_std_dev(close / ts_delay(close, 1) - 1, 20), 60)",
+    "time_consuming": 81.19,
+    "status": "success",
+    "timestamp": "2025-11-25 10:40:35",
+    "alpha_id": "rKv6EMnJ"
+  },
+  {
+    "expression": "ts_decay_linear(ts_rank(volume, 20), 10) - ts_rank(close, 20)",
+    "time_consuming": 78.57,
+    "status": "success",
+    "timestamp": "2025-11-25 10:42:06",
+    "alpha_id": "mLM2A3V6"
+  },
+  {
+    "expression": "ts_rank((vwap - close) / ts_mean(vwap - close, 20), 60)",
+    "time_consuming": 90.58,
+    "status": "success",
+    "timestamp": "2025-11-25 10:44:50",
+    "alpha_id": "kq2kX3Gk"
+  },
+  {
+    "expression": "-ts_delta(ts_mean(volume, 60), 10) / ts_mean(volume, 60)",
+    "time_consuming": 117.0,
+    "status": "success",
+    "timestamp": "2025-11-25 10:46:47",
+    "alpha_id": "MPolXd2r"
+  },
+  {
+    "expression": "ts_rank(ts_corr(ts_rank(close, 10), ts_rank(volume, 10), 5), 20)",
+    "time_consuming": 151.35,
+    "status": "success",
+    "timestamp": "2025-11-25 10:49:26",
+    "alpha_id": "vR3nzM5A"
+  },
+  {
+    "expression": "(close / ts_delay(close, 10) - 1) * ts_rank(volume, 20)",
+    "time_consuming": 85.66,
+    "status": "success",
+    "timestamp": "2025-11-25 10:50:51",
+    "alpha_id": "6XvPqqjL"
+  },
+  {
+    "expression": "-ts_covariance(ts_rank(high, 10), ts_rank(volume, 10), 20)",
+    "time_consuming": 115.29,
+    "status": "success",
+    "timestamp": "2025-11-25 10:52:47",
+    "alpha_id": "LLAbXNP9"
+  }
+]
--- a/simulator_result/success/success_results_1764040209.json
+++ b/simulator_result/success/success_results_1764040209.json
@ -0,0 +1,65 @@
+[
+  {
+    "expression": "-ts_covariance(ts_rank(high, 10), ts_rank(volume, 20), 20)",
+    "time_consuming": 79.09,
+    "status": "success",
+    "timestamp": "2025-11-25 10:57:58",
+    "alpha_id": "VkgwYlbG"
+  },
+  {
+    "expression": "-ts_covariance(ts_rank(close, 10), ts_rank(volume, 20), 20)",
+    "time_consuming": 76.69,
+    "status": "success",
+    "timestamp": "2025-11-25 10:59:15",
+    "alpha_id": "O0Ew5G9J"
+  },
+  {
+    "expression": "-ts_covariance(ts_rank(high, 5), ts_rank(volume, 10), 15)",
+    "time_consuming": 80.17,
+    "status": "success",
+    "timestamp": "2025-11-25 11:00:35",
+    "alpha_id": "j2bldodQ"
+  },
+  {
+    "expression": "group_neutralize(-ts_covariance(ts_rank(high, 10), ts_rank(volume, 10), 20), sector)",
+    "time_consuming": 132.85,
+    "status": "success",
+    "timestamp": "2025-11-25 11:02:48",
+    "alpha_id": "O0EwbQ0g"
+  },
+  {
+    "expression": "-ts_covariance(ts_rank(vwap, 10), ts_rank(volume, 20), 20)",
+    "time_consuming": 85.15,
+    "status": "success",
+    "timestamp": "2025-11-25 11:04:13",
+    "alpha_id": "d5A8E8lv"
+  },
+  {
+    "expression": "-ts_covariance(ts_rank(high, 20), ts_rank(volume, 10), 20)",
+    "time_consuming": 104.09,
+    "status": "success",
+    "timestamp": "2025-11-25 11:05:57",
+    "alpha_id": "mLM2rV5W"
+  },
+  {
+    "expression": "-ts_covariance(ts_rank(close, 10), ts_rank(volume, 10), 20) * ts_rank(close, 5)",
+    "time_consuming": 78.07,
+    "status": "success",
+    "timestamp": "2025-11-25 11:07:15",
+    "alpha_id": "P0drwP0W"
+  },
+  {
+    "expression": "-ts_covariance(ts_rank(high, 10), ts_rank(volume, 20), 10)",
+    "time_consuming": 80.16,
+    "status": "success",
+    "timestamp": "2025-11-25 11:08:35",
+    "alpha_id": "bl52ogzN"
+  },
+  {
+    "expression": "group_zscore(-ts_covariance(ts_rank(high, 10), ts_rank(volume, 10), 20), sector)",
+    "time_consuming": 93.28,
+    "status": "success",
+    "timestamp": "2025-11-25 11:10:09",
+    "alpha_id": "9qLP9vx1"
+  }
+]
--- a/simulator_result/success/success_results_1764043404.json
+++ b/simulator_result/success/success_results_1764043404.json
@ -0,0 +1,107 @@
+[
+  {
+    "expression": "reverse(ts_covariance(ts_rank(high,10),ts_rank(volume,20),20))",
+    "time_consuming": 93.04,
+    "status": "success",
+    "timestamp": "2025-11-25 11:40:21",
+    "alpha_id": "pwAJlKZj"
+  },
+  {
+    "expression": "reverse(ts_covariance(ts_rank(close,10),ts_rank(volume,20),20))",
+    "time_consuming": 120.38,
+    "status": "success",
+    "timestamp": "2025-11-25 11:42:22",
+    "alpha_id": "LLAb13e2"
+  },
+  {
+    "expression": "group_neutralize(reverse(ts_covariance(ts_rank(high,10),ts_rank(volume,20),20)),sector)",
+    "time_consuming": 97.15,
+    "status": "success",
+    "timestamp": "2025-11-25 11:43:59",
+    "alpha_id": "Xg5w8Gj1"
+  },
+  {
+    "expression": "reverse(ts_covariance(ts_rank(vwap,10),ts_rank(volume,20),20))",
+    "time_consuming": 87.67,
+    "status": "success",
+    "timestamp": "2025-11-25 11:45:26",
+    "alpha_id": "j2blrWW9"
+  },
+  {
+    "expression": "reverse(multiply(ts_covariance(ts_rank(high,10),ts_rank(volume,20),20),ts_rank(close,5)))",
+    "time_consuming": 134.79,
+    "status": "success",
+    "timestamp": "2025-11-25 11:47:41",
+    "alpha_id": "e7o8xQmd"
+  },
+  {
+    "expression": "reverse(ts_covariance(ts_rank(high,5),ts_rank(volume,15),15))",
+    "time_consuming": 96.79,
+    "status": "success",
+    "timestamp": "2025-11-25 11:49:18",
+    "alpha_id": "3qZYeOx6"
+  },
+  {
+    "expression": "group_zscore(reverse(ts_covariance(ts_rank(high,10),ts_rank(volume,20),20)),sector)",
+    "time_consuming": 75.78,
+    "status": "success",
+    "timestamp": "2025-11-25 11:50:34",
+    "alpha_id": "RRnZmjQb"
+  },
+  {
+    "expression": "reverse(ts_covariance(ts_rank(close,20),ts_rank(volume,10),20))",
+    "time_consuming": 106.53,
+    "status": "success",
+    "timestamp": "2025-11-25 11:52:20",
+    "alpha_id": "KPjYG6QE"
+  },
+  {
+    "expression": "reverse(multiply(ts_covariance(ts_rank(high,10),ts_rank(volume,20),20),ts_zscore(volume,10)))",
+    "time_consuming": 89.55,
+    "status": "success",
+    "timestamp": "2025-11-25 11:53:50",
+    "alpha_id": "RRnZmmRz"
+  },
+  {
+    "expression": "group_neutralize(reverse(ts_covariance(ts_rank(close,10),ts_rank(volume,15),20)),sector)",
+    "time_consuming": 109.25,
+    "status": "success",
+    "timestamp": "2025-11-25 11:55:39",
+    "alpha_id": "RRnZmlwj"
+  },
+  {
+    "expression": "reverse(ts_covariance(ts_rank(high,15),ts_rank(volume,10),15))",
+    "time_consuming": 94.42,
+    "status": "success",
+    "timestamp": "2025-11-25 11:57:14",
+    "alpha_id": "E5X0lZ79"
+  },
+  {
+    "expression": "reverse(divide(ts_covariance(ts_rank(high,10),ts_rank(volume,20),20),ts_std_dev(volume,20)))",
+    "time_consuming": 80.02,
+    "status": "success",
+    "timestamp": "2025-11-25 11:58:34",
+    "alpha_id": "j2bljmx9"
+  },
+  {
+    "expression": "group_rank(reverse(ts_covariance(ts_rank(high,10),ts_rank(volume,20),20)),sector)",
+    "time_consuming": 116.06,
+    "status": "success",
+    "timestamp": "2025-11-25 12:00:30",
+    "alpha_id": "ZYew7o7Y"
+  },
+  {
+    "expression": "reverse(ts_covariance(ts_rank(close,8),ts_rank(volume,25),20))",
+    "time_consuming": 86.46,
+    "status": "success",
+    "timestamp": "2025-11-25 12:01:56",
+    "alpha_id": "bl52jO8Z"
+  },
+  {
+    "expression": "multiply(reverse(ts_covariance(ts_rank(high,10),ts_rank(volume,20),20)),reverse(ts_corr(high,volume,20)))",
+    "time_consuming": 88.18,
+    "status": "success",
+    "timestamp": "2025-11-25 12:03:24",
+    "alpha_id": "akq27g3x"
+  }
+]
--- a/simulator_result/success/success_results_1764050897.json
+++ b/simulator_result/success/success_results_1764050897.json
@ -0,0 +1,128 @@
+[
+  {
+    "expression": "ts_zscore(ts_delta(close, 5), 20)",
+    "time_consuming": 73.51,
+    "status": "success",
+    "timestamp": "2025-11-25 13:39:42",
+    "alpha_id": "Xg5wO37z"
+  },
+  {
+    "expression": "ts_rank(ts_corr(volume, close, 10), 20)",
+    "time_consuming": 75.78,
+    "status": "success",
+    "timestamp": "2025-11-25 13:40:58",
+    "alpha_id": "N1vWGv87"
+  },
+  {
+    "expression": "group_neutralize(ts_av_diff(close, 10), sector)",
+    "time_consuming": 158.19,
+    "status": "success",
+    "timestamp": "2025-11-25 13:43:36",
+    "alpha_id": "E5X0Ml3P"
+  },
+  {
+    "expression": "ts_scale(ts_std_dev(close, 15), 30)",
+    "time_consuming": 89.16,
+    "status": "success",
+    "timestamp": "2025-11-25 13:45:05",
+    "alpha_id": "YPGwOJ6l"
+  },
+  {
+    "expression": "ts_rank(ts_decay_linear(volume, 5), 20)",
+    "time_consuming": 82.35,
+    "status": "success",
+    "timestamp": "2025-11-25 13:46:27",
+    "alpha_id": "N1vWlX2q"
+  },
+  {
+    "expression": "ts_rank(ts_delta(vwap, 3), 10)",
+    "time_consuming": 117.88,
+    "status": "success",
+    "timestamp": "2025-11-25 13:48:25",
+    "alpha_id": "88dkx6xq"
+  },
+  {
+    "expression": "group_zscore(ts_delta(high, 5), sector)",
+    "time_consuming": 124.91,
+    "status": "success",
+    "timestamp": "2025-11-25 13:50:30",
+    "alpha_id": "gJEqVewK"
+  },
+  {
+    "expression": "ts_rank(ts_mean(volume, 10) / ts_mean(volume, 30), 20)",
+    "time_consuming": 116.42,
+    "status": "success",
+    "timestamp": "2025-11-25 13:52:27",
+    "alpha_id": "Xg5wA09X"
+  },
+  {
+    "expression": "ts_rank(ts_delta(close, 1) / ts_delay(close, 1), 10)",
+    "time_consuming": 81.99,
+    "status": "success",
+    "timestamp": "2025-11-25 13:53:49",
+    "alpha_id": "A1MJXKYW"
+  },
+  {
+    "expression": "ts_rank(ts_mean(ts_delta(close, 1), 5), 20)",
+    "time_consuming": 87.52,
+    "status": "success",
+    "timestamp": "2025-11-25 13:55:16",
+    "alpha_id": "N1vWEnxq"
+  },
+  {
+    "expression": "group_neutralize(ts_zscore(ts_delta(high - low, 5), 15), country)",
+    "time_consuming": 76.08,
+    "status": "success",
+    "timestamp": "2025-11-25 13:56:32",
+    "alpha_id": "QPLrR35g"
+  },
+  {
+    "expression": "ts_rank(ts_corr(close, volume, 5), 10)",
+    "time_consuming": 81.12,
+    "status": "success",
+    "timestamp": "2025-11-25 13:57:53",
+    "alpha_id": "xA0w7G7g"
+  },
+  {
+    "expression": "ts_rank(ts_mean(ts_delta(close, 1), 20) / ts_std_dev(close, 20), 30)",
+    "time_consuming": 77.73,
+    "status": "success",
+    "timestamp": "2025-11-25 14:00:39",
+    "alpha_id": "RRnZOLEe"
+  },
+  {
+    "expression": "ts_rank(ts_arg_max(high, 10), 20)",
+    "time_consuming": 77.26,
+    "status": "success",
+    "timestamp": "2025-11-25 14:01:56",
+    "alpha_id": "O0EwLnrd"
+  },
+  {
+    "expression": "ts_rank(ts_av_diff(vwap, 5), 10)",
+    "time_consuming": 77.54,
+    "status": "success",
+    "timestamp": "2025-11-25 14:03:14",
+    "alpha_id": "YPGwVbM6"
+  },
+  {
+    "expression": "group_scale(ts_delta(close, 5), sector)",
+    "time_consuming": 137.56,
+    "status": "success",
+    "timestamp": "2025-11-25 14:05:32",
+    "alpha_id": "KPjYoo68"
+  },
+  {
+    "expression": "ts_rank(ts_delta(ts_mean(close, 3), 5), 10)",
+    "time_consuming": 80.65,
+    "status": "success",
+    "timestamp": "2025-11-25 14:06:52",
+    "alpha_id": "1YQVMQzW"
+  },
+  {
+    "expression": "ts_rank(ts_quantile(ts_delta(close, 1), 10), 20)",
+    "time_consuming": 73.94,
+    "status": "success",
+    "timestamp": "2025-11-25 14:08:06",
+    "alpha_id": "npMkEzgw"
+  }
+]
--- a/simulator_result/success/success_results_1764054880.json
+++ b/simulator_result/success/success_results_1764054880.json
@ -0,0 +1,135 @@
+[
+  {
+    "expression": "ts_delta(close, 5) / ts_mean(close, 20)",
+    "time_consuming": 74.95,
+    "status": "success",
+    "timestamp": "2025-11-25 14:45:09",
+    "alpha_id": "P0dqN33K"
+  },
+  {
+    "expression": "ts_rank(volume, 10) * ts_zscore(close, 20)",
+    "time_consuming": 244.84,
+    "status": "success",
+    "timestamp": "2025-11-25 14:49:14",
+    "alpha_id": "O0EqYY7v"
+  },
+  {
+    "expression": "ts_av_diff(close, 10) / ts_std_dev(close, 20)",
+    "time_consuming": 75.72,
+    "status": "success",
+    "timestamp": "2025-11-25 14:50:30",
+    "alpha_id": "58o3b3dJ"
+  },
+  {
+    "expression": "group_neutralize(ts_delta(close, 3), sector)",
+    "time_consuming": 77.43,
+    "status": "success",
+    "timestamp": "2025-11-25 14:51:47",
+    "alpha_id": "1YQ19zE6"
+  },
+  {
+    "expression": "ts_corr(close, volume, 15) * ts_delta(close, 5)",
+    "time_consuming": 90.76,
+    "status": "success",
+    "timestamp": "2025-11-25 14:53:18",
+    "alpha_id": "vR3xqYQb"
+  },
+  {
+    "expression": "ts_scale(close, 30) * sign(ts_delta(close, 5))",
+    "time_consuming": 144.64,
+    "status": "success",
+    "timestamp": "2025-11-25 14:55:43",
+    "alpha_id": "lebkOq1A"
+  },
+  {
+    "expression": "ts_rank(ts_delta(vwap, 5), 10) - 0.5",
+    "time_consuming": 78.59,
+    "status": "success",
+    "timestamp": "2025-11-25 14:57:01",
+    "alpha_id": "Xg5PQPea"
+  },
+  {
+    "expression": "ts_std_dev(close, 10) / ts_mean(close, 20)",
+    "time_consuming": 125.99,
+    "status": "success",
+    "timestamp": "2025-11-25 14:59:07",
+    "alpha_id": "78E0boq1"
+  },
+  {
+    "expression": "ts_zscore(ts_delta(close, 3), 10) * ts_rank(volume, 5)",
+    "time_consuming": 79.76,
+    "status": "success",
+    "timestamp": "2025-11-25 15:00:27",
+    "alpha_id": "omMA5kAv"
+  },
+  {
+    "expression": "ts_decay_linear(ts_delta(close, 1), 10, dense=false)",
+    "time_consuming": 69.41,
+    "status": "success",
+    "timestamp": "2025-11-25 15:01:37",
+    "alpha_id": "9qLbLzpx"
+  },
+  {
+    "expression": "ts_arg_max(high, 20) - ts_arg_min(low, 20)",
+    "time_consuming": 115.71,
+    "status": "success",
+    "timestamp": "2025-11-25 15:03:32",
+    "alpha_id": "d5AgAmGY"
+  },
+  {
+    "expression": "ts_mean(close, 5) / ts_mean(close, 60) - 1",
+    "time_consuming": 83.86,
+    "status": "success",
+    "timestamp": "2025-11-25 15:04:56",
+    "alpha_id": "E5XYXG1m"
+  },
+  {
+    "expression": "ts_rank(ts_product(close, 3), 10) * sign(ts_delta(close, 1))",
+    "time_consuming": 86.07,
+    "status": "success",
+    "timestamp": "2025-11-25 15:06:29",
+    "alpha_id": "vR3x3ZXv"
+  },
+  {
+    "expression": "ts_covariance(close, volume, 15) / (ts_std_dev(close, 15) * ts_std_dev(volume, 15))",
+    "time_consuming": 104.88,
+    "status": "success",
+    "timestamp": "2025-11-25 15:08:14",
+    "alpha_id": "A1MYMooW"
+  },
+  {
+    "expression": "ts_mean(ts_delta(close, 2), 10) * ts_rank(volume, 20)",
+    "time_consuming": 75.19,
+    "status": "success",
+    "timestamp": "2025-11-25 15:09:29",
+    "alpha_id": "d5AgLwGE"
+  },
+  {
+    "expression": "ts_quantile(close, 20, driver=\"uniform\") - 0.5",
+    "time_consuming": 73.63,
+    "status": "success",
+    "timestamp": "2025-11-25 15:10:43",
+    "alpha_id": "LLAqJnPv"
+  },
+  {
+    "expression": "ts_delta(close, 1) / ts_delta(vwap, 1) - 1",
+    "time_consuming": 82.26,
+    "status": "success",
+    "timestamp": "2025-11-25 15:12:05",
+    "alpha_id": "3qZ3L9jN"
+  },
+  {
+    "expression": "group_scale(ts_delta(close, 5), sector)",
+    "time_consuming": 80.72,
+    "status": "success",
+    "timestamp": "2025-11-25 15:13:26",
+    "alpha_id": "KPjYoo68"
+  },
+  {
+    "expression": "ts_rank(ts_delta(ts_mean(close, 3), 1), 10) * sign(ts_delta(volume, 3))",
+    "time_consuming": 74.11,
+    "status": "success",
+    "timestamp": "2025-11-25 15:14:40",
+    "alpha_id": "P0dq9kOE"
+  }
+]
--- a/simulator_result/success/success_results_1764057125.json
+++ b/simulator_result/success/success_results_1764057125.json
@ -0,0 +1,135 @@
+[
+  {
+    "expression": "group_neutralize(reverse(ts_covariance(ts_rank(close,12),ts_rank(volume,25),20)),sector)",
+    "time_consuming": 99.66,
+    "status": "success",
+    "timestamp": "2025-11-25 15:19:50",
+    "alpha_id": "omMAeGpl"
+  },
+  {
+    "expression": "reverse(multiply(ts_covariance(ts_rank(high,10),ts_rank(volume,20),20),ts_rank(ts_delta(close,1),10)))",
+    "time_consuming": 89.97,
+    "status": "success",
+    "timestamp": "2025-11-25 15:21:20",
+    "alpha_id": "QPLqdwxg"
+  },
+  {
+    "expression": "group_zscore(reverse(ts_covariance(ts_rank(vwap,15),ts_rank(volume,12),18)),sector)",
+    "time_consuming": 152.47,
+    "status": "success",
+    "timestamp": "2025-11-25 15:23:53",
+    "alpha_id": "O0EqenLJ"
+  },
+  {
+    "expression": "multiply(reverse(ts_covariance(ts_rank(high,8),ts_rank(volume,30),20)),ts_zscore(close,10))",
+    "time_consuming": 199.02,
+    "status": "success",
+    "timestamp": "2025-11-25 15:27:19",
+    "alpha_id": "bl5Vpmlp"
+  },
+  {
+    "expression": "group_neutralize(reverse(ts_corr(ts_rank(high,10),ts_rank(volume,20),20)),sector)",
+    "time_consuming": 95.55,
+    "status": "success",
+    "timestamp": "2025-11-25 15:28:54",
+    "alpha_id": "bl5V73OM"
+  },
+  {
+    "expression": "reverse(ts_covariance(ts_rank(close,10),ts_rank(ts_zscore(volume,20),15),20))",
+    "time_consuming": 153.67,
+    "status": "success",
+    "timestamp": "2025-11-25 15:31:28",
+    "alpha_id": "N1vqkagE"
+  },
+  {
+    "expression": "multiply(reverse(ts_covariance(ts_rank(vwap,10),ts_rank(volume,20),20)),reverse(ts_corr(close,volume,10)))",
+    "time_consuming": 88.94,
+    "status": "success",
+    "timestamp": "2025-11-25 15:32:57",
+    "alpha_id": "E5XYox3J"
+  },
+  {
+    "expression": "group_rank(reverse(ts_covariance(ts_rank(close,15),ts_rank(volume,10),20)),sector)",
+    "time_consuming": 149.71,
+    "status": "success",
+    "timestamp": "2025-11-25 15:35:27",
+    "alpha_id": "j2bWlNvW"
+  },
+  {
+    "expression": "reverse(multiply(ts_covariance(ts_rank(high,10),ts_rank(volume,20),20),ts_arg_max(close,10)))",
+    "time_consuming": 89.08,
+    "status": "success",
+    "timestamp": "2025-11-25 15:36:56",
+    "alpha_id": "mLMJ2XW2"
+  },
+  {
+    "expression": "group_neutralize(reverse(ts_covariance(ts_rank(ts_delta(close,3),10),ts_rank(volume,20),20)),sector)",
+    "time_consuming": 103.83,
+    "status": "success",
+    "timestamp": "2025-11-25 15:38:39",
+    "alpha_id": "npMYk6zd"
+  },
+  {
+    "expression": "reverse(divide(ts_covariance(ts_rank(close,10),ts_rank(volume,25),20),ts_rank(volume,10)))",
+    "time_consuming": 77.97,
+    "status": "success",
+    "timestamp": "2025-11-25 15:39:57",
+    "alpha_id": "QPLqrRYX"
+  },
+  {
+    "expression": "multiply(group_zscore(reverse(ts_covariance(ts_rank(high,12),ts_rank(volume,20),20)),sector),reverse(ts_corr(high,volume,15)))",
+    "time_consuming": 98.77,
+    "status": "success",
+    "timestamp": "2025-11-25 15:41:36",
+    "alpha_id": "GrpYYJ95"
+  },
+  {
+    "expression": "reverse(ts_covariance(ts_rank(close,10),ts_rank(ts_decay_linear(volume,20),15),20))",
+    "time_consuming": 88.48,
+    "status": "success",
+    "timestamp": "2025-11-25 15:43:05",
+    "alpha_id": "omMAAnLE"
+  },
+  {
+    "expression": "group_neutralize(multiply(reverse(ts_covariance(ts_rank(vwap,10),ts_rank(volume,20),20)),ts_zscore(close,5)),sector)",
+    "time_consuming": 79.84,
+    "status": "success",
+    "timestamp": "2025-11-25 15:44:24",
+    "alpha_id": "omMAALYv"
+  },
+  {
+    "expression": "reverse(multiply(ts_covariance(ts_rank(high,10),ts_rank(volume,20),20),power(ts_rank(close,5),2)))",
+    "time_consuming": 92.59,
+    "status": "success",
+    "timestamp": "2025-11-25 15:45:57",
+    "alpha_id": "VkgqqRJY"
+  },
+  {
+    "expression": "group_zscore(reverse(ts_covariance(ts_rank(close,20),ts_rank(ts_av_diff(volume,10),15),20)),sector)",
+    "time_consuming": 99.92,
+    "status": "success",
+    "timestamp": "2025-11-25 15:47:37",
+    "alpha_id": "P0dq6W1L"
+  },
+  {
+    "expression": "reverse(add(ts_covariance(ts_rank(high,10),ts_rank(volume,20),20),multiply(0.3,ts_covariance(ts_rank(close,5),ts_rank(volume,10),10))))",
+    "time_consuming": 79.13,
+    "status": "success",
+    "timestamp": "2025-11-25 15:48:56",
+    "alpha_id": "O0Eqkkm7"
+  },
+  {
+    "expression": "multiply(reverse(ts_covariance(ts_rank(close,10),ts_rank(volume,20),20)),ts_rank(ts_delta(close,1),20))",
+    "time_consuming": 100.41,
+    "status": "success",
+    "timestamp": "2025-11-25 15:50:37",
+    "alpha_id": "e7ogK9pp"
+  },
+  {
+    "expression": "group_neutralize(reverse(multiply(ts_covariance(ts_rank(high,10),ts_rank(volume,20),20),add(ts_zscore(close,10),ts_rank(close,5)))),sector)",
+    "time_consuming": 88.38,
+    "status": "success",
+    "timestamp": "2025-11-25 15:52:05",
+    "alpha_id": "ZYeqxMzx"
+  }
+]
--- a/simulator_result/success/success_results_1764058900.json
+++ b/simulator_result/success/success_results_1764058900.json
@ -0,0 +1,107 @@
+[
+  {
+    "expression": "rank(ts_delta(close, 1) * ts_sum(volume, 5)) - rank(ts_corr(close, volume, 20))",
+    "time_consuming": 87.33,
+    "status": "success",
+    "timestamp": "2025-11-25 15:57:18",
+    "alpha_id": "O0EqmJ0b"
+  },
+  {
+    "expression": "group_neutralize(ts_delta(close * volume, 3) / ts_mean(close * volume, 10), sector)",
+    "time_consuming": 76.15,
+    "status": "success",
+    "timestamp": "2025-11-25 15:58:34",
+    "alpha_id": "N1vqj8Ne"
+  },
+  {
+    "expression": "rank(ts_corr(high - low, volume, 10)) * sign(ts_delta(close, 5))",
+    "time_consuming": 80.84,
+    "status": "success",
+    "timestamp": "2025-11-25 15:59:55",
+    "alpha_id": "1YQ1nkm6"
+  },
+  {
+    "expression": "group_rank(ts_mean(close, 5) / ts_mean(close, 20), sector) - ts_rank(volume / ts_mean(volume, 20), 10)",
+    "time_consuming": 118.6,
+    "status": "success",
+    "timestamp": "2025-11-25 16:03:32",
+    "alpha_id": "GrpY3O00"
+  },
+  {
+    "expression": "if_else(close > ts_mean(close, 20), rank(ts_std_dev(close, 10)), reverse(rank(ts_std_dev(close, 10))))",
+    "time_consuming": 91.83,
+    "status": "success",
+    "timestamp": "2025-11-25 16:05:04",
+    "alpha_id": "wpMOJvdQ"
+  },
+  {
+    "expression": "ts_corr(rank(high - close), rank(volume), 15) - ts_corr(rank(close - low), rank(volume), 15)",
+    "time_consuming": 80.27,
+    "status": "success",
+    "timestamp": "2025-11-25 16:06:24",
+    "alpha_id": "58o3axrN"
+  },
+  {
+    "expression": "group_neutralize(divide(ts_sum(if_else(close > ts_delay(close, 1), volume, 0), 10), ts_sum(volume, 10)), sector)",
+    "time_consuming": 80.86,
+    "status": "success",
+    "timestamp": "2025-11-25 16:07:45",
+    "alpha_id": "bl5VoVeN"
+  },
+  {
+    "expression": "ts_rank(divide(vwap - close, ts_std_dev(close, 20)), 10) * ts_rank(ts_corr(close, volume, 10), 20)",
+    "time_consuming": 87.14,
+    "status": "success",
+    "timestamp": "2025-11-25 16:09:42",
+    "alpha_id": "Xg5P2bRX"
+  },
+  {
+    "expression": "rank(ts_sum(if_else(high == ts_delay(ts_arg_max(high, 20), 1), volume, 0), 5)) - rank(ts_mean(volume, 20))",
+    "time_consuming": 75.01,
+    "status": "success",
+    "timestamp": "2025-11-25 16:11:05",
+    "alpha_id": "A1MYgEgW"
+  },
+  {
+    "expression": "divide(ts_covariance(rank(close), rank(volume), 10), ts_std_dev(close, 10) * ts_std_dev(volume, 10))",
+    "time_consuming": 99.76,
+    "status": "success",
+    "timestamp": "2025-11-25 16:12:44",
+    "alpha_id": "E5XYq16R"
+  },
+  {
+    "expression": "group_neutralize(rank(close / ts_delay(close, 1)) - rank(volume / ts_delay(volume, 1)), sector)",
+    "time_consuming": 142.49,
+    "status": "success",
+    "timestamp": "2025-11-25 16:15:07",
+    "alpha_id": "xA09enzb"
+  },
+  {
+    "expression": "ts_corr(close - ts_mean(close, 10), volume - ts_mean(volume, 10), 15) * sign(ts_delta(close, 3))",
+    "time_consuming": 85.93,
+    "status": "success",
+    "timestamp": "2025-11-25 16:16:33",
+    "alpha_id": "O0EqnJLY"
+  },
+  {
+    "expression": "group_rank(ts_delta(close, 1) * ts_decay_linear(volume, 10), sector)",
+    "time_consuming": 116.38,
+    "status": "success",
+    "timestamp": "2025-11-25 16:18:36",
+    "alpha_id": "mLMJqvaK"
+  },
+  {
+    "expression": "ts_zscore(divide(ts_sum(if_else(close > open, volume, 0), 10), ts_sum(if_else(close < open, volume, 0), 10)), 20)",
+    "time_consuming": 92.52,
+    "status": "success",
+    "timestamp": "2025-11-25 16:20:14",
+    "alpha_id": "78E0JgX8"
+  },
+  {
+    "expression": "group_neutralize(rank(ts_std_dev(close, 20)) * rank(ts_delta(volume, 3)) * sign(ts_corr(close, volume, 10)), sector)",
+    "time_consuming": 86.69,
+    "status": "success",
+    "timestamp": "2025-11-25 16:21:40",
+    "alpha_id": "KPjqkbaN"
+  }
+]
--- a/wqb_operator.txt
+++ b/wqb_operator.txt
@ -0,0 +1,197 @@
+Operator: abs(x)
+Description: Absolute value of x
+
+Operator: add(x, y, filter = false), x + y
+Description: Add all inputs (at least 2 inputs required). If filter = true, filter all input NaN to 0 before adding
+
+Operator: densify(x)
+Description: Converts a grouping field of many buckets into lesser number of only available buckets so as to make working with grouping fields computationally efficient
+
+Operator: divide(x, y), x / y
+Description: x / y
+
+Operator: inverse(x)
+Description: 1 / x
+
+Operator: log(x)
+Description: Natural logarithm. For example: Log(high/low) uses natural logarithm of high/low ratio as stock weights.
+
+Operator: max(x, y, ..)
+Description: Maximum value of all inputs. At least 2 inputs are required
+
+Operator: min(x, y ..)
+Description: Minimum value of all inputs. At least 2 inputs are required
+
+Operator: multiply(x ,y, ... , filter=false), x * y
+Description: Multiply all inputs. At least 2 inputs are required. Filter sets the NaN values to 1
+
+Operator: power(x, y)
+Description: x ^ y
+
+Operator: reverse(x)
+Description: - x
+
+Operator: sign(x)
+Description: if input > 0, return 1; if input < 0, return -1; if input = 0, return 0; if input = NaN, return NaN;
+
+Operator: signed_power(x, y)
+Description: x raised to the power of y such that final result preserves sign of x
+
+Operator: sqrt(x)
+Description: Square root of x
+
+Operator: subtract(x, y, filter=false), x - y
+Description: x-y. If filter = true, filter all input NaN to 0 before subtracting
+
+Operator: and(input1, input2)
+Description: Logical AND operator, returns true if both operands are true and returns false otherwise
+
+Operator: if_else(input1, input2, input 3)
+Description: If input1 is true then return input2 else return input3.
+
+Operator: input1 < input2
+Description: If input1 < input2 return true, else return false
+
+Operator: input1 <= input2
+Description: Returns true if input1 <= input2, return false otherwise
+
+Operator: input1 == input2
+Description: Returns true if both inputs are same and returns false otherwise
+
+Operator: input1 > input2
+Description: Logic comparison operators to compares two inputs
+
+Operator: input1 >= input2
+Description: Returns true if input1 >= input2, return false otherwise
+
+Operator: input1!= input2
+Description: Returns true if both inputs are NOT the same and returns false otherwise
+
+Operator: is_nan(input)
+Description: If (input == NaN) return 1 else return 0
+
+Operator: not(x)
+Description: Returns the logical negation of x. If x is true (1), it returns false (0), and if input is false (0), it returns true (1).
+
+Operator: or(input1, input2)
+Description: Logical OR operator returns true if either or both inputs are true and returns false otherwise
+
+Operator: days_from_last_change(x)
+Description: Amount of days since last change of x
+
+Operator: hump(x, hump = 0.01)
+Description: Limits amount and magnitude of changes in input (thus reducing turnover)
+
+Operator: kth_element(x, d, k)
+Description: Returns K-th value of input by looking through lookback days. This operator can be used to backfill missing data if k=1
+
+Operator: last_diff_value(x, d)
+Description: Returns last x value not equal to current x value from last d days
+
+Operator: ts_arg_max(x, d)
+Description: Returns the relative index of the max value in the time series for the past d days. If the current day has the max value for the past d days, it returns 0. If previous day has the max value for the past d days, it returns 1
+
+Operator: ts_arg_min(x, d)
+Description: Returns the relative index of the min value in the time series for the past d days; If the current day has the min value for the past d days, it returns 0; If previous day has the min value for the past d days, it returns 1.
+
+Operator: ts_av_diff(x, d)
+Description: Returns x - tsmean(x, d), but deals with NaNs carefully. That is NaNs are ignored during mean computation
+
+Operator: ts_backfill(x,lookback = d, k=1, ignore="NAN")
+Description: Backfill is the process of replacing the NAN or 0 values by a meaningful value (i.e., a first non-NaN value)
+
+Operator: ts_corr(x, y, d)
+Description: Returns correlation of x and y for the past d days
+
+Operator: ts_count_nans(x ,d)
+Description: Returns the number of NaN values in x for the past d days
+
+Operator: ts_covariance(y, x, d)
+Description: Returns covariance of y and x for the past d days
+
+Operator: ts_decay_linear(x, d, dense = false)
+Description: Returns the linear decay on x for the past d days. Dense parameter=false means operator works in sparse mode and we treat NaN as 0. In dense mode we do not.
+
+Operator: ts_delay(x, d)
+Description: Returns x value d days ago
+
+Operator: ts_delta(x, d)
+Description: Returns x - ts_delay(x, d)
+
+Operator: ts_mean(x, d)
+Description: Returns average value of x for the past d days.
+
+Operator: ts_product(x, d)
+Description: Returns product of x for the past d days
+
+Operator: ts_quantile(x,d, driver="gaussian" )
+Description: It calculates ts_rank and apply to its value an inverse cumulative density function from driver distribution. Possible values of driver (optional ) are "gaussian", "uniform", "cauchy" distribution where "gaussian" is the default.
+
+Operator: ts_rank(x, d, constant = 0)
+Description: Rank the values of x for each instrument over the past d days, then return the rank of the current value + constant. If not specified, by default, constant = 0.
+
+Operator: ts_regression(y, x, d, lag = 0, rettype = 0)
+Description: Returns various parameters related to regression function
+
+Operator: ts_scale(x, d, constant = 0)
+Description: Returns (x - ts_min(x, d)) / (ts_max(x, d) - ts_min(x, d)) + constant. This operator is similar to scale down operator but acts in time series space
+
+Operator: ts_std_dev(x, d)
+Description: Returns standard deviation of x for the past d days
+
+Operator: ts_step(1)
+Description: Returns days' counter
+
+Operator: ts_sum(x, d)
+Description: Sum values of x for the past d days.
+
+Operator: ts_zscore(x, d)
+Description: Z-score is a numerical measurement that describes a value's relationship to the mean of a group of values. Z-score is measured in terms of standard deviations from the mean: (x - tsmean(x,d)) / tsstddev(x,d). This operator may help reduce outliers and drawdown.
+
+Operator: normalize(x, useStd = false, limit = 0.0)
+Description: Calculates the mean value of all valid alpha values for a certain date, then subtracts that mean from each element
+
+Operator: quantile(x, driver = gaussian, sigma = 1.0)
+Description: Rank the raw vector, shift the ranked Alpha vector, apply distribution (gaussian, cauchy, uniform). If driver is uniform, it simply subtract each Alpha value with the mean of all Alpha values in the Alpha vector
+
+Operator: rank(x, rate=2)
+Description: Ranks the input among all the instruments and returns an equally distributed number between 0.0 and 1.0. For precise sort, use the rate as 0
+
+Operator: scale(x, scale=1, longscale=1, shortscale=1)
+Description: Scales input to booksize. We can also scale the long positions and short positions to separate scales by mentioning additional parameters to the operator
+
+Operator: winsorize(x, std=4)
+Description: Winsorizes x to make sure that all values in x are between the lower and upper limits, which are specified as multiple of std.
+
+Operator: zscore(x)
+Description: Z-score is a numerical measurement that describes a value's relationship to the mean of a group of values. Z-score is measured in terms of standard deviations from the mean
+
+Operator: vec_avg(x)
+Description: Taking mean of the vector field x
+
+Operator: vec_sum(x)
+Description: Sum of vector field x
+
+Operator: bucket(rank(x), range="0, 1, 0.1" or buckets = "2,5,6,7,10")
+Description: Convert float values into indexes for user-specified buckets. Bucket is useful for creating group values, which can be passed to GROUP as input
+
+Operator: trade_when(x, y, z)
+Description: Used in order to change Alpha values only under a specified condition and to hold Alpha values in other cases. It also allows to close Alpha positions (assign NaN values) under a specified condition
+
+Operator: group_backfill(x, group, d, std = 4.0)
+Description: If a certain value for a certain date and instrument is NaN, from the set of same group instruments, calculate winsorized mean of all non-NaN values over last d days
+
+Operator: group_mean(x, weight, group)
+Description: All elements in group equals to the mean
+
+Operator: group_neutralize(x, group)
+Description: Neutralizes Alpha against groups. These groups can be subindustry, industry, sector, country or a constant
+
+Operator: group_rank(x, group)
+Description: Each elements in a group is assigned the corresponding rank in this group
+
+Operator: group_scale(x, group)
+Description: Normalizes the values in a group to be between 0 and 1. (x - groupmin) / (groupmax - groupmin)
+
+Operator: group_zscore(x, group)
+Description: Calculates group Z-score - numerical measurement that describes a value's relationship to the mean of a group of values. Z-score is measured in terms of standard deviations from the mean. zscore = (data - mean) / stddev of x for each instrument within its group.