Simulasi fill: tangga dari fantasi harga close menuju realita yang sadar antrean

Backtest Anda berisi dua model: model alpha Anda dan model fill Anda. Kebanyakan orang menghabiskan 95% usahanya untuk yang pertama dan mewarisi yang kedua dari framework apa pun yang kebetulan mereka pakai. Ini terbalik. Sinyal biasa-biasa saja dengan model fill yang jujur menghasilkan estimasi PnL yang biasa saja tapi nyata. Sinyal hebat dengan fill_price = candle.close menghasilkan angka yang bukan estimasi dari apa pun — itu hanyalah output dari asumsi yang tidak pernah Anda periksa.

Untuk strategi taker pada instrumen likuid, model fill adalah term koreksi. Untuk apa pun yang melibatkan resting limit order — market making, entry pasif, post-only rebate harvesting — model fill adalah strateginya. Apakah Anda mendapat fill, kapan, berapa kuantitasnya, dan bersyarat pada pergerakan harga berikutnya seperti apa — itulah yang menentukan tanda PnL, bukan cuma besarannya.

Dalam Backtest-live parity kami memetakan taksonomi lengkap divergensi backtest-live dan memberi rating divergensi eksekusi 5/5 tingkat keparahan — kelas terburuk. Artikel itu memberikan tiga level akurasi kasar untuk simulasi fill lalu berlanjut ke topik lain. Artikel ini adalah pendalamannya: tangga lengkap, anak tangga demi anak tangga, dengan lifecycle order sebagai state machine, batas probabilitas fill yang benar-benar bisa Anda hitung, dan eksperimen terukur yang menunjukkan persis di titik mana pada tangga itu strategi maker yang "profitable" berakhir mati.

Tangganya

Setiap anak tangga membutuhkan lebih banyak data dan lebih banyak kode, dan setiap anak tangga menghilangkan bias sistematis tertentu. Anak tangga diurutkan berdasarkan apa yang mereka salah pahami, bukan sekadar berdasarkan biaya.

Anak tangga 0: fill harga close

fill_price = bar.close

Order terisi seketika, penuh, pada harga close dari bar yang menghasilkan sinyal. Sinyal dihitung dari close yang sama itu, jadi Anda bertrading pada data yang belum ada saat harga tercetak: look-ahead bias yang berkedok eksekusi. Strategi apa pun dengan turnover akan terlihat bagus di sini.

Anak tangga 1: open bar berikutnya

fill_price = next_bar.open

Model paling jujur minimum untuk logika taker pada data bar. Sinyal dihitung pada bar $t$, fill terjadi pada harga observable pertama dari bar $t+1$. Ini menghilangkan look-ahead tapi masih mengasumsikan spread nol, impact nol, likuiditas tak terbatas pada harga open, dan kepastian fill 100%. Untuk limit order, model ini merosot menjadi logika touch-fill (lebih lanjut soal mengapa ini beracun di bawah).

Anak tangga 2: spread + slippage tetap

half_spread = mid * spread_bps / 2e4
slip        = mid * slippage_bps / 1e4
fill_price  = mid + side * (half_spread + slip)   # side: +1 buy, -1 sell

Sekarang setiap trade taker membayar setengah spread plus konstanta terkalibrasi. Ini anak tangga pertama di mana strategi turnover tinggi bisa mati dalam backtest — dan itulah intinya. Error residualnya: slippage tidak konstan. Ia berskala dengan ukuran order relatif terhadap depth yang ditampilkan dan meledak persis ketika strategi Anda paling ingin bertrading. Angka tetap 5 bps adalah rata-rata dari berbagai rezim; strategi Anda tidak bertrading pada rezim rata-rata.

Anak tangga 3: depth-walk L2 untuk market order

Dengan snapshot order book, Anda berhenti menebak slippage dan mulai menghitungnya. Market buy sebesar $Q$ menyusuri sisi ask level demi level; harga fill adalah rata-rata tertimbang volume di seluruh level yang terkonsumsi:

