exp_1148

FORMULA_NAME = "Recovery Quality Contrarian 52W Hybrid (Arbitrated Relay, v1148)"
LOGIC_VARIANT_COUNT = 4
NOTES = """mode=explore; family=recovery-quality-contrarian-52w-hybrid
This hybrid combines four distinct sleeves rather than averaging parents mechanically: a panic-repair sleeve for deep 52-week washouts that are proving they can rebound, a skeptical transition sleeve for messy tapes where quality must validate recovery before price strength is trusted, a trend-graduation sleeve where repaired names can outrank pure momentum only after crossing a quality-and-stability gate, and a defensive compounder sleeve for risk-off conditions. The explicit arbitration mechanism is stock-level: deep drawdown only helps when near-term repair is real, clean trend only wins when the name is not excessively extended versus recovery evidence, and weak-quality contrarian bounces are capped so low-quality dead-cat rallies do not dominate.
Deliberate metric coverage this run: actively use momentum (return_1m_pct, return_3m_pct, return_6m_pct, momentum_12_1_pct), trend/recovery (from_200d_ma_pct, from_52w_high_pct), volatility (realized_vol_3m), liquidity (avg_daily_volume_3m, avg_daily_dollar_volume_3m, trading_days_3m), income (dividend_yield_ttm_pct), valuation (forward_pe, peg), growth (operating_income_growth_pct, free_cash_flow_growth_pct, forward_eps), quality (operating_margin_pct, free_cash_flow_margin_pct), and size (market_cap). Deliberate weight-0 metrics this run: return_12m_pct, dividend_ttm, pe, eps_growth_pct, revenue_growth_pct, shares_outstanding, close, adj_close, high_52w, ma_200d, eps_ttm, revenue_ttm, operating_income_ttm, free_cash_flow_ttm."""

# Deliberate weight-0 metrics this run:
# - Momentum/return: return_12m_pct
# - Income: dividend_ttm
# - Valuation: pe
# - Growth: eps_growth_pct, revenue_growth_pct
# - Raw levels / duplicate size-price information: shares_outstanding, close, adj_close,
#   high_52w, ma_200d, eps_ttm, revenue_ttm, operating_income_ttm, free_cash_flow_ttm

