9 / Run the miniature system and define the promotion decision

Python implementation

Self-contained teaching example. Python 3.10+; dependencies and input conventions are shown in the code and notation. Run in your own Python environment.

from math import floor, isfinite

# Offline synthetic teaching simulator. No broker, network or fitted predictive model.
# Bars are chronologically ordered session records: {time, open, close}.
# After close t, choose a share quantity using only information through t.
# A cash-budget guard at the next open may reduce it, then exit that session.
def run_training_system(bars,capital=10000,lookback=2,probability=.56,
                        gain=.012,loss=.008,volatility=.02,
                        target_vol=.005,max_weight=.25,
                        fee_rate=.0001,exit_slip_rate=.0008):
    values=[capital,probability,gain,loss,volatility,target_vol,max_weight,fee_rate,exit_slip_rate]
    if not all(isfinite(x) for x in values): raise ValueError("Finite inputs required")
    if capital<=0 or volatility<=0 or not 0<=probability<=1 or not 0<=max_weight<=1 or min(gain,loss,target_vol,fee_rate,exit_slip_rate)<0:
        raise ValueError("Invalid model/risk/cost inputs")
    if not isinstance(lookback,int) or lookback<1 or len(bars)<=lookback:
        raise ValueError("Enough historical bars required")
    for i,b in enumerate(bars):
        if not all(isfinite(b[k]) and b[k]>0 for k in ['open','close']): raise ValueError("Positive finite prices required")
        if i and b['time']<=bars[i-1]['time']: raise ValueError("Unique increasing session times required")
    cost_rate=2*fee_rate+exit_slip_rate # both fees use entry notional in this toy
    edge=probability*gain-(1-probability)*loss-cost_rate
    cash=capital; trace=[]
    for t in range(lookback-1,len(bars)-1):
        history=[b['close'] for b in bars[t-lookback+1:t+1]]
        reference=history[-1]; feature=reference/(sum(history)/lookback)-1
        weight=min(max_weight,target_vol/volatility)
        target=floor(cash*weight/reference) if feature>0 and edge>0 else 0
        decision={'decision_time':bars[t]['time'],'feature':feature,'edge':edge,'target':target}
        nxt=bars[t+1]; entry=nxt['open']
        # Conservative cash and reference-dollar budget guards at execution time.
        quantity=min(target,floor(cash*weight/entry),floor(cash/(entry*(1+2*fee_rate))))
        exit_price=nxt['close']-entry*exit_slip_rate
        if exit_price<0: raise ValueError("Cost scenario implies an invalid exit price")
        before=cash; fee=quantity*entry*fee_rate
        cash-=quantity*entry+fee
        cash+=quantity*exit_price-fee
        trace.append({**decision,'execution_time':nxt['time'],'filled':quantity,
                      'entry':entry,'exit':exit_price,'fees':2*fee,
                      'pnl':cash-before,'cash':cash,'ending_holdings':0})
    return {'cash':cash,'pnl':cash-capital,'trace':trace}

bars=[{'time':1,'open':99,'close':99},
      {'time':2,'open':99,'close':100},
      {'time':3,'open':100,'close':101}]
print(run_training_system(bars))