exp_1137

FORMULA_NAME = "Contrarian 52-Week Recovery with Quality-Regime Momentum Arbitration (v1137)"
LOGIC_VARIANT_COUNT = 4
NOTES = """mode=explore; family=contrarian-52w-recovery-quality-regime-momentum-hybrid
New hybrid family that combines deep 52-week contrarian repair, recovery-quality durability filtering, and regime-aware momentum leadership, but resolves their conflicts explicitly instead of averaging them. Each regime branch decides whether a stock should be treated as a washout repair, a skeptical transition candidate, an orderly trend leader, or a defensive compounder; deep drawdowns only earn full credit when repair evidence and business quality agree, while strong trend names can outrank contrarian rebounds only in cleaner tapes.
Deliberate metric coverage: actively use the full momentum cluster (return_1m_pct, return_3m_pct, return_6m_pct, return_12m_pct, momentum_12_1_pct), both recovery metrics (from_200d_ma_pct, from_52w_high_pct), volatility (realized_vol_3m), all three liquidity checks (avg_daily_volume_3m, avg_daily_dollar_volume_3m, trading_days_3m), both income metrics (dividend_yield_ttm_pct, dividend_ttm), all three valuation ratios (pe, forward_pe, peg), a rotated growth set (eps_growth_pct, operating_income_growth_pct, free_cash_flow_growth_pct, forward_eps), both quality margins (operating_margin_pct, free_cash_flow_margin_pct), and one size tilt (market_cap). Deliberately weight revenue_growth_pct plus raw level metrics shares_outstanding, close, adj_close, high_52w, ma_200d, eps_ttm, revenue_ttm, operating_income_ttm, and free_cash_flow_ttm at zero this run to keep the family structurally distinct and avoid double-counting correlated price-level information. Sparse fundamentals are normalized by present weight inside each sleeve before arbitration."""