$P_{\text{fill}}(Q) = \frac{1}{Q}\sum_{i} p_i \cdot \min\!\left(q_i,\; Q - \textstyle\sum_{j<i} q_j\right)$

def depth_walk(levels: list[tuple[float, float]], qty: float) -> tuple[float, float]:
    """levels: [(price, size), ...] sorted best-first. Returns (vwap, filled_qty)."""
    remaining, cost = qty, 0.0
    for price, size in levels:
        take = min(size, remaining)
        cost += take * price
        remaining -= take
        if remaining <= 0:
            break
    filled = qty - remaining
    return (cost / filled if filled > 0 else float("nan"), filled)

Dua koreksi membuat ini secara material lebih jujur. Pertama, latensi: susuri book sebagaimana keadaannya $\Delta t$ setelah timestamp keputusan Anda, di mana $\Delta t$ adalah latensi sinyal-ke-exchange yang terukur — book yang Anda lihat bukan book yang Anda kenai. Kedua, partial fill yang marketable: jika depth yang ditampilkan dalam batas harga limit-through Anda kurang dari $Q$, model harus mengembalikan partial fill dan menyisakan sisa yang resting, yang menyerahkan masalah ke state machine di bawah.

Error residual pada anak tangga 3 adalah impact dan refill: Anda mengonsumsi book sebagai objek statis, tapi book nyata sebagian terisi ulang (dan counterparty nyata bereaksi). Untuk ukuran clip di bawah beberapa persen dari depth top-of-book, error ini kecil; untuk clip lebih besar Anda butuh model impact (Almgren-Chriss 2001) yang dilapisi di atasnya.

Anak tangga 4: fill probabilistik berbasis posisi antrean untuk limit order

Anak tangga 0-3 menjawab "pada harga berapa order agresif saya terisi." Anak tangga 4 menjawab pertanyaan yang lebih sulit: apakah order pasif saya terisi sama sekali — dan inilah satu-satunya anak tangga yang bisa menghargai strategi maker. Resting limit order pada harga $p$ terisi ketika volume trading kumulatif pada $p$ melampaui volume antrean yang berada di depannya. Itu memerlukan pelacakan posisi Anda dalam antrean FIFO yang tidak bisa Anda amati secara langsung.

Mesin estimasi posisi antrean — posisi awal, aturan update pada trade vs. cancel, keluarga probabilitas $f(x)$ untuk mengalokasikan cancellation yang tak teramati — adalah primitif yang kami bangun di Queue inside the wall. Saya tidak akan menurunkannya ulang di sini; simulator ini mengonsumsinya. Yang ditambahkan anak tangga 4 adalah aturan keputusan fill di atas estimasi tersebut, dibahas di bagian probabilitas fill di bawah.

Mengapa anak tangga ini penting dikuantifikasi dalam literatur: Moallemi dan Yuan (2016), "A Model for Queue Position Valuation in a Limit Order Book," menunjukkan bahwa untuk instrumen large-tick, nilai ekonomi dari posisi front-of-queue dibandingkan back-of-queue sebanding dengan half-spread — orde besaran yang sama dengan seluruh edge teoretis strategi market making. Model fill yang mengabaikan posisi antrean tidak sekadar salah estimasi PnL maker; ia mengestimasi PnL dari strategi yang berbeda sama sekali.

Ada anak tangga 5 — simulasi agent-based penuh di mana market bereaksi terhadap order Anda (model queue-reactive dalam pengertian Huang, Lehalle dan Rosenbaum 2015; framework multi-agent seperti ABIDES, Byrd et al. 2020). Replay historis, sekalipun sadar antrean, mengasumsikan order Anda tidak mengubah apa pun dalam perilaku semua orang lain. Asumsi itu masih wajar pada skala ritel dan makin salah seiring quote Anda menjadi fraksi yang terlihat dari suatu level. Anak tangga 5 di luar cakupan di sini; ketahuilah bahwa tangga ini tidak berhenti di 4.

Partial fill sebagai state machine

