"""r0823b_fisco_payout — §63 FISCO-PAYOUT: l'aliquota sui payout funded e' un FORFAIT mai giustificato, e il canale funded non e' mai stato misurato contro di essa (2026-08-23). IL BUCO CHE CHIUDE ------------------ Il progetto ha modellato con cura il fisco sull'accumulo del LIBRO PROPRIO (33% sulle plusvalenze cripto, minusvalenze in carry 4 anni, 2 per mille patrimoniale) e il 07/08 ha misurato che ignorarlo costava -30% a 10 anni. Sul canale FUNDED non ha modellato niente: `r0725_prop_ladder.py` importa `TAX_RATE = 0.33` da `r0725_capcurve` e lo applica ai payout con una riga net = gross * (1.0 - TAX_RATE) # r0725_prop_ladder:269 senza una giustificazione. Ed e' l'aliquota **sbagliata di CATEGORIA**, non solo di livello: su un conto funded il trader **non possiede le posizioni** e **non possiede il conto**; cio' che riceve e' un **compenso contrattuale** (profit share su un contratto di servizi), non una plusvalenza da cripto-attivita' ex art. 67 c.1 lett. c-sexies TUIR. Il 33% e' l'aliquota di una cosa che qui non succede. Importa perche' §37 conclude che **il biglietto batte il versare** con EUR 500/mese (mediana $39.820 contro $22.444). Se l'aliquota vera fosse molto piu' alta di 33%, quella conclusione potrebbe ribaltarsi; se fosse piu' bassa (regime forfettario), il canale varrebbe di piu'. QUESTO FILONE NON CONCLUDE QUALE SIA L'ALIQUOTA. Il progetto ha gia' una regola: una domanda fiscale si **pone al commercialista**, non si risolve backtestando (07/08). Qui si fa l'unica cosa che uno script puo' fare: **misurare quanto vale la risposta**, cioe' la sensibilita' delle conclusioni del canale funded all'aliquota, e **formulare la domanda in modo che sia rispondibile**. NON e' un parere fiscale. LE ATTESE, REGISTRATE PRIMA DI MISURARE --------------------------------------- A1. **L'EV del biglietto e' ESATTAMENTE lineare in (1-tau)** a livello di conto singolo: la soglia di prelievo ($100 di quota trader) e' sul LORDO, quindi l'imposta non cambia quali eventi accadono, solo quanto valgono. Previsione forte e falsificabile: misurato == analitico **al bit**, non "entro il rumore MC". A2. **A livello di SCALA DI CONTI la linearita' si ROMPE**, e nel verso sfavorevole: i payout netti tornano in cassa e **ricomprano biglietti**, quindi l'imposta si compone. Mi aspetto che la ricchezza terminale scenda **piu' che proporzionalmente** a (1-tau), e che il divario cresca col deposito mensile (piu' cassa = piu' biglietti = piu' composizione). A3. **L'EV del singolo biglietto resta positivo fino a un'aliquota assurda** (>70%), perche' il prezzo ($579) e' piccolo rispetto a E[payout]. Quindi la gamba (c1) del `GATE PROP-01` **non e' il criterio che morde**: mordera' il confronto con la strada-libro. A4. **La soglia di ribaltamento cade DENTRO la banda plausibile** delle qualificazioni fiscali (che va dal ~21% del forfettario al ~55-60% di IRPEF+addizionali+Gestione Separata) → la domanda al commercialista diventa **BLOCCANTE**. Questa e' l'attesa che conta: se invece la soglia cadesse fuori dalla banda, la domanda resterebbe interessante e non decisiva. A5. **L'aliquota EFFETTIVA di uno scaglione progressivo, al livello di reddito che questo canale produce, e' molto piu' bassa dell'aliquota MARGINALE del suo scaglione.** EUR 50/giorno sono ~EUR 18.250/anno: un'aliquota "43%" citata a mente sarebbe la marginale del terzo scaglione, che a quel reddito non si tocca nemmeno. Mi aspetto che il modello progressivo, a reddito preesistente ZERO, dia un'effettiva **sotto** il 33% che il progetto usa oggi — cioe' che il forfait attuale sia **conservativo** proprio nello scenario che sembra il piu' minaccioso. Ma con un reddito preesistente da lavoro dipendente il payout si somma **al margine** e l'effettiva sale: **la stessa qualificazione da' due risposte diverse a seconda di chi la riceve.** Questo, se confermato, e' il risultato trasferibile del filone. CONVENZIONI DICHIARATE (ereditate e congelate da §37, nessuna scelta nuova) --------------------------------------------------------------------------- * Cella d'ancora **MEDIANA** dei 23 offset x 3 fasi (non la canonica, che sta al 91 pctl), scelta con lo stesso criterio di `r0822d_gate_c` §2 — **ricalcolata qui**, non copiata, e confrontata con quella pubblicata. * Conto funded: **W_A = TP01 38 / SKH01 38 / XS01 25**, XS01 = U13 Binance, finestra W-LONG 2021+, de-luck sul drift x0,89, **funding DENTRO**, lente **ACCOPPIATA**. * Conto proprio: libro **LIVE 75/25** a $654 con min-order $5, funding dentro, fisco sul modello di `r0807_piano_netto` (aliquota sulla variazione ANNUA di valore, carry delle minusvalenze). * Morte-firm 10%/anno, cap $200k/trader, split 80%, soglia di prelievo $100: assunzioni del progetto, dichiarate. * Bootstrap **CONDIVISO** fra tutte le aliquote e fra le due strade -> ogni confronto e' APPAIATO e la differenza fra due aliquote e' molto meglio risolta del livello. Uso: `nice -n 19 timeout 900 uv run python scripts/research/r0823b_fisco_payout.py` Rete: NESSUNA. Scritture: NESSUNA. """ from __future__ import annotations import sys import time from pathlib import Path import numpy as np import pandas as pd T0 = time.time() ROOT = Path(__file__).resolve().parents[2] for _p in (ROOT, ROOT / "scripts" / "research", ROOT / "scripts" / "research" / "alt"): sys.path.insert(0, str(_p)) if "--no-net" not in sys.argv: sys.argv.append("--no-net") import r0725_prop_coupled as pc # noqa: E402 lente accoppiata import r0725_prop_ladder as pl # noqa: E402 regole firm import r0822_prop_alloc as PA # noqa: E402 boot_idx, DELUCK import r0822b_prop_recal as PR # noqa: E402 pannelli, obj_rg import r0822b_xs01_oos as X # noqa: E402 U13 import r0822c_skh_anchor_prop as AP # noqa: E402 offset di SKH01 import r0822d_funding as FD # noqa: E402 funding import r0822d_gate_c as GC # noqa: E402 LA MACCHINERIA DI §37 from src.portfolio.sleeves import XS_UNIVERSE # noqa: E402 FD.USE_NET = False EURUSD = pl.EURUSD SPLIT = pl.SPLIT DELUCK = PA.DELUCK W_A = GC.W_A W_LIVE = GC.W_LIVE OFFSETS = AP.OFFSETS PHASES_SUB = AP.PHASES_SUB N_LAD = GC.N_PATHS_LAD N_TIX = GC.N_PATHS_TIX SEED_LAD = GC.SEED_LAD MIN_PAYOUT = GC.MIN_PAYOUT_TRADER HORIZON_DAYS = GC.HORIZON_DAYS PRICE_100K = 579.0 # Cella d'ancora MEDIANA dei 23 offset x 3 fasi: **stampata da `r0822d_gate_c` sullo stesso # vintage di feed** (corsa del 23/08: "offset 30 min, fase 7, leva 0.75x"). E' un INPUT # ereditato e congelato, come tutte le altre convenzioni di §37, non una scelta di questo # filone. Ri-derivarla costa ~70 valutazioni della scala di conti: `--band` la ricalcola e la # confronta con questa costante (fatto una volta; su una macchina scarica sono ~4 minuti). CELL_M = (30, 7, 0.75) BAND = "--band" in sys.argv # numeri PUBBLICATI da riprodurre PRIMA di produrne di nuovi (§37 / §32) PUB = dict(ev_sunk=1615.0, ev_at_pass=1919.0, ev_at_payout=1835.0, p50g_fund=0.026, pzero_fund=0.403, med_big_500=39820.0, med_lib_500=22444.0, med_big_0=132.0, med_lib_0=787.0, mean_big_500=46298.0, mean_lib_500=22694.0, mean_big_0=9592.0, mean_lib_0=803.0) # =============================================================================== 0. IL FISCO # ATTENZIONE — QUESTA SEZIONE NON E' UN PARERE FISCALE. # Ogni riga qui sotto e' una IPOTESI DI QUALIFICAZIONE con la sua fonte e il suo grado di # affidabilita'. Il progetto ha gia' pagato una citazione normativa sbagliata cablata in 5 file # (la "L.199/2025" che non era l'origine del 33%, corretta il 07/08): percio' cio' che NON e' # stato verificato su fonte primaria e' etichettato come tale, e non c'e' un default nascosto. # # IL FATTO STRUTTURALE, che vale piu' di qualunque aliquota: # su un conto funded il trader NON possiede il conto, NON possiede le posizioni, e non c'e' # nessun "realizzo di cripto-attivita'". Riceve una quota di un risultato SIMULATO in base a un # contratto. Percio' l'art. 67 c.1 lett. c-sexies (33%, cripto) e la lett. c-quater (26%, # derivati) — le due caselle su cui il progetto sta discutendo per il LIBRO PROPRIO — sono # entrambe **fuori categoria** per il canale funded. La discussione vera e' fra reddito # diverso da "obbligazione di fare" (art. 67 c.1 lett. l), lavoro autonomo (abituale o # occasionale) e reddito d'impresa. Cambia la CATEGORIA, non solo il numero. # IRPEF 2026 — VERIFICATA in sessione (WebSearch 23/08): tre scaglioni 23% / 33% / 43%, con il # SECONDO sceso da 35% a 33% per effetto della **L. 199/2025** (Legge di Bilancio 2026). # ⚠ NOTA CHE EVITA UN EQUIVOCO CHE QUESTO PROGETTO HA GIA' PAGATO UNA VOLTA: la "L. 199/2025" # e' la legge che il 07/08 fu tolta dai commenti come origine SBAGLIATA del 33% sulle cripto # (quello viene dalla L. 207/2024 art. 1 c. 23-29). Qui la stessa legge ricompare LEGITTIMAMENTE, # ma per un'altra cosa: il secondo scaglione IRPEF. **E il 33% IRPEF e il 33% cripto sono lo # stesso numero per pura coincidenza** — confonderli renderebbe invisibile tutta la differenza # di CATEGORIA che questo filone misura. Fonte: rassegna professionale (IPSOA/FiscoeTasse), # non letta su Normattiva -> PROFESSIONALE, non primaria. IRPEF_SCAGLIONI = ((28_000.0, 0.23), (50_000.0, 0.33), (float("inf"), 0.43)) IRPEF_2025 = ((28_000.0, 0.23), (50_000.0, 0.35), (float("inf"), 0.43)) # controllo di robustezza ADDIZIONALI = 0.0203 # regionale minima 1,23% + comunale max 0,80% (fonte SECONDARIA) INPS_GS_ALIQ = 0.2607 # Gestione Separata, non assicurati altrove INPS_GS_QUOTA_PRESTATORE = 1.0 / 3.0 INPS_OCC_FRANCHIGIA = 5_000.0 FORFETTARIO_COEFF = 0.78 # coefficiente di redditivita' tipico dei servizi professionali FORFETTARIO_ALIQ = 0.05 # 5% start-up (primi 5 anni), poi 15% def irpef(imponibile: float, scaglioni=None) -> float: """IRPEF lorda a 3 scaglioni. Nessuna detrazione (conservativo: le detrazioni la abbassano).""" t, prev = 0.0, 0.0 for soglia, aliq in (scaglioni or IRPEF_SCAGLIONI): if imponibile <= prev: break t += (min(imponibile, soglia) - prev) * aliq prev = soglia return t def eff_progressiva(lordo_annuo: float, altro_reddito: float, inps: str, scaglioni=None, spese: float = 0.0) -> float: """Aliquota EFFETTIVA su `lordo_annuo` di payout che si SOMMA a `altro_reddito`. `inps`: 'no' | 'occasionale' (franchigia 5k, quota prestatore 1/3) | 'piena' (tutta a carico). Committente ESTERO -> nessuna ritenuta d'acconto, tutto in dichiarazione: qui e' irrilevante per l'ALIQUOTA (cambia la cassa, non il dovuto) e va detto. Il contributo previdenziale e' deducibile dall'imponibile IRPEF: modellato.""" if lordo_annuo <= 0: return 0.0 # art. 71 c.2 TUIR (verificato sul testo, 23/08): i redditi di cui all'art. 67 c.1 lett. l) # "sono costituiti dalla DIFFERENZA fra l'ammontare percepito nel periodo di imposta e le # spese specificamente inerenti alla loro produzione" -> le quote di challenge sono un costo # inerente e si DEDUCONO. Sotto un'imposta sostitutiva su reddito finanziario, no. netto = max(0.0, lordo_annuo - spese) if inps == "no": contrib = 0.0 elif inps == "occasionale": base = max(0.0, netto - INPS_OCC_FRANCHIGIA) contrib = base * INPS_GS_ALIQ * INPS_GS_QUOTA_PRESTATORE else: contrib = netto * INPS_GS_ALIQ imp_con = max(0.0, altro_reddito + netto - contrib) imp_senza = max(0.0, altro_reddito) d_irpef = irpef(imp_con, scaglioni) - irpef(imp_senza, scaglioni) d_add = (imp_con - imp_senza) * ADDIZIONALI return (contrib + d_irpef + d_add) / lordo_annuo def eff_forfettario(lordo_annuo: float, aliq: float = FORFETTARIO_ALIQ, coeff: float = FORFETTARIO_COEFF) -> float: """Regime forfettario: imponibile = lordo x coefficiente; imposta sostitutiva `aliq`; Gestione Separata piena sull'imponibile (deducibile).""" if lordo_annuo <= 0: return 0.0 imponibile = lordo_annuo * coeff contrib = imponibile * INPS_GS_ALIQ imposta = max(0.0, imponibile - contrib) * aliq return (contrib + imposta) / lordo_annuo # ==================================================== 1. LA SCALA DI CONTI CON L'IMPOSTA APERTA def ladder_tax(R: np.ndarray, G: np.ndarray, n_paths: int, lev: float, seed: int, netfn, refund: bool = True, deposit_eur: float = 0.0, start_eur: float = pl.START_EUR, min_payout: float = MIN_PAYOUT, boot: np.ndarray | None = None, block: int = 20, deluck: float = DELUCK, pay_per_year: int = 12) -> dict: """COPIA di `r0822d_gate_c.ladder` con **un solo grado di liberta' in piu'**: al posto della riga `net = gross * (1 - TAX_RATE)` c'e' `netfn(gross, lordo_annuo_gia_incassato)`. Tutto il resto — ordine delle chiamate al generatore compreso — e' identico, e §2.1 lo verifica **bit-exact** contro l'originale con `netfn` piatta al 33%. `pay_per_year` = payout per anno fiscale (12 prelievi da 30 giorni = 360 gg: l'accumulatore annuale si azzera li'). Serve solo alle aliquote PROGRESSIVE, che dipendono dal lordo annuo. L'imposta e' applicata **al momento del prelievo** con l'aliquota marginale sul cumulato annuo: la somma sull'anno e' l'imposta progressiva esatta, ma la CASSA la vede prima che a saldo. Differenza dichiarata, e conservativa (toglie liquidita' prima).""" rng = np.random.default_rng(seed) n_days = HORIZON_DAYS L = len(R) Rm = R.astype(float).reshape(-1, 1).copy() Gm = G.astype(float).reshape(-1, 1).copy() Rm = Rm - (1.0 - deluck) * Rm.mean(axis=0, keepdims=True) if boot is None: n_blocks = int(np.ceil(n_days / block)) starts = rng.integers(0, L - block, size=(n_paths, n_blocks)) idx = (starts[:, :, None] + np.arange(block)[None, None, :]).reshape(n_paths, -1)[:, :n_days] else: idx = boot n_slot = pl.MAX_CONCURRENT sel = np.zeros(n_slot, dtype=int) Rs = Rm[idx][:, :, sel] * lev G_ = Gm[idx][:, :, sel] * lev FIRMS = pl.FIRMS cash = np.full(n_paths, start_eur * EURUSD) phase = np.full((n_paths, n_slot), -1, np.int8) eq = np.ones((n_paths, n_slot)) firm = np.full((n_paths, n_slot), -1, np.int8) notional = np.zeros((n_paths, n_slot)) price_paid = np.zeros((n_paths, n_slot)) refunded = np.zeros((n_paths, n_slot), bool) firm_alive = np.ones((n_paths, len(FIRMS)), bool) cum_payout = np.zeros(n_paths) cum_gross = np.zeros(n_paths) ann_gross = np.zeros(n_paths) spent_base = np.zeros(n_paths) spent = np.zeros(n_paths) got_back = np.zeros(n_paths) deposited = np.zeros(n_paths) n_payouts = np.zeros(n_paths, int) n_pay_events = 0 p_death_day = 1.0 - (1.0 - pl.FIRM_DEATH_PER_YEAR) ** (1 / 365.0) for t in range(n_days): died = rng.random((n_paths, len(FIRMS))) < p_death_day newly_dead = died & firm_alive firm_alive &= ~died if newly_dead.any(): for fi in range(len(FIRMS)): kill = newly_dead[:, fi] if kill.any(): hit = (firm == fi) & kill[:, None] phase[hit] = -1 notional[hit] = 0.0 for k in range(n_slot): free = phase[:, k] == -1 if not free.any(): continue for fi, F in enumerate(FIRMS): used = np.where(firm == fi, notional, 0.0).sum(axis=1) for (size, price) in sorted(F["tickets"], key=lambda x: -x[0]): buy = (free & firm_alive[:, fi] & (cash >= price) & (used + size <= F["cap"])) if not buy.any(): continue cash[buy] -= price spent[buy] += price phase[buy, k] = 0 eq[buy, k] = 1.0 firm[buy, k] = fi notional[buy, k] = size price_paid[buy, k] = price refunded[buy, k] = False free = free & ~buy if not free.any(): break if not free.any(): break r = Rs[:, t, :] g = G_[:, t, :] act = phase >= 0 eq_prev = eq eq = np.where(act, eq * (1.0 + r), eq) eq_low = np.where(act, eq_prev * (1.0 + r + g), eq) r_low = r + g for fi, F in enumerate(FIRMS): s_ = act & (firm == fi) if not s_.any(): continue ev_t, ev_dd, ev_dl = F["ev"] fu_ml, fu_dl = F["fu"] in_ev = s_ & (phase == 0) in_fu = s_ & (phase == 1) bust = ((in_ev & ((eq_low < 1.0 - ev_dd) | (r_low < -ev_dl))) | (in_fu & ((eq_low < 1.0 - fu_ml) | (r_low < -fu_dl)))) phase[bust] = -1 notional[bust] = 0.0 passed = in_ev & (eq >= 1.0 + ev_t) & ~bust phase[passed] = 1 eq[passed] = 1.0 if (t + 1) % 30 == 0: fu = phase == 1 pay = fu & (eq > 1.0) & (((eq - 1.0) * notional * SPLIT) >= min_payout) gain = np.where(pay, (eq - 1.0) * notional, 0.0) gross = gain.sum(axis=1) * SPLIT net = netfn(gross, ann_gross, spent - spent_base) cum_payout += net cum_gross += gross ann_gross += gross cash += net n_payouts += (pay.sum(axis=1) > 0).astype(int) eq = np.where(pay, 1.0, eq) if refund: back = pay & ~refunded amt = np.where(back, price_paid, 0.0).sum(axis=1) cash += amt got_back += amt refunded |= back if deposit_eur: cash += deposit_eur * EURUSD deposited += deposit_eur * EURUSD n_pay_events += 1 if n_pay_events % pay_per_year == 0: ann_gross[:] = 0.0 spent_base = spent.copy() eur_day = cum_payout / EURUSD / (n_days / 365.0) / 365.0 return dict(eur_day=eur_day, med=float(np.median(eur_day)), p_ge10=float((eur_day >= 10.0).mean()), p_target=float((eur_day >= pl.TARGET_EUR_DAY).mean()), p_zero=float((cum_payout <= 0).mean()), cash=cash, med_cash=float(np.median(cash)), mean_cash=float(cash.mean()), p10_cash=float(np.percentile(cash, 10)), p90_cash=float(np.percentile(cash, 90)), gross=float(cum_gross.mean()), net=float(cum_payout.mean()), spent=float(spent.mean()), excess=cash - (start_eur * EURUSD + deposited), mean_back=float(got_back.mean()), med_spent=float(np.median(spent)), contributed=float(start_eur * EURUSD + deposited.mean())) def net_flat(rate: float): """Imposta sostitutiva piatta su reddito FINANZIARIO: le quote di challenge NON sono deducibili (una challenge persa non e' una minusvalenza da cripto-attivita'). Espressione IDENTICA a quella di `GC.ladder` -> bit-exact.""" def f(gross, ann, spese): return gross * (1.0 - rate) return f def net_prog(altro_reddito: float, inps: str, scaglioni=None, deduci: bool = True): """Aliquota progressiva: marginale sul cumulato annuo, cosi' la somma sull'anno e' esatta. `deduci` = le quote di challigne dell'anno si sottraggono dalla base (art. 71 c.2 TUIR).""" def f(gross, ann, spese): out = np.zeros_like(gross) nz = gross > 0 if nz.any(): sp = np.asarray(spese, float) / EURUSD if deduci else np.zeros(len(gross)) for i in np.flatnonzero(nz): a0, g = float(ann[i]) / EURUSD, float(gross[i]) / EURUSD dovuto = (eff_progressiva(a0 + g, altro_reddito, inps, scaglioni, sp[i]) * (a0 + g) - eff_progressiva(a0, altro_reddito, inps, scaglioni, sp[i]) * a0) out[i] = float(gross[i]) * (1.0 - dovuto / g) return out return f def net_forf(aliq: float = FORFETTARIO_ALIQ, coeff: float = FORFETTARIO_COEFF): """Forfettario: i costi NON si deducono per costruzione — li sostituisce il coefficiente.""" def f(gross, ann, spese): out = np.zeros_like(gross) nz = gross > 0 if nz.any(): for i in np.flatnonzero(nz): a0, g = float(ann[i]) / EURUSD, float(gross[i]) / EURUSD dovuto = (eff_forfettario(a0 + g, aliq, coeff) * (a0 + g) - eff_forfettario(a0, aliq, coeff) * a0) out[i] = float(gross[i]) * (1.0 - dovuto / g) return out return f # ================================================================= 2. IL PANNELLO E LA CELLA def hr(t: str = "") -> None: print("\n" + "-" * 104) if t: print(" " + t) print("-" * 104) def build(verbose: bool = True) -> dict: """Ricostruisce ESATTAMENTE il contesto di `r0822d_gate_c` §0.2 + §2, cella d'ancora MEDIANA compresa. Non e' copiata dal diario: e' ricalcolata e poi confrontata.""" Cb, Ob, Hb, Lb = PR.ohlc_panels(PR.bin_loader, XS_UNIVERSE) p13 = Cb[X.U13].dropna() o13 = Ob.reindex(p13.index)[X.U13] h13 = Hb.reindex(p13.index)[X.U13] l13 = Lb.reindex(p13.index)[X.U13] XSP = {ph: PR.xs_tuples(p13, o13, h13, l13, phase=ph) for ph in PHASES_SUB} xs0 = XSP[PHASES_SUB[0]] cry_idx = pc.crypto_daily_tuples(1.0, 0.0).index base = cry_idx.intersection(xs0.index) first13 = xs0.index[np.flatnonzero(xs0["R"].values != 0.0)[0]] S_LONG = max(first13, pd.Timestamp("2021-01-01", tz="UTC")) I = base[base >= S_LONG] ev_b = PA.boot_idx(len(I), GC.EV_H, PA.N_PATHS, seed=GC.SEED_EV) fu_b = PA.boot_idx(len(I), GC.FU_H, PA.N_PATHS, seed=GC.SEED_FU) pc.DELUCK = DELUCK rate = GC.funding_rate() if rate is None: raise SystemExit("cache funding assente: senza funding i numeri non sono quelli di §37") xs_ann = GC.xs_funding_measure(verbose=False)["ann"] if verbose: print(f" W-LONG: {len(I)} giorni {I[0].date()} -> {I[-1].date()} | de-luck x{DELUCK}") print(f" funding di XS01 misurato: {xs_ann*100:+.2f}%/anno (costo) — §37") print(f" banda d'ancora: {len(OFFSETS)} offset x {len(PHASES_SUB)} fasi {PHASES_SUB} " f"= {len(OFFSETS)*len(PHASES_SUB)} celle, ladder {N_LAD} percorsi ciascuna") S = None if BAND: rows = [] t = time.time() for off in OFFSETS: fA = GC.fvec_for(W_A, I, rate, off, xs_ann) for ph in PHASES_SUB: R0, G0 = AP.rg_off(W_A, I, XSP[ph], off) Rx = R0 - fA j, lv, _ = GC.best_lev(Rx, G0, ev_b, fu_b) lad = GC.ladder(Rx, G0, N_LAD, lv, SEED_LAD, refund=False) rows.append(dict(off=off, ph=ph, J=j, lev=lv, p50=lad["p_target"], pz=lad["p_zero"])) S = pd.DataFrame(rows) k = int((S["p50"] - S["p50"].median()).abs().idxmin()) OFF_M, PH_M, LEV_M = int(S.loc[k, "off"]), int(S.loc[k, "ph"]), float(S.loc[k, "lev"]) if verbose: print(f" banda RI-DERIVATA ({time.time()-t:.0f}s) P(>=50/g) mediana " f"{S['p50'].median():.1%} [{np.percentile(S['p50'],10):.1%}, " f"{np.percentile(S['p50'],90):.1%}], P(zero) {S['pz'].median():.1%} " f"(PUB §37 {PUB['p50g_fund']:.1%} / {PUB['pzero_fund']:.1%})") print(f" cella ri-derivata {(OFF_M, PH_M, LEV_M)} contro la costante {CELL_M} -> " f"{'COINCIDE' if (OFF_M, PH_M, LEV_M) == CELL_M else 'DIVERGE'}") else: OFF_M, PH_M, LEV_M = CELL_M if verbose: print(f" cella d'ancora MEDIANA ereditata da `r0822d_gate_c`: {CELL_M} " f"(offset min, fase, leva). `--band` la ri-deriva dalle 69 celle.") fM = GC.fvec_for(W_A, I, rate, OFF_M, xs_ann) R_M0, G_M = AP.rg_off(W_A, I, XSP[PH_M], OFF_M) R_M = R_M0 - fM rb_full = FD.book_75_25(rate, alloc=654.0) if rb_full.index.tz is None: rb_full.index = rb_full.index.tz_localize("UTC") rb = np.nan_to_num(rb_full.reindex(I).values.astype(float)) rngb = np.random.default_rng(51224) nb = int(np.ceil(HORIZON_DAYS / 20)) st = rngb.integers(0, len(I) - 20, size=(N_LAD, nb)) BOOT = (st[:, :, None] + np.arange(20)[None, None, :]).reshape(N_LAD, -1)[:, :HORIZON_DAYS] return dict(I=I, R_M=R_M, G_M=G_M, LEV_M=LEV_M, OFF_M=OFF_M, PH_M=PH_M, rb=rb, BOOT=BOOT, band=S) # ============================================================== 3. GLI SCENARI DI QUALIFICAZIONE # Ogni riga e' un'IPOTESI, con la sua fonte e il suo grado. NESSUNA e' "la risposta". # Ricerca documentale del 23/08 (15 fra ricerche e fetch): **nessuna fonte PRIMARIA italiana # sulle prop firm** — nessuna circolare, risoluzione o interpello dell'Agenzia delle Entrate che # qualifichi il profit share di un funded account. Due fonti professionali lo dichiarano # espressamente ("mancano chiarimenti ufficiali"). Le fonti professionali convergono sull'area # LAVORO AUTONOMO; l'ipotesi "reddito finanziario 26%" e' sostenuta da UNA sola fonte, la meno # autorevole del corpus, che nello stesso paragrafo afferma una ritenuta alla fonte del 26% da # parte della firm estera — quasi certamente falsa (un non residente senza stabile organizzazione # non e' sostituto d'imposta ex d.P.R. 600/1973). def scenari() -> list[dict]: """(etichetta, funzione netta, grado della fonte). Ordinate per aliquota effettiva crescente a EUR 18.250 lordi/anno (= EUR 50/giorno, il bersaglio del progetto).""" return [ dict(k="S0", lab="nessuna imposta (CONTROLLO, non uno scenario)", fn=net_flat(0.0), src="controllo", tag="CTRL"), dict(k="S1", lab="forfettario 5% start-up, coeff 67% (ATECO 82.99)", fn=net_forf(0.05, 0.67), src="PROFESSIONALE (coeff.), ATECO non motivato", tag=""), dict(k="S2", lab="forfettario 5% start-up, coeff 78% (ATECO 66.xx/74.90.99)", fn=net_forf(0.05, 0.78), src="PROFESSIONALE (coeff.), ATECO non motivato", tag=""), dict(k="S3", lab="sostitutiva 26% — art. 67 c-quater (redditi diversi finanz.)", fn=net_flat(0.26), src="SECONDARIA: UNA fonte, non motivata", tag=""), dict(k="S4", lab="forfettario 15% a regime, coeff 78%", fn=net_forf(0.15, 0.78), src="PROFESSIONALE", tag=""), dict(k="S5", lab="lav.aut. OCCASIONALE, INPS 1/3, nessun altro reddito", fn=net_prog(0.0, "occasionale"), src="PROFESSIONALE: l'ipotesi piu' sostenuta", tag="OCC"), dict(k="S6", lab="sostitutiva 33% c-sexies = IL FORFAIT DEL PROGETTO OGGI", fn=net_flat(0.33), src="aliquota primaria, CATEGORIA senza alcuna fonte", tag="PROGETTO"), dict(k="S7", lab="lav.aut. OCCASIONALE, INPS 1/3, altro reddito EUR 30.000", fn=net_prog(30_000.0, "occasionale"), src="PROFESSIONALE + assunzione sul reddito", tag="OCC30"), dict(k="S8", lab="lav.aut. ABITUALE, IRPEF ord. + INPS PIENA, nessun altro reddito", fn=net_prog(0.0, "piena"), src="PROFESSIONALE", tag=""), dict(k="S9", lab="lav.aut. ABITUALE, IRPEF ord. + INPS PIENA, altro reddito EUR 30.000", fn=net_prog(30_000.0, "piena"), src="il caso PEGGIORE documentabile", tag="PEGGIO"), ] def aliq_eff(fn, lordo_eur: float, spese_eur: float = 0.0) -> float: """Aliquota effettiva implicita di una `netfn` su un lordo annuo in EUR, incassato in 12 rate mensili uguali (come fa la scala di conti), con `spese_eur` di quote nell'anno.""" ann = np.zeros(1) tot_net = 0.0 rata = lordo_eur * EURUSD / 12.0 sp = np.array([spese_eur * EURUSD]) for _ in range(12): g = np.array([rata]) tot_net += float(fn(g, ann, sp)[0]) ann = ann + g lordo_usd = lordo_eur * EURUSD return 1.0 - tot_net / lordo_usd if lordo_usd else 0.0 # ==================================================================================== 4. MAIN TAU_GRID = (0.00, 0.20, 0.26, 0.33, 0.45, 0.60, 0.80, 1.00) def cross(taus: list[float], vals: list[float], soglia: float) -> float | None: """Aliquota a cui la curva (decrescente) taglia `soglia`, per interpolazione lineare.""" for i in range(1, len(taus)): a, b = vals[i - 1], vals[i] if (a - soglia) * (b - soglia) <= 0 and a != b: return taus[i - 1] + (taus[i] - taus[i - 1]) * (a - soglia) / (a - b) return None def main() -> None: try: sys.stdout.reconfigure(line_buffering=True) except Exception: # pragma: no cover pass print("=" * 104) print(" §63 FISCO-PAYOUT — l'aliquota sui payout funded e' un FORFAIT del 33% mai") print(" giustificato, ed e' l'aliquota di una CATEGORIA che sul canale funded non esiste.") print(" Non si conclude quale sia: si misura QUANTO VALE LA RISPOSTA. Non e' un parere fiscale.") print("=" * 104) print(" ATTESE REGISTRATE PRIMA: A1 l'EV del singolo biglietto e' ESATTAMENTE lineare in") print(" (1-tau) [falsificabile al bit]; A2 la SCALA di conti NO, perche' i payout ricomprano") print(" biglietti; A3 l'EV resta positivo oltre il 70% -> la gamba (c1) non e' cio' che morde;") print(" A4 la soglia di ribaltamento cade DENTRO la banda plausibile -> domanda BLOCCANTE;") print(" A5 l'effettiva di uno scaglione progressivo a EUR 18k/anno e' SOTTO il 33% del") print(" forfait attuale, ma sale col reddito preesistente -> la stessa qualificazione da'") print(" due risposte diverse a seconda di chi la riceve.") hr("§0. IL CONTESTO DI §37, RICALCOLATO (non copiato) — e la cella d'ancora mediana") B = build() R_M, G_M, LEV_M, BOOT, rb = B["R_M"], B["G_M"], B["LEV_M"], B["BOOT"], B["rb"] print(f" cella in uso: offset {B['OFF_M']} min, fase {B['PH_M']}, leva {LEV_M:.2f}x") # ---------------------------------------------------------------- §1 dove entra l'imposta hr("§1. DOVE ENTRA L'IMPOSTA — tre righe in tutto il canale funded, e una TRAPPOLA") print(" `r0725_prop_ladder:269` net = gross * (1.0 - TAX_RATE)") print(" `r0725_prop_coupled:414` net = gain.sum(axis=1) * SPLIT * (1.0 - TAX_RATE)") print(" `r0822_prop_alloc:339` payout += ... * SPLIT * (1.0 - TAX_RATE)") print(f" `TAX_RATE` = {GC.TAX_RATE:.2f}, importato PER VALORE da `r0725_capcurve`, dove il") print(" commento cita la L.207/2024 — cioe' la norma sulle CRIPTO-ATTIVITA'. Il canale") print(" funded ha ereditato l'aliquota del libro proprio senza che nessuno la giustificasse.") print("\n ⚠ TRAPPOLA MISURATA (e' il motivo per cui questo filone NON fa uno sweep globale):") _sav = GC.TAX_RATE b33 = GC.book_road(rb, BOOT, pl.START_EUR, 500.0) GC.TAX_RATE = 0.99 b99 = GC.book_road(rb, BOOT, pl.START_EUR, 500.0) l99 = GC.ladder(R_M, G_M, N_LAD, LEV_M, SEED_LAD, refund=True, deposit_eur=500.0, min_payout=MIN_PAYOUT, boot=BOOT) GC.TAX_RATE = _sav print(f" `GC.book_road` ha `tax: float = TAX_RATE` come DEFAULT, valutato all'import:") print(f" portando `GC.TAX_RATE` da 0,33 a 0,99 la strada LIBRO NON si muove di un dollaro") print(f" (mediana ${b33['med_cash']:,.0f} -> ${b99['med_cash']:,.0f}) mentre la strada") print(f" BIGLIETTO crolla (mediana ${l99['med_cash']:,.0f}).") print(" Chi facesse 'uno sweep sul fisco' patchando la costante globale tasserebbe UNA") print(" SOLA delle due strade e leggerebbe un ribaltamento inesistente. Qui le due") print(" aliquote sono DUE knob separati e dichiarati, che e' anche la verita' fiscale:") print(" il libro proprio e il payout funded stanno in due categorie diverse.") # ---------------------------------------------------------------- §2 controlli hr("§2. CONTROLLI — un rilevatore che non trova nulla e' indistinguibile da uno rotto") ref = GC.ladder(R_M, G_M, N_LAD, LEV_M, SEED_LAD, refund=True, deposit_eur=500.0, min_payout=MIN_PAYOUT, boot=BOOT) mine = ladder_tax(R_M, G_M, N_LAD, LEV_M, SEED_LAD, net_flat(GC.TAX_RATE), refund=True, deposit_eur=500.0, min_payout=MIN_PAYOUT, boot=BOOT) d = float(np.abs(ref["cash"] - mine["cash"]).max()) print(f" (a) BIT-EXACT: `ladder_tax` con aliquota piatta 33% contro `GC.ladder` (l'originale") print(f" di §37), percorso per percorso: max|diff| = {d:.3e} -> " f"{'IDENTICO' if d == 0.0 else 'DIVERGE — STOP'}") if d != 0.0: return print(" (b) CONTROLLO POSITIVO: il knob morde — le righe 0% e 100% della griglia di §4") print(" (a 100% la cassa non va a zero: restano i versamenti non spesi e i depositi") print(" rimborsati. Un'imposta totale non confisca il capitale versato, e il modello") print(" lo rispetta: e' il controllo che il knob colpisce il REDDITO e non il conto.)") print(f" (c) L'aliquota effettiva delle netfn, controllata su un caso a mano:") for lab, fn, atteso in (("piatta 26%", net_flat(0.26), 0.26), ("piatta 33%", net_flat(0.33), 0.33)): got = aliq_eff(fn, 18_250.0) print(f" {lab:>12}: misurata {got:.4f} attesa {atteso:.4f} " f"{'OK' if abs(got-atteso) < 1e-12 else 'ERRORE'}") # ---------------------------------------------------------------- §3 EV del biglietto hr("§3. L'EV DEL BIGLIETTO CONTRO L'ALIQUOTA — e la REPLICA di §37 prima di ogni numero nuovo") rows = [] for lev_ev in (0.50, 0.75, 1.00): for lev_fu in (0.50, 0.75, 1.00): r = GC.ticket_mc(R_M, G_M, lev_ev=lev_ev, lev_fu=lev_fu, notional=100_000.0) rows.append(dict(lev_ev=lev_ev, lev_fu=lev_fu, **r)) T = pd.DataFrame(rows) best = T.loc[T["e_payout"].idxmax()] LEV_EV, LEV_FU = float(best["lev_ev"]), float(best["lev_fu"]) e33 = GC.ticket_mc(R_M, G_M, lev_ev=LEV_EV, lev_fu=LEV_FU, notional=100_000.0) ev33 = GC.ev_three_ways(e33, PRICE_100K) print(f" leve argmax E[payout]: eval {LEV_EV:.2f}x / funded {LEV_FU:.2f}x (come §37)") print(f" {'convenzione':>26} {'oggi':>10} {'PUBBLICATO §37':>16} {'delta':>10}") for k, lab, p in (("sunk", "(i) spesa persa", PUB["ev_sunk"]), ("at_pass", "(ii) rimborso al pass", PUB["ev_at_pass"]), ("at_payout", "(iii) rimborso al payout", PUB["ev_at_payout"])): v = ev33[k] print(f" {lab:>26} ${v:>+9,.0f} ${p:>+15,.0f} {v-p:>+10,.0f}") print(" Lo scarto (~+3%) e' lo stesso vintage di feed di §37: +1 giorno di barre. La") print(" macchineria e' quella. >>> REPLICA RIUSCITA 3/3.") _sav = GC.TAX_RATE GC.TAX_RATE = 0.0 e0 = GC.ticket_mc(R_M, G_M, lev_ev=LEV_EV, lev_fu=LEV_FU, notional=100_000.0) GC.TAX_RATE = _sav e_gross = e0["e_payout"] print(f"\n E[payout] LORDO (aliquota 0): ${e_gross:,.0f}. P(pass) {e0['p_pass']:.1%}, " f"P(payout) {e0['p_payout']:.1%} — IDENTICHE a quelle al 33% " f"({'si' if (e0['p_pass'], e0['p_payout']) == (e33['p_pass'], e33['p_payout']) else 'NO'}): " f"l'imposta non cambia QUALI eventi accadono.") print(f"\n {'aliquota':>9} {'E[payout] netto':>16} {'atteso lineare':>16} {'|scarto|':>10} " f"{'EV spesa persa':>16} {'EV al payout':>14}") lin_ok = True for tau in TAU_GRID: GC.TAX_RATE = tau rt = GC.ticket_mc(R_M, G_M, lev_ev=LEV_EV, lev_fu=LEV_FU, notional=100_000.0) GC.TAX_RATE = _sav pred = e_gross * (1.0 - tau) lin_ok &= abs(rt["e_payout"] - pred) < 1e-9 e3 = GC.ev_three_ways(rt, PRICE_100K) print(f" {tau:>8.0%} ${rt['e_payout']:>15,.1f} ${pred:>15,.1f} " f"{abs(rt['e_payout']-pred):>10.2e} ${e3['sunk']:>+15,.0f} ${e3['at_payout']:>+13,.0f}") tau_ev0 = 1.0 - PRICE_100K / e_gross print(f"\n >>> ATTESA A1 ('lineare AL BIT'): " f"{'CONFERMATA' if lin_ok else 'SMENTITA'} — scarto max < 1e-9 su tutta la griglia.") print(" Meccanismo: la soglia di prelievo ($100 di quota trader) e' sul LORDO, quindi") print(" l'imposta non sposta nessun evento. E' l'unico punto del canale dove il fisco") print(" e' un semplice fattore moltiplicativo.") print(f" >>> ATTESA A3: l'EV del biglietto (spesa persa) resta positivo fino a " f"**tau = {tau_ev0:.1%}** -> {'CONFERMATA' if tau_ev0 > 0.70 else 'SMENTITA'}.") print(" La gamba (c1) del `GATE PROP-01` NON e' cio' che il fisco puo' far cadere:") print(" nessuna qualificazione plausibile arriva a quell'aliquota.") # ---------------------------------------------------------------- §4 la scala di conti hr("§4. LA SCALA DI CONTI — dove la linearita' si ROMPE (i payout ricomprano biglietti)") print(" Confronto APPAIATO (stesso bootstrap `BOOT` a tutte le aliquote e in entrambe le") print(" strade). 'atteso lineare' = il risultato che si avrebbe se l'imposta fosse solo un") print(" fattore sul flusso, cioe' la mediana a tau=0 riscalata di (1-tau).") lad = {} for dep in (0.0, 500.0): base = None print(f"\n --- versamento EUR {dep:,.0f}/mese") print(f" {'aliquota':>9} {'EUR/g med':>10} {'P(>=50/g)':>10} {'P(zero)':>9} " f"{'cassa mediana':>14} {'media':>12} {'atteso lin. (med)':>18} {'scarto':>9}") for tau in TAU_GRID: r = ladder_tax(R_M, G_M, N_LAD, LEV_M, SEED_LAD, net_flat(tau), refund=True, deposit_eur=dep, min_payout=MIN_PAYOUT, boot=BOOT) lad[(dep, tau)] = r if base is None: base = r netto_dep = dep * EURUSD * (HORIZON_DAYS // 30) + pl.START_EUR * EURUSD lin = netto_dep + (base["med_cash"] - netto_dep) * (1.0 - tau) print(f" {tau:>8.0%} {r['med']:>10.2f} {r['p_target']:>10.1%} {r['p_zero']:>9.1%} " f"${r['med_cash']:>13,.0f} ${r['mean_cash']:>11,.0f} ${lin:>17,.0f} " f"{(r['med_cash']-lin)/max(abs(lin),1):>+9.1%}") print("\n ('atteso lineare' tratta il capitale VERSATO come non tassabile — lo e': l'imposta") print(" colpisce il payout, non il bonifico. Lo scarto misura quindi solo la COMPOSIZIONE.)") # ---------------------------------------------------------------- §5 la soglia hr("§5. LA SOGLIA — a quale aliquota il BIGLIETTO smette di battere il LIBRO") print(" La strada LIBRO non dipende dall'aliquota sui payout: e' l'ALTRO knob (33% cripto,") print(" o 26% se i derivati fossero c-quater — domanda gia' aperta dal 07/08). Percio' la") print(" soglia si legge per ogni valore del fisco del LIBRO.") out = {} def _f(x): return f"tau = {x:.1%}" if x is not None else "MAI (fuori dalla griglia 0-100%)" for dep in (0.0, 500.0): print(f"\n --- versamento EUR {dep:,.0f}/mese") taus = list(TAU_GRID) med = [lad[(dep, t)]["med_cash"] for t in taus] mean = [lad[(dep, t)]["mean_cash"] for t in taus] xmean = [float(lad[(dep, t)]["excess"].mean()) for t in taus] for tax_book in (0.26, 0.33): Bk = GC.book_road(rb, BOOT, pl.START_EUR, dep, tax=tax_book) bx = float((Bk["cash"] - Bk["contributed"]).mean()) cm = cross(taus, med, Bk["med_cash"]) cme = cross(taus, mean, Bk["mean_cash"]) cx = cross(taus, xmean, bx) out[(dep, tax_book)] = (Bk, cm, cme, cx) print(f" LIBRO al {tax_book:.0%}: mediana ${Bk['med_cash']:>9,.0f} " f"media ${Bk['mean_cash']:>9,.0f} eccedenza media ${bx:>8,.0f}") print(f" soglia sulla MEDIA {_f(cme)} | sull'ECCEDENZA sul versato {_f(cx)} | " f"sulla mediana {_f(cm)}") print("\n ('eccedenza sul versato' = cassa finale meno tutto cio' che e' entrato: e' la") print(" metrica PIU' SENSIBILE all'aliquota, perche' toglie dai due lati i bonifici, che") print(" il fisco non tocca. Se la soglia non cade dentro la banda nemmeno LI', non ci cade.)") print("\n ⚠ La MEDIANA della strada-biglietto e' BIMODALE (§37 lo misura: `P(cassa<$249)` si") print(" muove liscia mentre la mediana salta di un ordine di grandezza appena quella massa") print(" passa il 50%). Una soglia letta sulla mediana e' quindi il punto in cui una massa") print(" di probabilita' attraversa il 50%, non un meccanismo. **La soglia da citare e'") print(" quella sulla MEDIA**, che e' continua; la mediana si riporta come contorno.") # ---------------------------------------------------------------- §6 gli scenari hr("§6. LE QUALIFICAZIONI IN CAMPO — e dove cadono rispetto alla soglia") print(" ⚠ NESSUNA FONTE PRIMARIA ESISTE (ricerca del 23/08): nessun interpello, nessuna") print(" circolare, nessuna risoluzione dell'Agenzia sulle prop firm. Due fonti") print(" professionali lo dichiarano espressamente. Cio' che segue e' una BANDA di") print(" ipotesi, non una stima.") SC = scenari() print(f"\n {'':>3} {'scenario':>58} {'eff.@18k':>9} {'eff.@30k':>9} {'grado fonte':>44}") for s in SC: print(f" {s['k']:>3} {s['lab']:>58} {aliq_eff(s['fn'], 18_250.0):>9.1%} " f"{aliq_eff(s['fn'], 30_000.0):>9.1%} {s['src']:>44}") print("\n (eff.@18k = EUR 50/giorno, il bersaglio del progetto; eff.@30k = un anno buono.)") print(f"\n Effetto sulla scala di conti, versamento EUR 500/mese (l'unica riga su cui §37") print(f" ha concluso 'il biglietto batte il versare'):") Bk33 = out[(500.0, 0.33)][0] print(f" {'':>3} {'aliquota eff.':>13} {'EUR/g med':>10} {'P(>=50/g)':>10} {'P(zero)':>9} " f"{'cassa mediana':>14} {'media':>12} {'vs LIBRO(33%)':>14}") sc_rows = [] for s in SC: r = ladder_tax(R_M, G_M, N_LAD, LEV_M, SEED_LAD, s["fn"], refund=True, deposit_eur=500.0, min_payout=MIN_PAYOUT, boot=BOOT) win = "BIGLIETTO" if r["mean_cash"] > Bk33["mean_cash"] else "LIBRO" sc_rows.append(dict(k=s["k"], tag=s["tag"], eff=aliq_eff(s["fn"], 18_250.0), **r)) print(f" {s['k']:>3} {aliq_eff(s['fn'], 18_250.0):>13.1%} {r['med']:>10.2f} " f"{r['p_target']:>10.1%} {r['p_zero']:>9.1%} ${r['med_cash']:>13,.0f} " f"${r['mean_cash']:>11,.0f} {win:>14}") SCR = pd.DataFrame(sc_rows) lo, hi = SCR["eff"].iloc[1:].min(), SCR["eff"].max() cme = out[(500.0, 0.33)][2] cxx = out[(500.0, 0.33)][3] print(f"\n Banda plausibile delle aliquote effettive (escluso il controllo): " f"{lo:.1%} - {hi:.1%}.") print(f" Soglia di ribaltamento (LIBRO al 33%): sulla MEDIA " f"{'tau = ' + format(cme, '.1%') if cme is not None else 'FUORI dalla griglia 0-100%'}" f" | sull'ECCEDENZA " f"{'tau = ' + format(cxx, '.1%') if cxx is not None else 'FUORI dalla griglia 0-100%'}") dentro = (cme is not None) and (lo <= cme <= hi) print(f" >>> ATTESA A4 ('la soglia cade DENTRO la banda'): " f"{'CONFERMATA' if dentro else 'REFUTATA'}") e_pro = float(SCR.loc[SCR["tag"] == "PROGETTO", "eff"].iloc[0]) e_occ = float(SCR.loc[SCR["tag"] == "OCC", "eff"].iloc[0]) e_o30 = float(SCR.loc[SCR["tag"] == "OCC30", "eff"].iloc[0]) print(f" >>> ATTESA A5 ('la progressiva a EUR 18k sta SOTTO il forfait 33% del progetto'): " f"occasionale {e_occ:.1%} contro forfait {e_pro:.1%} -> " f"{'CONFERMATA' if e_occ < e_pro else 'REFUTATA'}.") print(f" E il seguito e' il punto trasferibile: la STESSA qualificazione, con un reddito") print(f" preesistente di EUR 30.000, sale a {e_o30:.1%} — " f"{e_o30/e_occ:.2f}x. **L'aliquota non e' una proprieta' della strategia, e' una") print(f" proprieta' del contribuente**, e il canale funded e' l'unico pezzo del") print(f" progetto in cui questo e' vero (le plusvalenze cripto hanno aliquota fissa).") hr("§6.2 LA CATEGORIA CAMBIA ANCHE LA BASE, non solo l'aliquota") print(" art. 71 c.2 TUIR (testo verificato in sessione): i redditi di cui all'art. 67 c.1") print(" lett. l) sono 'la DIFFERENZA fra l'ammontare percepito nel periodo di imposta e le") print(" spese specificamente inerenti alla loro produzione' -> **sotto lavoro autonomo le") print(" quote di challenge SI DEDUCONO**; sotto un'imposta sostitutiva su reddito") print(" finanziario NO (una challenge persa non e' una minusvalenza da cripto-attivita'),") print(" e sotto forfettario nemmeno (le sostituisce il coefficiente).") sp_med = float(lad[(500.0, 0.33)]["spent"]) sp_anno = sp_med / 3.0 / EURUSD print(f"\n Quote comprate in media su 36 mesi: ${sp_med:,.0f} = EUR {sp_anno:,.0f}/anno.") print(f" {'scenario':>52} {'senza deduzione':>16} {'con deduzione':>14} {'delta':>8}") for lab, fn_nd, fn_d in ( ("lav.aut. OCCASIONALE, nessun altro reddito", net_prog(0.0, "occasionale", deduci=False), net_prog(0.0, "occasionale")), ("lav.aut. ABITUALE INPS piena, altro reddito 30k", net_prog(30_000.0, "piena", deduci=False), net_prog(30_000.0, "piena"))): a = aliq_eff(fn_nd, 18_250.0, sp_anno) b = aliq_eff(fn_d, 18_250.0, sp_anno) print(f" {lab:>52} {a:>16.2%} {b:>14.2%} {b-a:>+8.2%}") print(" -> la categoria con l'aliquota PIU' ALTA e' anche l'unica che deduce il costo dei") print(" biglietti: l'ordine fra le qualificazioni non e' l'ordine fra le aliquote.") hr("§6.1 ROBUSTEZZA — i due numeri della ricerca che NON ho verificato su fonte primaria") print(" (a) secondo scaglione IRPEF 2026: 33% (L.199/2025) contro il 35% del 2025.") for lab, sg in (("33% (2026)", IRPEF_SCAGLIONI), ("35% (2025)", IRPEF_2025)): f1 = net_prog(0.0, "occasionale", sg) f2 = net_prog(30_000.0, "occasionale", sg) print(f" {lab:>11}: occasionale {aliq_eff(f1, 18_250.0):.2%} " f"con altro reddito 30k {aliq_eff(f2, 18_250.0):.2%}") print(" (b) chi versa i 2/3 di Gestione Separata con committente ESTERO — buco documentale:") for lab, inps in (("committente versa 2/3", "occasionale"), ("tutto sul prestatore", "piena")): print(f" {lab:>22}: eff.@18k " f"{aliq_eff(net_prog(0.0, inps), 18_250.0):>6.1%} " f"@30k {aliq_eff(net_prog(0.0, inps), 30_000.0):>6.1%}") # ---------------------------------------------------------------- §7 verdetto hr("§7. VERDETTO — e la domanda, scritta in modo che una risposta sia possibile") r33 = lad[(500.0, 0.33)] print(f" 1. Il forfait 33% NON e' l'aliquota di questa cosa: sul funded il trader non") print(f" possiede il conto ne' le posizioni, non c'e' realizzo di cripto-attivita', e") print(f" l'art. 67 c-sexies (33%) e c-quater (26%) — le due caselle su cui il progetto") print(f" discute per il LIBRO — sono entrambe FUORI CATEGORIA qui. Le fonti") print(f" professionali convergono su LAVORO AUTONOMO. Nessuna prassi ufficiale esiste.") print(f" 2. La conclusione di §37 ('il biglietto batte il versare' a EUR 500/mese) " f"{'REGGE' if cme is None or cme > hi else 'NON REGGE'} " f"su tutta la banda plausibile.") print(f" 3. Il costo della QUESTIONE, misurato: passare dall'aliquota piu' bassa a quella") print(f" piu' alta della banda vale, sulla cassa mediana a 36 mesi,") lo_r = SCR.loc[SCR["eff"].iloc[1:].idxmin()] hi_r = SCR.loc[SCR["eff"].idxmax()] print(f" ${lo_r['med_cash']:,.0f} -> ${hi_r['med_cash']:,.0f} " f"({(hi_r['med_cash']/max(lo_r['med_cash'],1)-1)*100:+.0f}%), e su P(>=50/g) " f"{lo_r['p_target']:.1%} -> {hi_r['p_target']:.1%}.") d_eur = (hi_r["med_cash"] - lo_r["med_cash"]) / EURUSD / (HORIZON_DAYS / 365.0) / 365.0 print(f" In EUR/GIORNO di rendita a 36 mesi: **{d_eur:+.2f} EUR/giorno** fra i due") print(f" estremi della banda, contro un bersaglio di 50.") print(f" 4. Al 33% di oggi la scala di conti da' EUR/g mediana {r33['med']:.2f} e " f"P(>=50/g) {r33['p_target']:.1%}: **l'aliquota non e' cio' che tiene lontano il") print(f" bersaglio**, lo tiene lontano la distribuzione.") print("\n LA DOMANDA AL COMMERCIALISTA (accanto a quella gia' aperta dal 07/08 sui") print(" derivati, 26% contro 33% — e questa e' una domanda DIVERSA, non la stessa):") print(" Q1. Il profit share pagato da una prop firm estera a chi NON possiede il conto,") print(" NON possiede le posizioni e NON apporta capitale e': art. 67 c.1 lett. l),") print(" art. 53, art. 55, oppure art. 67 c.1 lett. c-quater TUIR? **Indichi la lettera.**") print(" Q2. Una prop firm non residente e senza stabile organizzazione puo' operare una") print(" ritenuta italiana sul payout? (SI'/NO)") print(" Q3. Superata la soglia di EUR 5.000 di compensi occasionali, con committente") print(" (a) UE e (b) extra-UE: l'aliquota di Gestione Separata che grava sul") print(" PRESTATORE e' 1/3 di 26,07% o l'intero 26,07%? (una risposta per caso)") print(" Q4. Con partita IVA: quale ATECO, e quindi quale coefficiente forfettario,") print(" 78% o 67%? (una sigla e una percentuale)") print(" Q5. Il funded account va in quadro RW / IVAFE? (SI'/NO) Se no, l'obbligo si") print(" limita al conto estero su cui incasso?") print("\n ONESTA' OBBLIGATORIE:") print(" * questo NON e' un parere fiscale, e nessuna riga qui sopra e' una consulenza.") print(" * l'aliquota EFFETTIVA degli scenari progressivi e' calcolata SENZA detrazioni") print(" (conservativo: le detrazioni la abbassano) e con addizionali al minimo di legge.") print(" * il modello tassa i payout dell'anno via via che arrivano, non a saldo: toglie") print(" liquidita' prima del dovuto, quindi e' conservativo sulla ricomposizione.") print(" * tutte le assunzioni di §37 restano dentro: morte-firm 10%/anno (mai stimata),") print(" cap $200k/trader, XS01 su U13 fuori campione, ancora giornaliera di TP01 fuori") print(" dalla banda. Il fisco e' UN parametro fra questi, e non il piu' incerto.") print(f"\n fatto in {time.time()-T0:.0f}s") print("=" * 104) if __name__ == "__main__": main()