def score_universe(stocks, regime, ctx):
    def zmap(metric):
        return ctx.z(metric)

    Z = {
        "return_1m_pct": zmap("return_1m_pct"),
        "return_3m_pct": zmap("return_3m_pct"),
        "return_6m_pct": zmap("return_6m_pct"),
        "return_12m_pct": zmap("return_12m_pct"),
        "momentum_12_1_pct": zmap("momentum_12_1_pct"),
        "from_200d_ma_pct": zmap("from_200d_ma_pct"),
        "from_52w_high_pct": zmap("from_52w_high_pct"),
        "realized_vol_3m": zmap("realized_vol_3m"),
        "avg_daily_volume_3m": zmap("avg_daily_volume_3m"),
        "avg_daily_dollar_volume_3m": zmap("avg_daily_dollar_volume_3m"),
        "trading_days_3m": zmap("trading_days_3m"),
        "dividend_yield_ttm_pct": zmap("dividend_yield_ttm_pct"),
        "dividend_ttm": zmap("dividend_ttm"),
        "pe": zmap("pe"),
        "forward_pe": zmap("forward_pe"),
        "peg": zmap("peg"),
        "eps_growth_pct": zmap("eps_growth_pct"),
        "operating_income_growth_pct": zmap("operating_income_growth_pct"),
        "free_cash_flow_growth_pct": zmap("free_cash_flow_growth_pct"),
        "forward_eps": zmap("forward_eps"),
        "operating_margin_pct": zmap("operating_margin_pct"),
        "free_cash_flow_margin_pct": zmap("free_cash_flow_margin_pct"),
        "market_cap": zmap("market_cap"),
    }

    def val(symbol, metric):
        series = Z.get(metric)
        if not series:
            return None
        return series.get(symbol)

    def weighted(symbol, terms):
        total = 0.0
        present = 0.0
        for metric, weight, sign in terms:
            v = val(symbol, metric)
            if v is None:
                continue
            total += weight * sign * v
            present += weight
        if present <= 0.0:
            return 0.0
        return total / present

    def clamp(x, lo, hi):
        if x < lo:
            return lo
        if x > hi:
            return hi
        return x

    bull = 1.0 if regime.get("bull") else 0.0
    breadth = regime.get("breadth")
    avg_vol = regime.get("avg_realized_vol_3m")
    median_200d = regime.get("median_from_200d_ma_pct")

    if breadth is None:
        breadth = 0.5
    if avg_vol is None:
        avg_vol = 30.0
    if median_200d is None:
        median_200d = 0.0

    if bull >= 1.0 and breadth >= 0.62 and median_200d >= 1.5 and avg_vol <= 29.0:
        branch = "orderly_trend"
    elif bull >= 1.0 and (breadth < 0.62 or avg_vol > 29.0):
        branch = "skeptical_transition"
    elif bull < 1.0 and (median_200d < -2.0 or avg_vol >= 36.0):
        branch = "risk_off"
    else:
        branch = "washout_repair"

    scores = {}
    for stock in stocks:
        symbol = stock["symbol"]

        repair = weighted(symbol, [
            ("from_52w_high_pct", 0.26, -1),
            ("from_200d_ma_pct", 0.22, +1),
            ("return_1m_pct", 0.10, +1),
            ("return_3m_pct", 0.14, +1),
            ("realized_vol_3m", 0.08, -1),
            ("avg_daily_dollar_volume_3m", 0.08, +1),
            ("trading_days_3m", 0.05, +1),
            ("market_cap", 0.07, -1),
        ])

        trend = weighted(symbol, [
            ("momentum_12_1_pct", 0.26, +1),
            ("return_6m_pct", 0.22, +1),
            ("return_12m_pct", 0.14, +1),
            ("from_200d_ma_pct", 0.16, +1),
            ("from_52w_high_pct", 0.08, +1),
            ("realized_vol_3m", 0.07, -1),
            ("avg_daily_volume_3m", 0.07, +1),
        ])

        quality = weighted(symbol, [
            ("operating_margin_pct", 0.21, +1),
            ("free_cash_flow_margin_pct", 0.21, +1),
            ("operating_income_growth_pct", 0.14, +1),
            ("free_cash_flow_growth_pct", 0.14, +1),
            ("eps_growth_pct", 0.08, +1),
            ("forward_eps", 0.06, +1),
            ("dividend_ttm", 0.05, +1),
            ("avg_daily_dollar_volume_3m", 0.06, +1),
            ("trading_days_3m", 0.05, +1),
        ])

        value_support = weighted(symbol, [
            ("peg", 0.34, -1),
            ("forward_pe", 0.28, -1),
            ("pe", 0.14, -1),
            ("dividend_yield_ttm_pct", 0.14, +1),
            ("market_cap", 0.10, -1),
        ])

        defense = weighted(symbol, [
            ("realized_vol_3m", 0.24, -1),
            ("from_200d_ma_pct", 0.16, +1),
            ("from_52w_high_pct", 0.10, +1),
            ("operating_margin_pct", 0.13, +1),
            ("free_cash_flow_margin_pct", 0.12, +1),
            ("dividend_yield_ttm_pct", 0.08, +1),
            ("avg_daily_dollar_volume_3m", 0.08, +1),
            ("trading_days_3m", 0.05, +1),
            ("peg", 0.04, -1),
        ])

        recovery_proof = weighted(symbol, [
            ("from_200d_ma_pct", 0.34, +1),
            ("return_1m_pct", 0.16, +1),
            ("return_3m_pct", 0.20, +1),
            ("realized_vol_3m", 0.12, -1),
            ("avg_daily_volume_3m", 0.08, +1),
            ("trading_days_3m", 0.10, +1),
        ])

        drawdown_depth = weighted(symbol, [
            ("from_52w_high_pct", 1.0, -1),
        ])

        durability = weighted(symbol, [
            ("operating_margin_pct", 0.28, +1),
            ("free_cash_flow_margin_pct", 0.24, +1),
            ("operating_income_growth_pct", 0.16, +1),
            ("free_cash_flow_growth_pct", 0.16, +1),
            ("dividend_yield_ttm_pct", 0.08, +1),
            ("forward_pe", 0.08, -1),
        ])

        conflict_bias = drawdown_depth - trend
        reconciliation = clamp(0.5 + 0.7 * recovery_proof + 0.5 * durability - 0.4 * trend, -1.0, 1.0)

        if branch == "washout_repair":
            repair_weight = 0.58 + 0.12 * clamp(conflict_bias, -0.5, 1.0)
            trend_weight = 0.07
            quality_weight = 0.23
            defense_weight = 0.12
            score = (
                repair_weight * repair +
                trend_weight * trend +
                quality_weight * quality +
                defense_weight * defense +
                0.12 * reconciliation -
                0.16 * clamp(drawdown_depth - recovery_proof - durability, 0.0, 2.0)
            )
        elif branch == "skeptical_transition":
            trend_share = clamp(0.34 + 0.18 * (trend - drawdown_depth), 0.20, 0.52)
            repair_share = clamp(0.32 + 0.16 * (drawdown_depth - trend), 0.18, 0.50)
            quality_share = 0.24
            defense_share = 1.0 - trend_share - repair_share - quality_share
            score = (
                trend_share * trend +
                repair_share * repair +
                quality_share * quality +
                defense_share * defense +
                0.10 * value_support +
                0.14 * clamp(recovery_proof + durability - abs(conflict_bias), -1.0, 1.5)
            )
        elif branch == "orderly_trend":
            score = (
                0.47 * trend +
                0.16 * repair +
                0.21 * quality +
                0.08 * value_support +
                0.08 * defense +
                0.10 * clamp(trend + durability - max(drawdown_depth - 0.4, 0.0), -1.0, 2.0)
            )
        else:
            score = (
                0.43 * defense +
                0.24 * quality +
                0.14 * value_support +
                0.11 * trend +
                0.08 * repair +
                0.10 * clamp(durability - drawdown_depth + recovery_proof, -1.5, 1.5)
            )

        scores[symbol] = score

    return scores