Anak tangga 0-2 bisa berpura-pura bahwa order adalah pemanggilan fungsi: submit, dapat harga, selesai. Mulai anak tangga 3 ke atas, order adalah proses dengan lifecycle, dan simulator harus memodelkannya sebagai state machine atau ia akan diam-diam salah menangani kasus-kasus yang paling penting.

enum OrderState {
    PendingNew,                                  // sent, not yet acked (latency window)
    Resting     { remaining: f64, q_ahead: f64 }, // in book, queue position estimated
    PartialFill { remaining: f64, q_ahead: f64 }, // some qty done, rest still queued
    PendingAmend,                                 // amend in flight
    PendingCancel,                                // cancel in flight
    Filled,
    Canceled    { filled_qty: f64 },              // may be partially filled at cancel time
    Rejected,
}

Transisi-transisi ini membawa muatan ekonominya:

• PendingNew → Resting: order bergabung ke antrean di belakang segala sesuatu yang sudah ada pada saat ack, bukan pada saat keputusan diambil. Posisi antrean Anda diinisialisasi dengan volume level pada saat $t + \Delta t_{\text{ack}}$. Simulator yang menginisialisasi pada saat keputusan secara sistematis melebih-lebihkan prioritas antrean — persis sebesar volume yang datang selama window latensi Anda, yang notabene adalah mayoritas volume saat terjadi burst.
• Resting → PartialFill: trade pada level Anda yang lebih besar dari antrean di depan Anda mengisi Anda sebagian. Sisanya mempertahankan posisinya (kini di depan antrean). Partial fill bukan noise — ia adalah informasi: terisi 0,3 dari 1,0 lalu menyaksikan harga memantul menjauh adalah peristiwa PnL yang berbeda dari full fill, dan proses inventory maker dibangun dari fragmen-fragmen semacam ini.
• Resting → PendingAmend → Resting: jebakannya. Di hampir semua venue crypto, amend adalah cancel/replace — cancelReplace milik Binance bersifat atomik terhadap eksekusi ganda tapi mengembalikan order ID baru di belakang antrean. Bahkan venue dengan semantik modify native (CME Globex) hanya mempertahankan time priority untuk pengurangan kuantitas; perubahan harga atau kenaikan kuantitas menghilangkan prioritas tersebut. Jadi dalam simulator: amend harga apa pun mereset q_ahead ke seluruh volume level saat ini. Engine quoting yang re-peg tiap 500ms bukan "mempertahankan quote" — ia terus-menerus masuk ulang di belakang antrean, dan profil fill realistisnya adalah hampir murni adverse selection. Digabung dengan hasil Moallemi-Yuan: re-quoting punya harga, dan harganya adalah posisi antrean Anda.
• PendingCancel → PartialFill → Canceled: cancel juga butuh latensi. Dalam window antara keputusan menarik quote dan cancel mencapai matching engine, Anda masih bisa terisi — dan fill-fill itu adalah fill terburuk yang akan pernah Anda terima, karena alasan Anda menarik quote adalah market akan segera melindas Anda. Simulator tanpa latensi cancel menghapus persis fill-fill paling toksik dari riwayat Anda.

State machine ini juga yang membuat pembukuan simulator jujur: fee terakumulasi per event fill, inventory ter-update per event fill, dan statistik time-in-state (berapa lama order resting sebelum terisi vs. dibatalkan) menjadi langsung comparable dengan log live — yang menjadi input bagi loop kalibrasi di bagian akhir.

Probabilitas fill limit order: tiga model dan sebuah bracket

Diberikan order resting pada harga $p$ (misalnya bid), kapan simulator mendeklarasikan sebuah fill? Tiga aturan keputusan, dengan tingkat kejujuran meningkat:

