Dataset Viewer
Auto-converted to Parquet Duplicate
benchmark_id
stringlengths
14
14
hurst_parameter
float64
0.03
0.5
h_regime
stringclasses
5 values
nu_vol_of_vol
float64
1.21
2.8
rho_correlation
float64
-0.9
-0.65
atm_skew_slope
float64
-6.39
-0.42
variogram_scaling_exponent
float64
0.06
1
sample_fbm_variance_trajectory
listlengths
10
10
sample_iv_smile_strikes
listlengths
7
7
sample_iv_smile_vols
listlengths
7
7
verification_code
stringlengths
433
439
RVOL-ULTR-0001
0.045
ultra_rough_h005
2.721
-0.717
-5.1029
0.09
[ 0.04, 0.00119, 0.0018, 0.00204, 0.00327, 0.00192, 0.00143, 0.00112, 0.00078, 0.00027 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 1.3687, 0.7473, 0.4644, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-ULTR-0001 (H = 0.045) H = 0.045 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0, '...
RVOL-EQUI-0002
0.083
equity_index_rough_h010
1.774
-0.871
-3.4616
0.166
[ 0.04, 0.02228, 0.03218, 0.01886, 0.01603, 0.00934, 0.00614, 0.01028, 0.01757, 0.01466 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.9553, 0.5619, 0.377, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-EQUI-0002 (H = 0.083) H = 0.083 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0, '...
RVOL-COMM-0003
0.1555
commodity_rough_h015
2.755
-0.659
-3.0613
0.311
[ 0.04, 0.01254, 0.00128, 0.00063, 0.00038, 0.00065, 0.00054, 0.00038, 0.00049, 0.00082 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.9641, 0.5441, 0.3626, 0.2, 0.0564, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-COMM-0003 (H = 0.1555) H = 0.1555 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-SUB_-0004
0.3397
sub_diffusive_h030
2.619
-0.705
-1.5903
0.6794
[ 0.04, 0.00722, 0.01478, 0.02176, 0.00807, 0.06842, 0.07923, 0.01818, 0.03196, 0.01133 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.6552, 0.3933, 0.2881, 0.2, 0.1291, 0.0753, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-SUB_-0004 (H = 0.3397) H = 0.3397 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-STAN-0005
0.4939
standard_markovian_h050
2.324
-0.81
-0.9604
0.9878
[ 0.04, 0.30543, 0.05803, 0.07547, 0.08625, 0.07517, 0.15009, 0.44288, 0.34968, 0.79803 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.5001, 0.323, 0.2548, 0.2, 0.1587, 0.131, 0.1159 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-STAN-0005 (H = 0.4939) H = 0.4939 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-ULTR-0006
0.0399
ultra_rough_h005
1.77
-0.711
-3.362
0.0798
[ 0.04, 0.01584, 0.01852, 0.01103, 0.01097, 0.00383, 0.00377, 0.00436, 0.00347, 0.0067 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.9351, 0.5519, 0.372, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-ULTR-0006 (H = 0.0399) H = 0.0399 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-EQUI-0007
0.0936
equity_index_rough_h010
2.689
-0.685
-3.9551
0.1872
[ 0.04, 0.04255, 0.01083, 0.00579, 0.00638, 0.00546, 0.00919, 0.0049, 0.00843, 0.00566 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 1.1356, 0.6317, 0.4068, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-EQUI-0007 (H = 0.0936) H = 0.0936 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-COMM-0008
0.1974
commodity_rough_h015
1.219
-0.658
-1.1543
0.3948
[ 0.04, 0.04047, 0.03639, 0.03594, 0.02351, 0.02492, 0.03101, 0.05299, 0.06565, 0.12432 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.4606, 0.3229, 0.2596, 0.2, 0.1441, 0.092, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-COMM-0008 (H = 0.1974) H = 0.1974 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-SUB_-0009
0.302
sub_diffusive_h030
2.436
-0.77
-1.8449
0.604
[ 0.04, 0.04159, 0.16672, 0.32573, 0.21199, 0.04946, 0.03408, 0.11801, 0.18003, 0.08882 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.6877, 0.4142, 0.2997, 0.2, 0.1152, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-SUB_-0009 (H = 0.302) H = 0.302 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0, '...
RVOL-STAN-0010
0.495
standard_markovian_h050
1.495
-0.848
-0.6444
0.99
[ 0.04, 0.02595, 0.00253, 0.00111, 0.00483, 0.01754, 0.01562, 0.02243, 0.02651, 0.12199 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.3736, 0.2756, 0.235, 0.2, 0.1706, 0.1467, 0.1158 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-STAN-0010 (H = 0.495) H = 0.495 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0, '...
RVOL-ULTR-0011
0.0529
ultra_rough_h005
1.648
-0.708
-2.954
0.1058
[ 0.04, 0.01202, 0.00824, 0.01068, 0.00405, 0.00473, 0.00516, 0.00363, 0.0058, 0.00431 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.8451, 0.509, 0.3511, 0.2, 0.0557, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-ULTR-0011 (H = 0.0529) H = 0.0529 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-EQUI-0012
0.105
equity_index_rough_h010
1.387
-0.665
-1.8928
0.21
[ 0.04, 0.01022, 0.02471, 0.02622, 0.02023, 0.02595, 0.05633, 0.0458, 0.04264, 0.03216 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.617, 0.3989, 0.297, 0.2, 0.1078, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-EQUI-0012 (H = 0.105) H = 0.105 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0, '...
RVOL-COMM-0013
0.1989
commodity_rough_h015
2.542
-0.869
-3.1612
0.3978
[ 0.04, 1.17861, 0.40383, 0.08401, 0.05059, 0.10534, 0.04041, 0.06877, 0.00755, 0.00747 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.9615, 0.5484, 0.3661, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-COMM-0013 (H = 0.1989) H = 0.1989 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-SUB_-0014
0.2656
sub_diffusive_h030
2.346
-0.735
-1.9319
0.5312
[ 0.04, 0.09699, 0.01235, 0.00757, 0.01415, 0.00418, 0.00933, 0.00724, 0.00536, 0.00967 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.6965, 0.4207, 0.3035, 0.2, 0.1103, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-SUB_-0014 (H = 0.2656) H = 0.2656 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-STAN-0015
0.4804
standard_markovian_h050
2.663
-0.871
-1.2375
0.9608
[ 0.04, 0.00052, 0.00477, 0.13468, 0.25905, 0.10696, 0.15539, 0.64099, 2.07611, 0.58761 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.5893, 0.3592, 0.2707, 0.2, 0.147, 0.1117, 0.0943 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-STAN-0015 (H = 0.4804) H = 0.4804 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-ULTR-0016
0.0517
ultra_rough_h005
2.597
-0.717
-4.7376
0.1034
[ 0.04, 0.00669, 0.00969, 0.0105, 0.0093, 0.00667, 0.00238, 0.00332, 0.00349, 0.0037 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 1.2824, 0.7075, 0.4453, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-ULTR-0016 (H = 0.0517) H = 0.0517 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-EQUI-0017
0.0817
equity_index_rough_h010
1.229
-0.653
-1.8073
0.1634
[ 0.04, 0.01026, 0.00889, 0.00797, 0.01268, 0.01276, 0.0106, 0.02306, 0.01697, 0.02353 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.5917, 0.3883, 0.2923, 0.2, 0.1115, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-EQUI-0017 (H = 0.0817) H = 0.0817 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-COMM-0018
0.1696
commodity_rough_h015
1.627
-0.68
-1.7679
0.3392
[ 0.04, 0.04916, 0.08246, 0.09483, 0.08999, 0.12261, 0.16383, 0.23181, 0.21532, 0.14353 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.6065, 0.39, 0.2917, 0.2, 0.1149, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-COMM-0018 (H = 0.1696) H = 0.1696 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-SUB_-0019
0.2582
sub_diffusive_h030
2.289
-0.736
-1.9387
0.5164
[ 0.04, 0.01953, 0.00453, 0.00553, 0.01192, 0.00364, 0.01804, 0.03071, 0.02036, 0.0105 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.6925, 0.4201, 0.3035, 0.2, 0.1096, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-SUB_-0019 (H = 0.2582) H = 0.2582 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-STAN-0020
0.4821
standard_markovian_h050
1.587
-0.653
-0.5498
0.9642
[ 0.04, 0.03862, 0.01041, 0.05076, 0.09396, 0.07, 0.06508, 0.06831, 0.02001, 0.01773 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.3603, 0.2676, 0.2306, 0.2, 0.1757, 0.1576, 0.1404 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-STAN-0020 (H = 0.4821) H = 0.4821 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-ULTR-0021
0.0597
ultra_rough_h005
1.881
-0.814
-3.7699
0.1194
[ 0.04, 0.00477, 0.01866, 0.01363, 0.02681, 0.01011, 0.00841, 0.01209, 0.01197, 0.01368 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 1.0247, 0.5947, 0.3929, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-ULTR-0021 (H = 0.0597) H = 0.0597 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-EQUI-0022
0.0823
equity_index_rough_h010
2.05
-0.666
-3.0673
0.1646
[ 0.04, 0.02431, 0.01579, 0.01413, 0.00416, 0.00851, 0.0096, 0.01442, 0.00309, 0.01055 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.8975, 0.5277, 0.3586, 0.2, 0.0519, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-EQUI-0022 (H = 0.0823) H = 0.0823 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-COMM-0023
0.1681
commodity_rough_h015
1.209
-0.819
-1.5913
0.3362
[ 0.04, 0.0134, 0.00724, 0.00681, 0.01796, 0.00922, 0.00967, 0.00668, 0.00647, 0.00806 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.5475, 0.3664, 0.2814, 0.2, 0.1223, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-COMM-0023 (H = 0.1681) H = 0.1681 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-SUB_-0024
0.2757
sub_diffusive_h030
2.741
-0.779
-2.3069
0.5514
[ 0.04, 0.04066, 0.23291, 0.12589, 0.04626, 0.04211, 0.05897, 0.04599, 0.03787, 0.01638 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.8116, 0.4683, 0.3247, 0.2, 0.094, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-SUB_-0024 (H = 0.2757) H = 0.2757 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-STAN-0025
0.4814
standard_markovian_h050
2.481
-0.842
-1.1109
0.9628
[ 0.04, 0.45775, 0.2444, 0.30648, 2.88058, 0.44265, 0.09335, 0.15487, 0.71655, 0.43627 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.5453, 0.3419, 0.2632, 0.2, 0.1521, 0.1197, 0.1009 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-STAN-0025 (H = 0.4814) H = 0.4814 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-ULTR-0026
0.0651
ultra_rough_h005
2.589
-0.699
-4.3587
0.1302
[ 0.04, 0.00285, 0.00638, 0.00429, 0.00239, 0.00348, 0.00189, 0.00209, 0.00211, 0.00371 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 1.2058, 0.6694, 0.4263, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-ULTR-0026 (H = 0.0651) H = 0.0651 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-EQUI-0027
0.0947
equity_index_rough_h010
1.863
-0.693
-2.7601
0.1894
[ 0.04, 0.03555, 0.03904, 0.02725, 0.02074, 0.01548, 0.015, 0.02162, 0.01303, 0.01379 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.8214, 0.4934, 0.3423, 0.2, 0.0663, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-EQUI-0027 (H = 0.0947) H = 0.0947 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-COMM-0028
0.143
commodity_rough_h015
1.479
-0.875
-2.2895
0.286
[ 0.04, 0.07133, 0.07196, 0.08954, 0.04371, 0.02025, 0.04373, 0.03249, 0.02764, 0.04653 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.7016, 0.4399, 0.3172, 0.2, 0.0883, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-COMM-0028 (H = 0.143) H = 0.143 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0, '...
RVOL-SUB_-0029
0.309
sub_diffusive_h030
2.013
-0.826
-1.5953
0.618
[ 0.04, 0.58551, 0.41959, 0.30183, 0.43234, 0.16035, 0.18583, 0.11919, 0.09918, 0.15033 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.6001, 0.3798, 0.2848, 0.2, 0.1253, 0.0607, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-SUB_-0029 (H = 0.309) H = 0.309 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0, '...
RVOL-STAN-0030
0.4942
standard_markovian_h050
2.462
-0.771
-0.9675
0.9884
[ 0.04, 0.00229, 0.0035, 0.00182, 0.00025, 0.00037, 0.00045, 0.00234, 0.00443, 0.00197 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.5147, 0.3271, 0.256, 0.2, 0.1592, 0.1336, 0.1277 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-STAN-0030 (H = 0.4942) H = 0.4942 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-ULTR-0031
0.0326
ultra_rough_h005
1.98
-0.892
-4.8641
0.0652
[ 0.04, 0.0092, 0.00528, 0.00308, 0.00276, 0.00372, 0.00415, 0.0054, 0.00539, 0.00516 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 1.2512, 0.706, 0.4481, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-ULTR-0031 (H = 0.0326) H = 0.0326 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-EQUI-0032
0.1008
equity_index_rough_h010
1.528
-0.681
-2.1713
0.2016
[ 0.04, 0.01922, 0.00817, 0.01621, 0.0152, 0.01408, 0.05259, 0.04189, 0.0258, 0.02103 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.681, 0.4288, 0.3115, 0.2, 0.0944, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-EQUI-0032 (H = 0.1008) H = 0.1008 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-COMM-0033
0.163
commodity_rough_h015
2.515
-0.785
-3.2349
0.326
[ 0.04, 0.01442, 0.00097, 0.00111, 0.00396, 0.00596, 0.00264, 0.00185, 0.00154, 0.00108 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.9735, 0.5551, 0.3697, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-COMM-0033 (H = 0.163) H = 0.163 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0, '...
RVOL-SUB_-0034
0.3358
sub_diffusive_h030
1.668
-0.672
-0.9787
0.6716
[ 0.04, 0.09917, 0.12478, 0.03946, 0.08791, 0.04899, 0.07755, 0.08349, 0.21435, 0.14382 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.4514, 0.3118, 0.2524, 0.2, 0.1545, 0.116, 0.0599 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-SUB_-0034 (H = 0.3358) H = 0.3358 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-STAN-0035
0.4927
standard_markovian_h050
1.313
-0.836
-0.5622
0.9854
[ 0.04, 0.02214, 0.00335, 0.00438, 0.00149, 0.00269, 0.00171, 0.00135, 0.00121, 0.00132 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.3469, 0.2648, 0.2303, 0.2, 0.174, 0.1524, 0.122 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-STAN-0035 (H = 0.4927) H = 0.4927 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-ULTR-0036
0.0304
ultra_rough_h005
2.218
-0.672
-4.1428
0.0608
[ 0.04, 0.00967, 0.00814, 0.00536, 0.00602, 0.00373, 0.00418, 0.00417, 0.0039, 0.00381 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 1.127, 0.6389, 0.4133, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-ULTR-0036 (H = 0.0304) H = 0.0304 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-EQUI-0037
0.0946
equity_index_rough_h010
1.549
-0.653
-2.1633
0.1892
[ 0.04, 0.08054, 0.03493, 0.02916, 0.01588, 0.0171, 0.01427, 0.01437, 0.01717, 0.0111 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.6806, 0.4283, 0.3112, 0.2, 0.0948, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-EQUI-0037 (H = 0.0946) H = 0.0946 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-COMM-0038
0.1909
commodity_rough_h015
1.409
-0.702
-1.4585
0.3818
[ 0.04, 0.04039, 0.02741, 0.03905, 0.02827, 0.03336, 0.03051, 0.04878, 0.04084, 0.01748 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.5314, 0.3558, 0.2754, 0.2, 0.1296, 0.0641, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-COMM-0038 (H = 0.1909) H = 0.1909 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-SUB_-0039
0.3159
sub_diffusive_h030
2.426
-0.689
-1.5651
0.6318
[ 0.04, 0.00709, 0.01385, 0.0051, 0.00601, 0.00123, 0.00036, 0.00047, 0.00039, 0.00056 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.6307, 0.3859, 0.2856, 0.2, 0.1291, 0.0729, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-SUB_-0039 (H = 0.3159) H = 0.3159 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-STAN-0040
0.4955
standard_markovian_h050
1.634
-0.776
-0.6435
0.991
[ 0.04, 0.01256, 0.01063, 0.00798, 0.0108, 0.00654, 0.01558, 0.01604, 0.01626, 0.01375 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.3821, 0.2777, 0.2355, 0.2, 0.1712, 0.149, 0.1247 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-STAN-0040 (H = 0.4955) H = 0.4955 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-ULTR-0041
0.0629
ultra_rough_h005
2.561
-0.847
-5.2715
0.1258
[ 0.04, 0.00383, 0.017, 0.00792, 0.00788, 0.01107, 0.01977, 0.00856, 0.00598, 0.01074 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 1.3855, 0.7599, 0.4718, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-ULTR-0041 (H = 0.0629) H = 0.0629 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-EQUI-0042
0.0891
equity_index_rough_h010
1.595
-0.779
-2.7163
0.1782
[ 0.04, 0.01882, 0.04436, 0.03218, 0.03029, 0.0156, 0.01292, 0.012, 0.01131, 0.0192 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.7941, 0.4844, 0.339, 0.2, 0.0674, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-EQUI-0042 (H = 0.0891) H = 0.0891 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-COMM-0043
0.1634
commodity_rough_h015
2.349
-0.838
-3.2205
0.3268
[ 0.04, 0.11975, 0.16684, 0.09448, 0.02087, 0.01963, 0.05781, 0.06149, 0.03769, 0.04751 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.9545, 0.5496, 0.3679, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-COMM-0043 (H = 0.1634) H = 0.1634 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-SUB_-0044
0.2976
sub_diffusive_h030
1.996
-0.849
-1.693
0.5952
[ 0.04, 0.00478, 0.0128, 0.03346, 0.01945, 0.00221, 0.00371, 0.00597, 0.00827, 0.01868 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.6183, 0.3892, 0.2896, 0.2, 0.1203, 0.0506, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-SUB_-0044 (H = 0.2976) H = 0.2976 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-STAN-0045
0.4903
standard_markovian_h050
2.014
-0.808
-0.8402
0.9806
[ 0.04, 0.33097, 0.68546, 0.9803, 0.5542, 1.04846, 1.57679, 0.81196, 1.01671, 0.55115 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.4492, 0.3043, 0.2471, 0.2, 0.1631, 0.1363, 0.1131 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-STAN-0045 (H = 0.4903) H = 0.4903 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-ULTR-0046
0.0434
ultra_rough_h005
2.372
-0.799
-4.9901
0.0868
[ 0.04, 0.0037, 0.00145, 0.00113, 0.00272, 0.00243, 0.00195, 0.00226, 0.00282, 0.00421 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 1.3105, 0.7271, 0.4565, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-ULTR-0046 (H = 0.0434) H = 0.0434 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-EQUI-0047
0.1179
equity_index_rough_h010
1.369
-0.861
-2.2991
0.2358
[ 0.04, 0.02385, 0.02731, 0.05545, 0.0579, 0.03249, 0.06051, 0.04938, 0.03953, 0.03291 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.6973, 0.4393, 0.3173, 0.2, 0.0874, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-EQUI-0047 (H = 0.1179) H = 0.1179 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-COMM-0048
0.1558
commodity_rough_h015
2.633
-0.733
-3.2505
0.3116
[ 0.04, 0.01016, 0.0483, 0.00655, 0.01293, 0.00607, 0.02505, 0.08244, 0.02452, 0.01298 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.9888, 0.5597, 0.3712, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-COMM-0048 (H = 0.1558) H = 0.1558 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-SUB_-0049
0.3359
sub_diffusive_h030
2.397
-0.79
-1.6528
0.6718
[ 0.04, 0.00371, 0.01144, 0.00357, 0.00839, 0.00296, 0.00719, 0.0078, 0.03356, 0.02091 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.6455, 0.394, 0.2898, 0.2, 0.1245, 0.0634, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-SUB_-0049 (H = 0.3359) H = 0.3359 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-STAN-0050
0.4938
standard_markovian_h050
1.605
-0.898
-0.7356
0.9876
[ 0.04, 0.06088, 0.37907, 0.33945, 0.33432, 0.24697, 0.45178, 0.70441, 0.3929, 0.16327 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.3986, 0.2864, 0.24, 0.2, 0.1664, 0.1393, 0.1044 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-STAN-0050 (H = 0.4938) H = 0.4938 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-ULTR-0051
0.0368
ultra_rough_h005
1.512
-0.677
-2.7701
0.0736
[ 0.04, 0.01962, 0.01899, 0.02072, 0.02818, 0.02907, 0.02696, 0.03822, 0.04059, 0.03276 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.7997, 0.4884, 0.3414, 0.2, 0.0644, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-ULTR-0051 (H = 0.0368) H = 0.0368 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-EQUI-0052
0.1067
equity_index_rough_h010
1.717
-0.676
-2.366
0.2134
[ 0.04, 0.0162, 0.02573, 0.02597, 0.02629, 0.02879, 0.01204, 0.01863, 0.02271, 0.01313 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.7322, 0.4513, 0.322, 0.2, 0.0854, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-EQUI-0052 (H = 0.1067) H = 0.1067 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-COMM-0053
0.1426
commodity_rough_h015
2.328
-0.786
-3.2422
0.2852
[ 0.04, 0.05352, 0.04441, 0.04452, 0.08692, 0.09662, 0.08538, 0.02928, 0.20081, 0.05303 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.9568, 0.5513, 0.3689, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-COMM-0053 (H = 0.1426) H = 0.1426 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-SUB_-0054
0.2855
sub_diffusive_h030
2.278
-0.884
-2.1005
0.571
[ 0.04, 0.0841, 0.02485, 0.01471, 0.00592, 0.00678, 0.00347, 0.00656, 0.00159, 0.00154 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.7239, 0.436, 0.3115, 0.2, 0.1015, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-SUB_-0054 (H = 0.2855) H = 0.2855 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-STAN-0055
0.4846
standard_markovian_h050
2.084
-0.807
-0.8849
0.9692
[ 0.04, 0.0061, 0.01799, 0.00417, 0.00721, 0.00348, 0.00221, 0.00366, 0.00291, 0.00415 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.4638, 0.3102, 0.2497, 0.2, 0.1612, 0.1332, 0.1099 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-STAN-0055 (H = 0.4846) H = 0.4846 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-ULTR-0056
0.0504
ultra_rough_h005
2.184
-0.672
-3.7542
0.1008
[ 0.04, 0.01136, 0.07873, 0.01149, 0.02399, 0.015, 0.01451, 0.01222, 0.00928, 0.00717 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 1.0462, 0.5993, 0.3937, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-ULTR-0056 (H = 0.0504) H = 0.0504 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-EQUI-0057
0.0825
equity_index_rough_h010
1.348
-0.859
-2.5993
0.165
[ 0.04, 0.01361, 0.01862, 0.01837, 0.02208, 0.0119, 0.01364, 0.02791, 0.02141, 0.02652 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.7562, 0.469, 0.3322, 0.2, 0.0723, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-EQUI-0057 (H = 0.0825) H = 0.0825 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-COMM-0058
0.1986
commodity_rough_h015
1.544
-0.883
-1.9532
0.3972
[ 0.04, 0.1357, 0.11433, 0.0802, 0.05558, 0.02857, 0.03038, 0.03359, 0.01711, 0.02174 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.6383, 0.4072, 0.3006, 0.2, 0.1053, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-COMM-0058 (H = 0.1986) H = 0.1986 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-SUB_-0059
0.3113
sub_diffusive_h030
2.702
-0.735
-1.89
0.6226
[ 0.04, 0.01824, 0.00653, 0.00039, 0.00313, 0.00527, 0.00799, 0.00151, 0.00675, 0.00388 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.724, 0.4255, 0.3036, 0.2, 0.1146, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-SUB_-0059 (H = 0.3113) H = 0.3113 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-STAN-0060
0.4854
standard_markovian_h050
1.21
-0.655
-0.4159
0.9708
[ 0.04, 0.03515, 0.05103, 0.02616, 0.05877, 0.09653, 0.11597, 0.09823, 0.11601, 0.07983 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.3125, 0.2489, 0.2226, 0.2, 0.181, 0.1657, 0.1461 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-STAN-0060 (H = 0.4854) H = 0.4854 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-ULTR-0061
0.032
ultra_rough_h005
1.882
-0.692
-3.5957
0.064
[ 0.04, 0.00759, 0.01032, 0.01183, 0.00883, 0.00476, 0.00471, 0.00647, 0.00522, 0.00561 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.99, 0.5773, 0.3842, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-ULTR-0061 (H = 0.032) H = 0.032 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0, '...
RVOL-EQUI-0062
0.0916
equity_index_rough_h010
1.948
-0.745
-3.1411
0.1832
[ 0.04, 0.00439, 0.00184, 0.00472, 0.00184, 0.00217, 0.0034, 0.00401, 0.00507, 0.00551 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.9041, 0.5331, 0.3618, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-EQUI-0062 (H = 0.0916) H = 0.0916 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-COMM-0063
0.1942
commodity_rough_h015
1.851
-0.864
-2.3292
0.3884
[ 0.04, 0.00867, 0.02997, 0.10986, 0.07998, 0.06318, 0.05583, 0.0955, 0.14022, 0.09355 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.7344, 0.4501, 0.3207, 0.2, 0.0878, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-COMM-0063 (H = 0.1942) H = 0.1942 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-SUB_-0064
0.3132
sub_diffusive_h030
1.405
-0.755
-1.0028
0.6264
[ 0.04, 0.12481, 0.19064, 0.18123, 0.16531, 0.36134, 0.25145, 0.10681, 0.12279, 0.29193 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.44, 0.3102, 0.2526, 0.2, 0.1523, 0.1096, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-SUB_-0064 (H = 0.3132) H = 0.3132 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-STAN-0065
0.4876
standard_markovian_h050
1.299
-0.815
-0.5515
0.9752
[ 0.04, 0.00789, 0.01271, 0.00328, 0.00289, 0.00219, 0.00244, 0.00264, 0.00479, 0.0105 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.344, 0.2636, 0.2297, 0.2, 0.1745, 0.1533, 0.1234 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-STAN-0065 (H = 0.4876) H = 0.4876 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-ULTR-0066
0.0676
ultra_rough_h005
1.399
-0.681
-2.2714
0.1352
[ 0.04, 0.02808, 0.00851, 0.01454, 0.01563, 0.01464, 0.02853, 0.01963, 0.01708, 0.03062 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.6934, 0.4369, 0.316, 0.2, 0.0889, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-ULTR-0066 (H = 0.0676) H = 0.0676 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-EQUI-0067
0.1005
equity_index_rough_h010
1.973
-0.804
-3.3139
0.201
[ 0.04, 0.01379, 0.01478, 0.00844, 0.00905, 0.00975, 0.00644, 0.01165, 0.01139, 0.01367 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.9406, 0.5509, 0.3706, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-EQUI-0067 (H = 0.1005) H = 0.1005 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-COMM-0068
0.1863
commodity_rough_h015
2.586
-0.885
-3.4334
0.3726
[ 0.04, 0.0052, 0.01111, 0.03834, 0.0027, 0.00562, 0.00061, 0.00043, 0.00239, 0.0014 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 1.0204, 0.5768, 0.38, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-COMM-0068 (H = 0.1863) H = 0.1863 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-SUB_-0069
0.2696
sub_diffusive_h030
1.236
-0.685
-0.935
0.5392
[ 0.04, 0.08519, 0.06883, 0.12037, 0.11185, 0.196, 0.11856, 0.1085, 0.13498, 0.09028 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.4176, 0.3011, 0.2487, 0.2, 0.1552, 0.1141, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-SUB_-0069 (H = 0.2696) H = 0.2696 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-STAN-0070
0.4993
standard_markovian_h050
1.83
-0.867
-0.7951
0.9986
[ 0.04, 0.34357, 0.55666, 0.07681, 0.09255, 0.01598, 0.01708, 0.06437, 0.03215, 0.01862 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.426, 0.2963, 0.2439, 0.2, 0.1644, 0.1372, 0.108 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-STAN-0070 (H = 0.4993) H = 0.4993 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-ULTR-0071
0.0678
ultra_rough_h005
1.701
-0.685
-2.7757
0.1356
[ 0.04, 0.02191, 0.01265, 0.01912, 0.02732, 0.02758, 0.02009, 0.01744, 0.03216, 0.02292 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.813, 0.492, 0.3424, 0.2, 0.0648, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-ULTR-0071 (H = 0.0678) H = 0.0678 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-EQUI-0072
0.1193
equity_index_rough_h010
1.6
-0.882
-2.7375
0.2386
[ 0.04, 0.05252, 0.10168, 0.02479, 0.01004, 0.00916, 0.01393, 0.01734, 0.02598, 0.01369 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.7987, 0.4866, 0.3401, 0.2, 0.0663, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-EQUI-0072 (H = 0.1193) H = 0.1193 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-COMM-0073
0.1536
commodity_rough_h015
2.524
-0.9
-3.8582
0.3072
[ 0.04, 0.00345, 0.00203, 0.00353, 0.00114, 0.00091, 0.00032, 0.00103, 0.00089, 0.001 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 1.0991, 0.6177, 0.4009, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-COMM-0073 (H = 0.1536) H = 0.1536 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-SUB_-0074
0.2543
sub_diffusive_h030
1.487
-0.802
-1.3919
0.5086
[ 0.04, 0.02247, 0.03046, 0.0281, 0.03061, 0.01956, 0.03894, 0.01859, 0.02493, 0.04273 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.5226, 0.3502, 0.2724, 0.2, 0.1332, 0.0719, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-SUB_-0074 (H = 0.2543) H = 0.2543 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-STAN-0075
0.4907
standard_markovian_h050
1.513
-0.858
-0.6694
0.9814
[ 0.04, 0.02697, 0.05529, 0.15947, 0.07782, 0.09069, 0.07489, 0.09836, 0.20103, 0.15592 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.3797, 0.2784, 0.2363, 0.2, 0.1694, 0.1445, 0.1119 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-STAN-0075 (H = 0.4907) H = 0.4907 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-ULTR-0076
0.0659
ultra_rough_h005
2.04
-0.723
-3.5408
0.1318
[ 0.04, 0.0089, 0.00336, 0.00389, 0.00382, 0.00676, 0.00775, 0.00425, 0.00506, 0.00681 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.9914, 0.5749, 0.3822, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-ULTR-0076 (H = 0.0659) H = 0.0659 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-EQUI-0077
0.1047
equity_index_rough_h010
2.752
-0.718
-4.0598
0.2094
[ 0.04, 0.00824, 0.00692, 0.00177, 0.0029, 0.00655, 0.01514, 0.00798, 0.03686, 0.00493 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 1.1634, 0.6438, 0.4125, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-EQUI-0077 (H = 0.1047) H = 0.1047 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-COMM-0078
0.1328
commodity_rough_h015
1.919
-0.756
-2.6699
0.2656
[ 0.04, 0.00333, 0.01093, 0.00674, 0.00623, 0.00432, 0.00441, 0.012, 0.01579, 0.02082 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.8076, 0.4854, 0.3381, 0.2, 0.0711, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-COMM-0078 (H = 0.1328) H = 0.1328 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-SUB_-0079
0.2974
sub_diffusive_h030
1.561
-0.746
-1.1642
0.5948
[ 0.04, 0.03171, 0.02479, 0.01019, 0.01149, 0.0106, 0.00936, 0.00814, 0.02, 0.01535 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.4816, 0.3286, 0.2613, 0.2, 0.1448, 0.0958, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-SUB_-0079 (H = 0.2974) H = 0.2974 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-STAN-0080
0.4871
standard_markovian_h050
1.84
-0.886
-0.8507
0.9742
[ 0.04, 0.21923, 0.16503, 0.16696, 0.0478, 0.0217, 0.0846, 0.04524, 0.12585, 0.09562 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.4379, 0.302, 0.2468, 0.2, 0.1617, 0.1319, 0.0976 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-STAN-0080 (H = 0.4871) H = 0.4871 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-ULTR-0081
0.0366
ultra_rough_h005
1.732
-0.665
-3.1195
0.0732
[ 0.04, 0.00694, 0.00827, 0.00854, 0.01211, 0.00834, 0.01173, 0.01068, 0.0077, 0.00582 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.8839, 0.5269, 0.3597, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-ULTR-0081 (H = 0.0366) H = 0.0366 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-EQUI-0082
0.1191
equity_index_rough_h010
2.565
-0.775
-3.8592
0.2382
[ 0.04, 0.00195, 0.00507, 0.0245, 0.0202, 0.01722, 0.01298, 0.00351, 0.01013, 0.00541 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 1.1034, 0.6188, 0.4012, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-EQUI-0082 (H = 0.1191) H = 0.1191 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-COMM-0083
0.1644
commodity_rough_h015
1.713
-0.852
-2.3787
0.3288
[ 0.04, 0.00727, 0.00209, 0.00467, 0.00598, 0.01061, 0.00554, 0.00957, 0.02053, 0.01949 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.7344, 0.4525, 0.3226, 0.2, 0.0847, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-COMM-0083 (H = 0.1644) H = 0.1644 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-SUB_-0084
0.3227
sub_diffusive_h030
2.309
-0.653
-1.3784
0.6454
[ 0.04, 0.11404, 0.01326, 0.03655, 0.03795, 0.05113, 0.02318, 0.00527, 0.00929, 0.00184 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.5823, 0.3645, 0.2756, 0.2, 0.1377, 0.0888, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-SUB_-0084 (H = 0.3227) H = 0.3227 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-STAN-0085
0.4974
standard_markovian_h050
2.525
-0.743
-0.9461
0.9948
[ 0.04, 0.01346, 0.00567, 0.01717, 0.01452, 0.05225, 0.06792, 0.03271, 0.04078, 0.0173 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.5167, 0.3265, 0.2553, 0.2, 0.1607, 0.1373, 0.1383 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-STAN-0085 (H = 0.4974) H = 0.4974 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-ULTR-0086
0.0484
ultra_rough_h005
1.323
-0.732
-2.4977
0.0968
[ 0.04, 0.01747, 0.02319, 0.03064, 0.02455, 0.02135, 0.02402, 0.01632, 0.01837, 0.02102 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.7345, 0.4585, 0.3271, 0.2, 0.0773, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-ULTR-0086 (H = 0.0484) H = 0.0484 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-EQUI-0087
0.0894
equity_index_rough_h010
1.991
-0.671
-2.9171
0.1788
[ 0.04, 0.0101, 0.00805, 0.00853, 0.02109, 0.00839, 0.01233, 0.01405, 0.00819, 0.01669 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.8627, 0.5115, 0.3508, 0.2, 0.0591, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-EQUI-0087 (H = 0.0894) H = 0.0894 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-COMM-0088
0.1859
commodity_rough_h015
1.371
-0.705
-1.4522
0.3718
[ 0.04, 0.0267, 0.04413, 0.02062, 0.06072, 0.01967, 0.01621, 0.02075, 0.02657, 0.02404 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.528, 0.3546, 0.275, 0.2, 0.1297, 0.0642, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-COMM-0088 (H = 0.1859) H = 0.1859 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-SUB_-0089
0.2674
sub_diffusive_h030
1.778
-0.741
-1.4666
0.5348
[ 0.04, 0.02542, 0.01391, 0.01786, 0.01821, 0.04723, 0.03573, 0.07694, 0.04964, 0.07566 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.5565, 0.3625, 0.2773, 0.2, 0.1306, 0.0691, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-SUB_-0089 (H = 0.2674) H = 0.2674 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-STAN-0090
0.4897
standard_markovian_h050
2.105
-0.671
-0.7307
0.9794
[ 0.04, 0.0238, 0.20326, 0.3035, 1.17488, 0.20517, 0.16173, 0.03757, 0.02993, 0.02398 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.4348, 0.2952, 0.2421, 0.2, 0.169, 0.1491, 0.1425 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-STAN-0090 (H = 0.4897) H = 0.4897 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-ULTR-0091
0.0435
ultra_rough_h005
1.211
-0.73
-2.3267
0.087
[ 0.04, 0.02135, 0.02334, 0.02531, 0.02121, 0.01915, 0.02029, 0.01476, 0.0198, 0.02534 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.6947, 0.44, 0.3182, 0.2, 0.0855, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-ULTR-0091 (H = 0.0435) H = 0.0435 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-EQUI-0092
0.1127
equity_index_rough_h010
2.766
-0.775
-4.2675
0.2254
[ 0.04, 0.06699, 0.01662, 0.01278, 0.00374, 0.00194, 0.00242, 0.00556, 0.00367, 0.00286 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 1.2065, 0.665, 0.4229, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-EQUI-0092 (H = 0.1127) H = 0.1127 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-COMM-0093
0.1418
commodity_rough_h015
1.937
-0.823
-2.8333
0.2836
[ 0.04, 0.02035, 0.01625, 0.07233, 0.14936, 0.05256, 0.01272, 0.01378, 0.01747, 0.01038 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.8417, 0.5021, 0.3464, 0.2, 0.063, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-COMM-0093 (H = 0.1418) H = 0.1418 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-SUB_-0094
0.2862
sub_diffusive_h030
1.373
-0.681
-0.9729
0.5724
[ 0.04, 0.02016, 0.03425, 0.00551, 0.03713, 0.04369, 0.04193, 0.06933, 0.17983, 0.19898 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.4323, 0.3067, 0.251, 0.2, 0.1537, 0.1121, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-SUB_-0094 (H = 0.2862) H = 0.2862 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-STAN-0095
0.4955
standard_markovian_h050
2.485
-0.862
-1.0871
0.991
[ 0.04, 0.00124, 0.00025, 0.00101, 0.00087, 0.00044, 0.0011, 0.00061, 0.00057, 0.00032 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.5409, 0.3396, 0.2621, 0.2, 0.1534, 0.1222, 0.1061 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-STAN-0095 (H = 0.4955) H = 0.4955 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-ULTR-0096
0.0561
ultra_rough_h005
1.609
-0.809
-3.2525
0.1122
[ 0.04, 0.01408, 0.01729, 0.01761, 0.02582, 0.0283, 0.03277, 0.03003, 0.0169, 0.01641 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.9023, 0.5382, 0.3659, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-ULTR-0096 (H = 0.0561) H = 0.0561 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-EQUI-0097
0.0897
equity_index_rough_h010
2.392
-0.858
-4.476
0.1794
[ 0.04, 0.00809, 0.00239, 0.00154, 0.00118, 0.00369, 0.00732, 0.00476, 0.00891, 0.00636 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 1.2096, 0.6762, 0.431, 0.2, 0.05, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-EQUI-0097 (H = 0.0897) H = 0.0897 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-COMM-0098
0.1531
commodity_rough_h015
1.905
-0.686
-2.2239
0.3062
[ 0.04, 0.04972, 0.04353, 0.04176, 0.02733, 0.01138, 0.00642, 0.01158, 0.01142, 0.01043 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.7174, 0.4405, 0.3157, 0.2, 0.0933, 0.05, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-COMM-0098 (H = 0.1531) H = 0.1531 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-SUB_-0099
0.3434
sub_diffusive_h030
2.426
-0.736
-1.5181
0.6868
[ 0.04, 0.08626, 0.2701, 0.1516, 0.25888, 0.1821, 0.0493, 0.05615, 0.02048, 0.14051 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.6213, 0.3812, 0.2833, 0.2, 0.1315, 0.0776, 0.05 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-SUB_-0099 (H = 0.3434) H = 0.3434 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
RVOL-STAN-0100
0.4817
standard_markovian_h050
2.095
-0.774
-0.8614
0.9634
[ 0.04, 0.02601, 0.0053, 0.01009, 0.00131, 0.00164, 0.00207, 0.00456, 0.0101, 0.00711 ]
[ -0.2, -0.1, -0.05, 0, 0.05, 0.1, 0.2 ]
[ 0.4601, 0.3081, 0.2486, 0.2, 0.1624, 0.1358, 0.1155 ]
import numpy as np # Rough Volatility Scaling Verification for RVOL-STAN-0100 (H = 0.4817) H = 0.4817 T = 0.1 # Theoretical ATM skew power-law scaling: d(sigma_BS)/dk ~ T^(H - 0.5) expected_power = H - 0.5 print('Hurst parameter H:', H) print('ATM Skew Exponent (H - 0.5):', expected_power) assert expected_power <= 0.0,...
End of preview. Expand in Data Studio

Rough Volatility Fractional SDE Benchmarks

Dataset License Hub Type Hurst Calibrator Interactive Studio

πŸ“Œ Executive Summary

At1uri/rough-volatility-fractional-benchmarks is an institutional dataset and benchmark suite for evaluating neural calibrators, fractional differential equation solvers, and volatility surface modeling under Rough Volatility paradigms (Gatheral, Jaisson & Rosenbaum, 2018; Bayer, Friz & Gatheral, 2016).

Classical Markovian stochastic volatility models (Heston, SABR, standard Bergomi) assume that log-volatility behaves like a standard Brownian motion with Hurst exponent $H = 1/2$. However, extensive empirical high-frequency tick data across global equity indices, foreign exchange, and commodity markets overwhelmingly demonstrates that financial volatility is rough, exhibiting a Hurst parameter $H \in (0, 1/2)$, typically $H \approx 0.10$.

This roughness drives the celebrated explosive short-dated at-the-money (ATM) volatility skew:

ψ(T)=βˆ‚ΟƒBS(k,T)βˆ‚k∣k=0∝THβˆ’1/2\psi(T) = \left. \frac{\partial \sigma_{\text{BS}}(k, T)}{\partial k} \right|_{k=0} \propto T^{H - 1/2}

As $T \to 0$, classical diffusion models predict flat skews ($\lim_{T \to 0} \psi(T) = \text{const}$), whereas rough volatility models capture the true empirical power-law blowup with singularity $T^{-0.40}$.

This benchmark provides 1,000 continuous Volterra rough SDE trajectory instances across five distinct Hurst regimes, complete with exact forward variance paths, implied volatility smile profiles, variogram scaling exponents, and executable verification scripts.


πŸ”¬ Benchmark Taxonomy & Hurst Regimes

Regime Hurst Exponent $H$ Target Asset Class ATM Skew Slope ($T = 0.1$) HΓΆlder Regularity
Ultra-Rough Regime $H \in [0.03, 0.07]$ Ultra-high frequency equities, crypto liquidity pools $\psi(T) \sim T^{-0.45}$ (Extreme) $\alpha < 0.07$
Equity Index Rough $H \in [0.08, 0.12]$ S&P 500, NASDAQ-100, Euro Stoxx 50 empirical consensus $\psi(T) \sim T^{-0.40}$ (Gatheral) $\alpha \approx 0.10$
Commodity Rough $H \in [0.13, 0.20]$ Crude Oil (WTI/Brent), Natural Gas, Gold futures $\psi(T) \sim T^{-0.35}$ $\alpha \approx 0.16$
Sub-Diffusive Regime $H \in [0.25, 0.35]$ Mildly rough macro rates, long-dated foreign exchange $\psi(T) \sim T^{-0.20}$ $\alpha \approx 0.30$
Standard Markovian $H = 0.50$ Classical Brownian motion baseline (Standard Bergomi) $\psi(T) \sim \mathcal{O}(1)$ (Flat limit) $\alpha = 0.50$

πŸ“Š Dataset Schema

Each sample in train.parquet (800 rows) and test.parquet (200 rows) contains the following fields:

{
    "benchmark_id": "RVOL-ULTR-0001",                    # Unique benchmark identifier
    "hurst_parameter": 0.0624,                           # True Hurst exponent H in (0, 0.50]
    "h_regime": "ultra_rough_h005",                      # Qualitative regime descriptor
    "nu_vol_of_vol": 2.15,                               # Volatility of volatility parameter nu
    "rho_correlation": -0.84,                            # Spot-vol correlation coefficient rho
    "atm_skew_slope": -3.842,                            # At-the-money skew slope d(sigma)/dk at T=0.1
    "variogram_scaling_exponent": 0.1248,                # E[|v_{t+dt} - v_t|^2] ~ dt^{2H}
    "sample_fbm_variance_trajectory": [0.04, 0.042, ...],# Discretized forward variance path v_t
    "sample_iv_smile_strikes": [-0.2, -0.1, 0.0, ...],   # Log-moneyness grid k = log(K / S0)
    "sample_iv_smile_vols": [0.384, 0.282, 0.201, ...],  # Implied Black-Scholes volatilities
    "verification_code": "import numpy as np..."         # Executable verification code
}

πŸš€ Quickstart & Usage

from datasets import load_dataset
import numpy as np

# Load benchmark dataset
ds = load_dataset("At1uri/rough-volatility-fractional-benchmarks")

print(f"Train split: {len(ds['train'])} samples")
print(f"Test split:  {len(ds['test'])} samples")

sample = ds["train"][0]
print(f"Benchmark: {sample['benchmark_id']} (Regime: {sample['h_regime']})")
print(f"Hurst Parameter H: {sample['hurst_parameter']}")
print(f"ATM Skew Slope:    {sample['atm_skew_slope']}")

πŸ”— Integrated Ecosystem


πŸ“œ Citation

@dataset{atluri2026roughvol,
  author       = {Atluri, Ramprasad},
  title        = {Rough Volatility Fractional SDE Benchmarks},
  year         = {2026},
  publisher    = {Hugging Face},
  howpublished = {\url{https://huggingface.co/datasets/At1uri/rough-volatility-fractional-benchmarks}}
}
Downloads last month
18

Space using At1uri/rough-volatility-fractional-benchmarks 1

Collection including At1uri/rough-volatility-fractional-benchmarks