140 lines
6.3 KiB
Python
140 lines
6.3 KiB
Python
"""
|
|
Phase 4 of the Strategy Builder Greeks plan (see project memory) — Mode 1 ("scenario only")
|
|
and the contradiction-detection layer from the user's spec, section 12.
|
|
|
|
`infer_natural_greek_profile` answers "what Greek behavior does this scenario already imply,
|
|
before the user sets any explicit target?" — a deterministic, rule-based reading of the
|
|
spec's own lookup tables (2.1 spot / 2.2 IV), NOT a fitted or learned model. Thresholds are
|
|
judgment calls, documented inline, meant as a starting suggestion the Phase 2 profile panel
|
|
can be pre-filled with and the user can freely override — not an authoritative answer.
|
|
|
|
`detect_greek_contradictions` answers "did the user just ask for something that's hard to
|
|
get on a single option structure?" — static checks on the requested profile alone (no need
|
|
to run the optimizer), returned as non-blocking warnings, never filtering the request.
|
|
"""
|
|
from typing import Any, Dict, List, Optional
|
|
|
|
_POSITIVE_STATES = {"positive", "strong_positive"}
|
|
_STRONG_STATES = {"strong_positive", "strong_negative"}
|
|
|
|
|
|
def infer_natural_greek_profile(spot_shock_pct: float, iv_level_shift: float, horizon_days: int) -> Dict[str, Any]:
|
|
horizon_days = max(horizon_days, 1)
|
|
speed = abs(spot_shock_pct) / horizon_days # %/day intensity of the anticipated move
|
|
|
|
if abs(spot_shock_pct) < 1.0:
|
|
spot_dir = "stable"
|
|
elif spot_shock_pct > 0:
|
|
spot_dir = "hausse"
|
|
else:
|
|
spot_dir = "baisse"
|
|
|
|
# Thresholds are a judgment call, not calibrated against real move distributions —
|
|
# ~0.8%/day is "a few percent in a few days" (fast), ~0.15%/day is "a percent or two
|
|
# over a couple weeks" (progressive), below that reads as effectively directionless drift.
|
|
if speed >= 0.8:
|
|
spot_speed = "rapide"
|
|
elif speed >= 0.15:
|
|
spot_speed = "moderee"
|
|
else:
|
|
spot_speed = "lente"
|
|
|
|
if iv_level_shift >= 0.05:
|
|
iv_bucket = "forte_hausse"
|
|
elif iv_level_shift >= 0.02:
|
|
iv_bucket = "hausse_moderee"
|
|
elif iv_level_shift <= -0.02:
|
|
iv_bucket = "baisse"
|
|
else:
|
|
iv_bucket = "faible"
|
|
|
|
delta = gamma = theta = "free"
|
|
rationale: List[str] = []
|
|
|
|
# Spot -> delta/gamma/theta, spec section 2.1's table
|
|
if spot_dir == "stable":
|
|
delta, theta = "neutral", "positive"
|
|
rationale.append("Spot quasi stable → Delta proche de zéro, Theta plutôt positif (collecte de temps).")
|
|
elif spot_dir == "hausse" and spot_speed == "rapide":
|
|
delta, gamma = "strong_positive", "positive"
|
|
rationale.append("Hausse forte et rapide → Delta et Gamma positifs, la vitesse du mouvement compte autant que le niveau.")
|
|
elif spot_dir == "hausse":
|
|
delta = "positive"
|
|
theta = "positive" if spot_speed == "lente" else "neutral"
|
|
rationale.append("Hausse modérée/progressive → Delta positif, Theta plutôt positif si le mouvement reste lent.")
|
|
elif spot_dir == "baisse" and spot_speed == "rapide":
|
|
delta, gamma = "strong_negative", "positive"
|
|
rationale.append("Baisse forte et rapide → Delta négatif et Gamma positif, la vitesse compte plus que le niveau.")
|
|
else: # baisse, lente/modérée
|
|
delta = "negative"
|
|
theta = "positive" if spot_speed == "lente" else "neutral"
|
|
rationale.append("Baisse modérée ou stagnation baissière → Delta négatif faible, Theta plutôt positif.")
|
|
|
|
# IV -> vega, spec section 2.2's table — can nuance the theta read above when IV dominates
|
|
if iv_bucket == "forte_hausse":
|
|
vega = "strong_positive"
|
|
rationale.append("Forte hausse d'IV anticipée → Vega positif, idéalement avec de la convexité de vol (Vomma).")
|
|
elif iv_bucket == "hausse_moderee":
|
|
vega = "positive"
|
|
rationale.append("Hausse modérée d'IV → Vega positif, sans excès.")
|
|
elif iv_bucket == "baisse":
|
|
vega = "negative"
|
|
if theta == "free":
|
|
theta = "positive"
|
|
rationale.append("Baisse d'IV attendue (normalisation) → Vega négatif, Theta plutôt positif.")
|
|
else:
|
|
vega = "free"
|
|
|
|
return {
|
|
"delta": delta, "gamma": gamma, "theta": theta, "vega": vega, "rho": "free",
|
|
"rationale": rationale,
|
|
"reading": {"spot_direction": spot_dir, "spot_speed": spot_speed, "iv_bucket": iv_bucket},
|
|
}
|
|
|
|
|
|
def detect_greek_contradictions(
|
|
greek_profile: Optional[Dict[str, Any]], n_expiries: int,
|
|
dte_min: Optional[int], dte_max: Optional[int],
|
|
) -> List[str]:
|
|
if not greek_profile:
|
|
return []
|
|
|
|
def state_of(key: str) -> str:
|
|
return (greek_profile.get(key) or {}).get("state", "free")
|
|
|
|
def weight_of(key: str) -> float:
|
|
return (greek_profile.get(key) or {}).get("weight", 50.0)
|
|
|
|
single_expiry = (n_expiries or 1) <= 1 or (
|
|
dte_min is not None and dte_max is not None and dte_max - dte_min <= 5
|
|
)
|
|
|
|
warnings: List[str] = []
|
|
gamma_state, theta_state, delta_state, vega_state = (
|
|
state_of("gamma"), state_of("theta"), state_of("delta"), state_of("vega"),
|
|
)
|
|
|
|
if (gamma_state in _POSITIVE_STATES and theta_state in _POSITIVE_STATES
|
|
and weight_of("gamma") >= 30 and weight_of("theta") >= 30 and single_expiry):
|
|
warnings.append(
|
|
"Gamma positif et Theta positif en même temps sont difficiles à obtenir sur une seule "
|
|
"échéance. Solutions : élargir la fenêtre DTE (calendars/diagonales), réduire l'exigence "
|
|
"sur l'un des deux, ou n'exiger un Theta positif qu'autour du scénario central."
|
|
)
|
|
|
|
if delta_state == "neutral" and gamma_state in _STRONG_STATES and weight_of("delta") >= 30 and weight_of("gamma") >= 30:
|
|
warnings.append(
|
|
"Delta neutre et Gamma fortement positif se contredisent dans la durée : un Gamma élevé "
|
|
"fait bouger le Delta dès que le marché évolue — il ne restera « neutre » qu'au voisinage "
|
|
"immédiat du scénario central."
|
|
)
|
|
|
|
if vega_state == "strong_positive" and theta_state == "strong_positive" and weight_of("vega") >= 30 and weight_of("theta") >= 30:
|
|
warnings.append(
|
|
"Vega fortement positif et Theta fortement positif combinent rarement bien : la convexité "
|
|
"de volatilité coûte généralement du portage — vérifiez que le crédit net visé reste "
|
|
"cohérent avec cet objectif."
|
|
)
|
|
|
|
return warnings
|