1. Touch-fill (naif). Fill jika harga menyentuh level Anda: $\text{low}_t \le p$. Ini adalah aturan first-passage-time, dan kegagalannya sudah diukur seperempat abad lalu: Lo, MacKinlay dan Zhang (2002), "Econometric Models of Limit-Order Executions" (Journal of Financial Economics 65), mem-fit model survival ke data limit order aktual dan menyimpulkan bahwa eksekusi hipotetis yang dikonstruksi dari first-passage time "adalah proksi yang sangat buruk untuk eksekusi limit order aktual." Mode kegagalannya bersifat struktural: ketika harga menyentuh level Anda lalu memantul, sentuhan itu mengonsumsi depan antrean — trader yang meng-quote sebelum Anda. Touch-fill menghadiahkan Anda fill milik mereka. Lebih buruk lagi, ia menghadiahkan persis fill yang bagus (touch-and-bounce adalah skenario profitable bagi maker), sementara fill nyata Anda condong ke touch-and-run-through — yang kena adverse selection.

2. Trade-through (batas konservatif). Fill hanya jika harga trading secara ketat melewati level Anda: $\text{low}_t < p - \epsilon$, atau pada data tick, volume trading kumulatif pada $p$ melampaui seluruh level. Jika harga trading tembus, seluruh antrean pada $p$ telah terkonsumsi, jadi Anda terisi terlepas dari posisi Anda. Ini tidak pernah menghadiahkan fill yang tidak akan Anda dapatkan. Biasnya adalah cerminan dari touch-fill: ia menolak setiap fill di mana antrean habis hingga posisi Anda tanpa penetrasi penuh, dan fill yang tetap diberikannya secara tidak proporsional adalah yang run-through (kena adverse selection). Backtest maker di bawah trade-through adalah stress test, bukan estimasi.

3. Estimasi queue-depletion. Lacak volume trading kumulatif $M_t$ pada harga Anda dari trade tape dan volume yang dibatalkan $C_t$ yang diinferensikan dari delta L2. Estimasi antrean di depan Anda:

$\hat{Q}_{\text{ahead}}(t) = \max\!\Big(Q_0 - M_t - \phi \cdot C_t,\; 0\Big)$

di mana $Q_0$ adalah volume level pada saat order masuk (waktu-ack) dan $\phi \in [0,1]$ adalah fraksi cancellation yang diasumsikan berasal dari depan Anda — knob yang bentuk prinsipilnya (keluarga $f(x)$) diturunkan di artikel posisi antrean. Fill dimulai ketika $\hat{Q}_{\text{ahead}} = 0$; kuantitas terisi Anda adalah volume trading yang melebihi itu, yang menghasilkan partial fill secara alami:

$\text{filled}(t) = \min\!\Big(S,\; \max(M_t - Q_0 + \phi\, C_t,\, 0)\Big)$

Menetapkan $\phi = 1$ (semua cancel di depan Anda) memberikan sisi optimistis model ini; $\phi = 0$ sisi pesimistisnya. Ketika Anda hanya punya snapshot L2 yang jarang dan tanpa trade tape pada level tersebut — umum terjadi pada feed crypto yang di-throttle 100ms — Anda bisa mengandalkan prior berbasis model: Cont, Stoikov dan Talreja (2010), "A Stochastic Model for Order Book Dynamics" (Operations Research 58), memodelkan setiap level harga sebagai antrean birth-death dan menghitung, lewat transformasi Laplace, probabilitas bahwa order pada bid tereksekusi sebelum mid bergerak, bersyarat pada ukuran antrean saat ini. Ini adalah oracle probabilitas fill analitik: kasar dibandingkan replay tape, jauh lebih baik daripada touch-fill, dan cukup murah untuk dievaluasi di dalam hot loop backtest.

Disiplin bracket

Ketiga aturan ini bukan pesaing — mereka adalah sebuah urutan:

$\text{fills}_{\text{trade-through}} \;\subseteq\; \text{fills}_{\text{queue}} \;\subseteq\; \text{fills}_{\text{touch}}$

yang menginduksi sebuah bracket PnL. Jalankan setiap backtest maker tiga kali dan laporkan intervalnya:

$\text{PnL}_{\text{trade-through}} \;\le\; \text{PnL}_{\text{live}} \lesssim \text{PnL}_{\text{touch}}$