def score_universe(stocks, regime, ctx):
    def clamp(x, lo, hi):
        if x < lo:
            return lo
        if x > hi:
            return hi
        return x

    def as_number(x):
        if isinstance(x, bool):
            return 1.0 if x else 0.0
        if isinstance(x, (int, float)):
            return float(x)
        return None

    def metric_value(stock, name):
        return as_number(stock.get(name))

    def regime_value(name, default):
        v = None
        if isinstance(regime, dict):
            v = as_number(regime.get(name))
        if v is None and isinstance(ctx, dict):
            v = as_number(ctx.get(name))
        if v is None:
            return default
        return v

    def percentile_maps(metric_names):
        maps = {}
        for name in metric_names:
            vals = []
            for stock in stocks:
                v = metric_value(stock, name)
                if v is not None:
                    vals.append(v)
            vals.sort()
            n = len(vals)
            if n == 0:
                maps[name] = None
                continue
            ranks = {}
            i = 0
            while i < n:
                j = i + 1
                while j < n and vals[j] == vals[i]:
                    j += 1
                rank = ((i + j - 1) * 0.5) / (n - 1) if n > 1 else 0.5
                ranks[vals[i]] = rank
                i = j
            maps[name] = ranks
        return maps

    def pct(stock, name, invert=False):
        v = metric_value(stock, name)
        if v is None:
            return None
        ranks = rank_maps.get(name)
        if ranks is None:
            return None
        p = ranks.get(v)
        if p is None:
            return None
        return 1.0 - p if invert else p

    def blend(stock, parts):
        total = 0.0
        wsum = 0.0
        for metric_name, weight, invert in parts:
            p = pct(stock, metric_name, invert)
            if p is None:
                continue
            total += weight * p
            wsum += weight
        if wsum <= 0.0:
            return 0.0
        return total / wsum

    def liquidity_gate(stock):
        adv = pct(stock, "avg_daily_dollar_volume_3m", False)
        av = pct(stock, "avg_daily_volume_3m", False)
        td = pct(stock, "trading_days_3m", False)
        total = 0.0
        wsum = 0.0
        if adv is not None:
            total += 0.5 * adv
            wsum += 0.5
        if av is not None:
            total += 0.3 * av
            wsum += 0.3
        if td is not None:
            total += 0.2 * td
            wsum += 0.2
        if wsum <= 0.0:
            return 0.5
        return total / wsum

    def recovery_core(stock):
        return blend(stock, [
            ("from_52w_high_pct", 0.36, True),
            ("from_200d_ma_pct", 0.24, True),
            ("return_1m_pct", 0.16, False),
            ("return_3m_pct", 0.14, False),
            ("realized_vol_3m", 0.10, True),
        ])

    def transition_core(stock):
        return blend(stock, [
            ("from_52w_high_pct", 0.24, True),
            ("from_200d_ma_pct", 0.14, True),
            ("return_1m_pct", 0.16, False),
            ("return_3m_pct", 0.16, False),
            ("operating_margin_pct", 0.10, False),
            ("free_cash_flow_margin_pct", 0.10, False),
            ("operating_income_growth_pct", 0.10, False),
        ])

    def momentum_core(stock):
        return blend(stock, [
            ("momentum_12_1_pct", 0.30, False),
            ("return_6m_pct", 0.22, False),
            ("return_3m_pct", 0.14, False),
            ("return_1m_pct", 0.08, False),
            ("from_200d_ma_pct", 0.10, False),
            ("realized_vol_3m", 0.08, True),
            ("forward_pe", 0.08, True),
        ])

    def quality_core(stock):
        return blend(stock, [
            ("operating_margin_pct", 0.28, False),
            ("free_cash_flow_margin_pct", 0.24, False),
            ("forward_eps", 0.14, False),
            ("free_cash_flow_growth_pct", 0.16, False),
            ("operating_income_growth_pct", 0.10, False),
            ("peg", 0.08, True),
        ])

    def defensive_core(stock):
        return blend(stock, [
            ("realized_vol_3m", 0.28, True),
            ("operating_margin_pct", 0.20, False),
            ("free_cash_flow_margin_pct", 0.18, False),
            ("dividend_yield_ttm_pct", 0.10, False),
            ("forward_pe", 0.10, True),
            ("peg", 0.06, True),
            ("return_3m_pct", 0.08, False),
        ])

    metric_names = [
        "return_1m_pct",
        "return_3m_pct",
        "return_6m_pct",
        "momentum_12_1_pct",
        "from_200d_ma_pct",
        "from_52w_high_pct",
        "realized_vol_3m",
        "avg_daily_volume_3m",
        "avg_daily_dollar_volume_3m",
        "trading_days_3m",
        "dividend_yield_ttm_pct",
        "forward_pe",
        "peg",
        "operating_income_growth_pct",
        "free_cash_flow_growth_pct",
        "forward_eps",
        "operating_margin_pct",
        "free_cash_flow_margin_pct",
        "market_cap",
    ]
    rank_maps = percentile_maps(metric_names)

    market_trend = regime_value("market_trend", regime_value("trend", 0.0))
    risk_on = regime_value("risk_on", 0.5)
    drawdown = regime_value("drawdown", regime_value("market_drawdown", 0.0))
    vol_regime = regime_value("volatility", regime_value("market_volatility", 0.5))

    if drawdown <= -0.10 or (risk_on < 0.42 and vol_regime > 0.58):
        branch = 0  # defensive compounder
    elif market_trend > 0.18 and risk_on > 0.55 and vol_regime < 0.62:
        branch = 1  # trend graduation
    elif market_trend < -0.08 or (vol_regime > 0.70 and risk_on < 0.52):
        branch = 2  # panic repair
    else:
        branch = 3  # skeptical transition

    scores = {}
    for stock in stocks:
        symbol = stock.get("symbol")
        if not symbol:
            continue

        liq = liquidity_gate(stock)
        rec = recovery_core(stock)
        trans = transition_core(stock)
        mom = momentum_core(stock)
        qual = quality_core(stock)
        defense = defensive_core(stock)

        deep_drawdown = pct(stock, "from_52w_high_pct", True)
        if deep_drawdown is None:
            deep_drawdown = 0.5
        short_repair = pct(stock, "return_1m_pct", False)
        if short_repair is None:
            short_repair = 0.5
        medium_repair = pct(stock, "return_3m_pct", False)
        if medium_repair is None:
            medium_repair = 0.5
        six_m = pct(stock, "return_6m_pct", False)
        if six_m is None:
            six_m = 0.5
        below_200 = pct(stock, "from_200d_ma_pct", True)
        if below_200 is None:
            below_200 = 0.5
        low_vol = pct(stock, "realized_vol_3m", True)
        if low_vol is None:
            low_vol = 0.5
        cheapish = pct(stock, "forward_pe", True)
        if cheapish is None:
            cheapish = 0.5
        size = pct(stock, "market_cap", False)
        if size is None:
            size = 0.5

        repair_valid = 0.0
        if short_repair > 0.55:
            repair_valid += 0.5
        if medium_repair > 0.52:
            repair_valid += 0.3
        if qual > 0.52:
            repair_valid += 0.2

        trend_clean = 0.0
        if mom > 0.58:
            trend_clean += 0.45
        if low_vol > 0.50:
            trend_clean += 0.20
        if qual > 0.50:
            trend_clean += 0.20
        if liq > 0.45:
            trend_clean += 0.15

        conflict_gap = mom - rec
        conflict_penalty = 0.0
        if conflict_gap > 0.22 and deep_drawdown > 0.72 and short_repair < 0.45:
            conflict_penalty += 0.10
        if conflict_gap < -0.22 and qual < 0.42:
            conflict_penalty += 0.10
        if liq < 0.22:
            conflict_penalty += 0.18

        if branch == 0:
            base = 0.42 * defense + 0.22 * qual + 0.14 * mom + 0.12 * rec + 0.06 * cheapish + 0.04 * size
            if deep_drawdown > 0.78 and repair_valid < 0.55:
                base -= 0.10
            if low_vol > 0.70 and qual > 0.60:
                base += 0.05
        elif branch == 1:
            repaired_leader_bonus = 0.0
            if deep_drawdown > 0.60 and repair_valid > 0.68 and trend_clean > 0.58:
                repaired_leader_bonus = 0.08
            if deep_drawdown < 0.35 and below_200 < 0.35:
                repaired_leader_bonus -= 0.03
            base = 0.38 * mom + 0.24 * qual + 0.18 * trans + 0.10 * rec + 0.05 * low_vol + 0.05 * cheapish + repaired_leader_bonus
            if short_repair < 0.35 and medium_repair < 0.45 and deep_drawdown > 0.70:
                base -= 0.10
        elif branch == 2:
            bounce_cap = 1.0
            if qual < 0.40:
                bounce_cap = 0.88
            if liq < 0.30:
                bounce_cap = 0.82 if bounce_cap > 0.82 else bounce_cap
            base = (0.38 * rec + 0.24 * qual + 0.14 * trans + 0.08 * defense + 0.08 * cheapish + 0.08 * low_vol) * bounce_cap
            if deep_drawdown > 0.80 and repair_valid > 0.70:
                base += 0.07
            if short_repair < 0.30:
                base -= 0.08
        else:
            recovery_vs_trend = rec - mom
            bridge_bonus = 0.0
            if recovery_vs_trend > 0.08 and qual > 0.56:
                bridge_bonus += 0.05
            if recovery_vs_trend < -0.08 and cheapish < 0.35 and qual < 0.50:
                bridge_bonus -= 0.04
            base = 0.30 * trans + 0.26 * qual + 0.18 * rec + 0.14 * mom + 0.06 * cheapish + 0.06 * defense + bridge_bonus
            if deep_drawdown > 0.76 and repair_valid < 0.50:
                base -= 0.08

        score = base - conflict_penalty
        score += 0.05 * liq

        # Small penalty for excessively large, already-crowded names in contrarian sleeves.
        if branch in (2, 3) and size > 0.85 and deep_drawdown < 0.45:
            score -= 0.03

        scores[symbol] = score

    return scores