(ketaksamaan sisi atas bersifat aproksimatif — touch-fill bisa salah mengurutkan strategi, bukan hanya menggelembungkannya, karena ia menghadiahkan fill bagus yang bersifat kontrafaktual). Aturan keputusan yang mengikutinya: strategi maker layak deploy hanya jika ia bertahan pada sisi konservatif bracket, dan bracket-nya cukup sempit sehingga point estimate-nya berarti sesuatu. Strategi yang menunjukkan +$9k touch / -$3k trade-through punya bracket selebar $12k; Anda tidak tahu apa-apa selain bahwa asumsi simulator Anda mendominasi alpha Anda. Strategi yang menunjukkan +$2,1k / +$0,4k sedang memberi tahu Anda sesuatu yang nyata.

Eksperimen: menuruni tangga dengan satu strategi maker

Ambil satu maker yang sengaja dibuat sederhana — quote simetris pada best bid/ask, clip tetap 0,05 BTC, inventory dibatasi pada ±0,5 BTC dengan taker flattening pada batas tersebut. Data satu bulan BTCUSDT perpetual: bar 1m untuk anak tangga rendah, diff L2 100ms plus trade tape untuk anak tangga tinggi; fee maker 1,0 bps, taker 4,0 bps. Kode sinyal yang sama di setiap anak tangga (shared core, sehingga satu-satunya variabel adalah model fill). Angka-angka di bawah adalah satu run representatif milik kami — besaran Anda akan berbeda tergantung venue, bulan, dan ukuran; bentuknya tidak akan berbeda:

Baca tabel dari atas ke bawah dan amati di mana strategi ini mati. Bukan di anak tangga 2 — fee dan slippage memangkas 26% dan strategi masih terlihat profitable secara robust. Ia mati antara anak tangga 3 dan anak tangga 4, dan matinya karena alasan yang tidak bisa ditangkap oleh model biaya mana pun: seleksi fill. Touch-fill menghadiahkan 37.400 fill yang mayoritasnya adalah touch-and-bounce — spread capture murni. Model yang sadar antrean menghapus 58% dari fill-fill itu, dan fill yang dihapusnya secara tidak proporsional adalah yang profitable: ketika level hanya tersentuh ringan, antrean di depan maker yang re-quote dengan latensi ritel menyerap semuanya. Fill yang bertahan hingga anak tangga 4 condong ke sweep yang membersihkan level — fill di mana harga sudah bergerak menembus posisi Anda. Rasio fill turun 2,4x; PnL berbalik tanda. Asimetri itu — kehilangan fill bagus, mempertahankan fill buruk — adalah adverse selection yang dibuat eksplisit secara mekanis, dan itu tidak terlihat di anak tangga mana pun di bawah 4.

Perhatikan juga apa yang dilakukan bracket ini: [-$3.900, +$1.900] melintasi nol dengan estimasi terkalibrasi di -$700 dan live di -$1.150. Simulator ini tidak menebak PnL live secara persis hingga ke dolarnya — ia menangkap tanda, besarannya, dan rasio fill dalam selisih 2 poin. Itulah fungsi model fill. Backtest anak tangga 1 meleset dari PnL live sebesar $10.750 pada strategi yang seluruh edge gross bulanannya hanya beberapa ribu dolar: error model fill kira-kira 3x lebih besar dari ukuran alpha-nya. Maka tesisnya: model fill Anda adalah asumsi yang lebih besar daripada alpha Anda.

Satu catatan untuk anak tangga rendah: jika Anda terpaksa hidup dengan data bar (anak tangga 0-2), minimal selesaikan ambiguitas intrabar dengan adaptive drill-down — drill dari 1m ke 1s/100ms/trades di mana level SL, TP, atau quote jatuh di dalam rentang bar. Drill-down memperbaiki error sekuens (level mana yang tersentuh lebih dulu) tapi tidak bisa memperbaiki error antrean; ia adalah pendamping resolusi data untuk artikel ini, bukan pengganti anak tangga 4.

Loop kalibrasi: menutup celah terhadap fill live

Simulator anak tangga 4 punya parameter bebas — $\phi$, latensi $\Delta t$, latensi cancel, asumsi refill level. Tanpa kalibrasi, ia hanyalah tebakan dengan bentuk yang berbeda. Loop yang mengubahnya menjadi instrumen:

1. Log semuanya secara live. Setiap event order dengan timestamp exchange: submit, ack, tiap partial fill, ack amend, ack cancel. Plus state L2 pada saat submit. Ini adalah disiplin logging yang sama yang dituntut backtest-live parity untuk DivergenceMonitor-nya — kalibrasi model fill adalah lapisan terdalam dari monitor itu.

2. Replay order yang sama lewat simulator. Umpankan data market yang terekam dan instruksi order yang terekam (bukan fill-nya) ke dalam simulator. Sekarang Anda punya hasil berpasangan: untuk tiap order live, ada satu nasib simulasi.

3. Bandingkan distribusi, bukan rata-rata, dalam bucket. Satu kecocokan rasio fill global tunggal bisa menyembunyikan error yang saling mengompensasi (terlalu optimistis pada rezim tenang, terlalu pesimistis pada burst — hasil bersihnya "terkalibrasi"). Kelompokkan berdasarkan pendorongnya:

import numpy as np
from scipy.stats import ks_2samp

def calibration_report(pairs, bucket_key):
    """pairs: [{'bucket':…, 'live_filled':bool, 'sim_filled':bool,
                'live_ttf':float|None, 'sim_ttf':float|None}, …]"""
    out = {}
    for b in sorted({p['bucket'] for p in pairs}):
        grp = [p for p in pairs if p['bucket'] == b]
        live_fr = np.mean([p['live_filled'] for p in grp])
        sim_fr  = np.mean([p['sim_filled']  for p in grp])
        live_ttf = [p['live_ttf'] for p in grp if p['live_ttf'] is not None]
        sim_ttf  = [p['sim_ttf']  for p in grp if p['sim_ttf']  is not None]
        ks = ks_2samp(live_ttf, sim_ttf) if len(live_ttf) > 20 and len(sim_ttf) > 20 else None
        out[b] = {
            'n': len(grp),
            'fill_rate_live': live_fr,
            'fill_rate_sim':  sim_fr,
            'fill_rate_gap':  sim_fr - live_fr,      # signed: + means sim optimistic
            'ttf_ks_pvalue':  ks.pvalue if ks else None,
        }
    return out

Dua statistik per bucket: fill-rate gap bertanda (simulator dikurangi live) dan uji KS pada distribusi time-to-fill di antara order yang terisi. Perbandingan time-to-fill adalah yang paling tajam — simulator bisa mencocokkan rasio fill sambil mengisi pada waktu yang secara sistematis salah, yang merusak setiap statistik inventory dan adverse-selection di hilirnya. Ini persis pelajaran dari kerangka survival-analysis Lo-MacKinlay-Zhang: eksekusi adalah masalah time-to-event, jadi validasilah sebagai itu.

4. Fit knob-nya, berdasarkan urutan identifiability. Latensi lebih dulu (terukur langsung dari timestamp ack — bukan hasil fitting). Lalu $\phi$ dengan meminimalkan fill-rate gap di seluruh bucket kedalaman antrean. Lalu periksa bucket rezim volatilitas: gap optimistis yang persisten dan terkonsentrasi di bucket burst biasanya berarti simulator Anda kurang memodelkan fill toksik akibat latensi cancel atau refill level, bukan masalah $\phi$.

5. Jalankan ulang bracket-nya. Setelah kalibrasi, estimasi queue-depletion seharusnya berada di dalam bracket dekat live, dan — uji penerimaan sesungguhnya — ranking varian strategi di bawah simulator harus cocok dengan ranking-nya dalam mode shadow. Lalu bekukan parameternya dan kalibrasi ulang sesuai jadwal; dinamika fill bergeser mengikuti tier fee venue, perubahan tick-size, dan populasi HFT, dan $\phi$ yang dikalibrasi pada bulan Maret hanyalah hipotesis pada bulan Juli.

Ekspektasi konvergensi dari run kami: simulator anak tangga 4 yang belum dikalibrasi biasanya berada dalam ±10-15 poin dari rasio fill live; setelah satu putaran kalibrasi, ±3-5 poin, dengan p-value KS time-to-fill yang tidak lagi konsisten menolak hipotesis nol. Anda tidak akan bisa mengungguli itu dengan replay historis — residualnya adalah reaksi market terhadap Anda, yang menjadi masalah anak tangga 5.

Yang perlu dibawa pulang

1. Beri nama pada anak tangga Anda. Setiap backtest berada pada tangga ini entah Anda yang memilih anak tangganya atau framework Anda yang memilihkannya. Jika Anda tidak bisa menamai anak tangga model fill Anda dan bias-bias yang diketahuinya, angka PnL Anda punya error bar yang belum pernah Anda lihat.
2. Taker bisa berhenti di anak tangga 3. Depth-walk plus latensi terukur menghargai eksekusi agresif secara jujur pada skala ritel. Alokasikan usaha yang terhemat untuk kualitas data.
3. Maker mulai di anak tangga 4. Di bawahnya, logika fill limit order bukan sekadar aproksimasi — ia memilih himpunan fill kontrafaktual dengan skew adverse-selection yang berlawanan. Backtest touch-fill untuk strategi maker adalah generator paling andal untuk strategi yang mati begitu bersentuhan dengan produksi.
4. Modelkan lifecycle-nya, bukan cuma fill-nya. Partial fill, amend-mereset-antrean, latensi cancel — state machine adalah tempat fill-fill toksik itu bersembunyi, dan fill toksik adalah tempat PnL maker berakhir mati.
5. Laporkan bracket-nya. Batas konservatif dan optimistis hanya berharga dua run backtest ekstra dan mengubah "backtest saya bilang +$7k" menjadi "realitanya ada di suatu tempat dalam [-$3,9k, +$1,9k]" — yang merupakan keputusan berbeda, dan lebih baik.
6. Kalibrasi terhadap fill live dalam bucket. Model fill yang divalidasi hanya secara agregat adalah model fill dengan error tersembunyi yang saling mengompensasi. Fill-rate gap per bucket ditambah uji KS time-to-fill, dikalibrasi ulang tiap kuartal.

Anak tangga pada tangga ini bukan gradasi akademis — masing-masing adalah kebohongan spesifik yang berhenti diceritakan backtest Anda. Naiklah sampai kebohongan itu lebih kecil daripada edge Anda.

Tautan berguna

1. Moallemi, C., Yuan, K. — A Model for Queue Position Valuation in a Limit Order Book (2016)
2. Cont, R., Stoikov, S., Talreja, R. — A Stochastic Model for Order Book Dynamics, Operations Research 58(3), 549-563 (2010)
3. Lo, A., MacKinlay, C., Zhang, J. — Econometric Models of Limit-Order Executions, Journal of Financial Economics 65(1), 31-71 (2002)
4. Huang, W., Lehalle, C.-A., Rosenbaum, M. — Simulating and Analyzing Order Book Data: The Queue-Reactive Model, JASA 110(509), 107-122 (2015)
5. Almgren, R., Chriss, N. — Optimal Execution of Portfolio Transactions (2001)
6. Byrd, D., Hybinette, M., Balch, T. — ABIDES: Towards High-Fidelity Multi-Agent Market Simulation (2020)
7. Binance API — Cancel-Replace order semantics
8. CME Globex — Order modification and time priority rules

Sitasi

@article{soloviov2026fillsimulation,
  author = {Soloviov, Eugen},
  title = {Fill simulation: the ladder from close-price fantasy to queue-aware reality},
  year = {2026},
  url = {https://marketmaker.cc/blog/fill-simulation-partial-fills-backtest},
  description = {Five rungs of fill simulation fidelity — from close-price fills to probabilistic queue-position models. Partial fills as a state machine, limit-fill probability bounds as a PnL bracket, and a calibration loop against live fills.}
}