diff --git a/MyIA.AI.Notebooks/IIT/ICT-Series/ict/results/stv_valence_symmetry_v2_calibration.json b/MyIA.AI.Notebooks/IIT/ICT-Series/ict/results/stv_valence_symmetry_v2_calibration.json new file mode 100644 index 00000000000..808d01a8168 --- /dev/null +++ b/MyIA.AI.Notebooks/IIT/ICT-Series/ict/results/stv_valence_symmetry_v2_calibration.json @@ -0,0 +1,62 @@ +{ + "k2_coupling": 48.0, + "source": "fenetre v(u=1) scellee", + "v_u1_median": 0.75, + "v_variance": null, + "trace": [ + { + "k2": 4.0, + "v_u1_median": 0.08928571428571427, + "n_exact": 4, + "v_variance_mean": 0.001545670351473923 + }, + { + "k2": 8.0, + "v_u1_median": 0.017857142857142856, + "n_exact": 4, + "v_variance_mean": 0.0003912155139833711 + }, + { + "k2": 16.0, + "v_u1_median": 0.0, + "n_exact": 4, + "v_variance_mean": 0.0001557480631141345 + }, + { + "k2": 24.0, + "v_u1_median": 0.10714285714285714, + "n_exact": 4, + "v_variance_mean": 0.006593088624338624 + }, + { + "k2": 32.0, + "v_u1_median": 0.35714285714285715, + "n_exact": 4, + "v_variance_mean": 0.00881194491685563 + }, + { + "k2": 48.0, + "v_u1_median": 0.75, + "n_exact": 4, + "v_variance_mean": 0.009858630952380954 + }, + { + "k2": 64.0, + "v_u1_median": 1.0, + "n_exact": 4, + "v_variance_mean": 0.0 + }, + { + "k2": 96.0, + "v_u1_median": 1.0, + "n_exact": 4, + "v_variance_mean": 0.0 + }, + { + "k2": 128.0, + "v_u1_median": 1.0, + "n_exact": 4, + "v_variance_mean": 0.0 + } + ] +} diff --git a/MyIA.AI.Notebooks/IIT/ICT-Series/ict/results/stv_valence_symmetry_v2_results.json b/MyIA.AI.Notebooks/IIT/ICT-Series/ict/results/stv_valence_symmetry_v2_results.json new file mode 100644 index 00000000000..284402e1d64 --- /dev/null +++ b/MyIA.AI.Notebooks/IIT/ICT-Series/ict/results/stv_valence_symmetry_v2_results.json @@ -0,0 +1,2023 @@ +{ + "case": "17bis-stv-v2-lock-structure", + "k2_coupling": 48.0, + "seeds": [ + 0, + 1, + 7, + 42, + 99 + ], + "m_configs": 120, + "per_seed": [ + { + "seed": 0, + "rho1": 0.4205083686367108, + "rho_eps_partial": 0.7139185325882231, + "dS": 0.0, + "s_h": 0.0, + "s_n": 0.0, + "excl_h": 0, + "excl_n": 0, + "r_bar_h": 0.8594313901223745, + "r_bar_n": 0.7500813705723652, + "v_u1_median": 0.75, + "v_u0_median": 0.6428571428571428, + "v_ladder": [ + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.75, + 0.75 + ], + "sigma_ladder": [ + 0.4288739432350485, + 0.9999999999999989, + 0.3943570109647017, + 0.49462573840268015, + 0.5575107742969521, + 0.4850380692276963, + 0.3413467263559105, + 0.29852397492045857, + 0.2892848820445341, + 0.9999999999999989, + 0.5889437219947415, + 0.4166646425434258, + 0.25022376996153184, + 0.5872761827193286, + 0.3460636682986373, + 0.39023103387007646, + 0.3944320821255283, + 0.6783503477403533, + 0.27454036067825344, + 0.5218725530823206, + 0.5161021078454434, + 0.240013323476513, + 0.9999999999999989, + 0.5474547191378123, + 0.4105137708563946, + 0.6159181589383816, + 0.29715274187082097, + 0.430051695526761, + 0.8162447175501131, + 0.36709779126368797, + 0.49591345882742566, + 0.3848873893336585, + 0.2858622638226472, + 0.4532728822275442, + 0.3746952838459899, + 0.42889919900861095, + 0.4572752594753618, + 0.9999999999999989, + 0.9999999999999989, + 0.31631072961352136, + 0.4954073753001022, + 0.29924490264448644, + 0.31030258409342265, + 0.9999999999999989, + 0.45793970381092797, + 0.4064166972385336, + 0.5785653616458715, + 0.9999999999999989, + 0.9999999999999989, + 0.5383816761644339, + 0.3649941391684314, + 0.4727860315868512, + 0.41734690786938666, + 0.43840684722448, + 0.29266497576428546, + 0.39963835073303594, + 0.3413551429583012, + 0.9999999999999989, + 0.5390256476357226, + 0.5203413974296629, + 0.26204418221493725, + 0.3807846921421771, + 0.3430412061254195, + 0.4935503877822181, + 0.42389072416291906, + 0.8187529151399529, + 0.7905011430791348, + 0.2881368824330123, + 0.39106143243594127, + 0.7731223084759531, + 0.26138750315675036, + 0.8207535813065977, + 0.9999999999999989, + 0.6225098956834534, + 0.5306683669960389, + 0.2638778969236208, + 0.4767079630950937, + 0.315138823169074, + 0.2958786435625084, + 0.2987439482866104, + 0.7993878708886445, + 0.9999999999999989, + 0.5971130598320958, + 0.9999999999999989, + 0.7848907616607502, + 0.7848903791371554, + 0.5256018272297142, + 0.606983833479058, + 0.4892948243758139, + 0.38756749324234996, + 0.5346585982928076, + 0.3330712194240353, + 0.9999999999999989, + 0.30826792352526533, + 0.9999999999999989, + 0.2482866778788597, + 0.48806754925368345, + 0.9999999999999989, + 0.48766649863925304, + 0.9999999999999989, + 0.41257404274721976, + 0.33937177241195887, + 0.6297515894512614, + 0.6145211023645237, + 0.8052106980553791, + 0.5886313357137762, + 0.2565651768975669, + 0.4281746012977286, + 0.5231383831485339, + 0.3783016069250104, + 0.31521982574470353, + 0.7922025272871298, + 0.3276871530709563, + 0.2774108604137568, + 0.5354589821073198, + 0.39987002359715357, + 0.31576542916692424, + 0.9999999999999989, + 0.7729389186695567, + 0.8027334799388495 + ], + "u_ladder": [ + 0.5, + 1.0, + 0.25, + 0.625, + 0.625, + 0.625, + 0.125, + 0.25, + 0.25, + 1.0, + 0.75, + 0.5, + 0.25, + 0.75, + 0.5, + 0.25, + 0.5, + 0.75, + 0.375, + 0.625, + 0.625, + 0.125, + 1.0, + 0.625, + 0.5, + 0.75, + 0.25, + 0.5, + 0.875, + 0.125, + 0.625, + 0.25, + 0.25, + 0.5, + 0.5, + 0.375, + 0.5, + 1.0, + 1.0, + 0.125, + 0.375, + 0.375, + 0.25, + 1.0, + 0.125, + 0.5, + 0.75, + 1.0, + 1.0, + 0.625, + 0.5, + 0.625, + 0.375, + 0.375, + 0.25, + 0.125, + 0.25, + 1.0, + 0.125, + 0.625, + 0.25, + 0.5, + 0.375, + 0.625, + 0.5, + 0.875, + 0.875, + 0.25, + 0.5, + 0.875, + 0.125, + 0.875, + 1.0, + 0.75, + 0.625, + 0.375, + 0.625, + 0.375, + 0.125, + 0.375, + 0.875, + 1.0, + 0.75, + 1.0, + 0.875, + 0.875, + 0.625, + 0.75, + 0.625, + 0.5, + 0.625, + 0.125, + 1.0, + 0.375, + 1.0, + 0.25, + 0.625, + 1.0, + 0.125, + 1.0, + 0.5, + 0.25, + 0.75, + 0.75, + 0.875, + 0.75, + 0.125, + 0.125, + 0.625, + 0.5, + 0.25, + 0.875, + 0.375, + 0.25, + 0.625, + 0.5, + 0.125, + 1.0, + 0.875, + 0.875 + ], + "m": 40 + }, + { + "seed": 1, + "rho1": 0.3607819987499131, + "rho_eps_partial": 0.7647305088104281, + "dS": 0.0, + "s_h": 0.0, + "s_n": 0.0, + "excl_h": 0, + "excl_n": 0, + "r_bar_h": 0.8594242519727976, + "r_bar_n": 0.9999429799567114, + "v_u1_median": 0.75, + "v_u0_median": 0.5357142857142857, + "v_ladder": [ + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.5357142857142857, + 0.75, + 0.5357142857142857, + 0.75, + 0.5357142857142857, + 0.75, + 0.5357142857142857, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75 + ], + "sigma_ladder": [ + 0.48505225459618917, + 0.5032266178327809, + 0.6282245504918025, + 0.5111480846221322, + 0.61505647509075, + 0.405096279777666, + 0.6013477630557588, + 0.7957906261102623, + 0.3622005495681343, + 0.3964166083469855, + 0.45804588257021006, + 0.7689780517496915, + 0.32006869757109385, + 0.9999999999999989, + 0.5323628170048583, + 0.6117758936479442, + 0.46476865138623236, + 0.7954293146621901, + 0.2926809838321022, + 0.31066093068656714, + 0.32988805451315345, + 0.9999999999999989, + 0.4852356453895818, + 0.6045622678677854, + 0.4662395677240025, + 0.3382570152853323, + 0.8299886054026094, + 0.43594608356877373, + 0.33477943316590947, + 0.32906757273876763, + 0.6023064741466879, + 0.6140407820444729, + 0.9999999999999989, + 0.41438683892729195, + 0.5873286788375418, + 0.32233344715292855, + 0.8067538286830447, + 0.447788768676583, + 0.9999999999999989, + 0.4977689433559488, + 0.7933406992623926, + 0.3059360650318733, + 0.9999999999999989, + 0.37731507996957514, + 0.38786188881271233, + 0.9999999999999989, + 0.3505275829026206, + 0.4096863421488455, + 0.40513774441392975, + 0.9999999999999989, + 0.9999999999999989, + 0.3340548353923665, + 0.3333823535884203, + 0.36661875795205595, + 0.3850586687583869, + 0.9999999999999989, + 0.4736731832685992, + 0.44264282335599037, + 0.47832186476211314, + 0.3478357678742548, + 0.8099180509543961, + 0.7956509315207796, + 0.4571405952747, + 0.9999999999999989, + 0.6363094702496255, + 0.24682202636681164, + 0.38209521100224675, + 0.49491986185550735, + 0.490321630987235, + 0.6247108577341295, + 0.386352284766749, + 0.9999999999999989, + 0.6242918268056125, + 0.9999999999999989, + 0.3107144934943005, + 0.6380552422133627, + 0.7877452481462104, + 0.4278362173479865, + 0.347355308716464, + 0.3841410192373919, + 0.2572051925134838, + 0.30322835633315154, + 0.3919034024377473, + 0.8136524201294071, + 0.4884429692595265, + 0.7901587845746328, + 0.361026557898405, + 0.266808491650748, + 0.9999999999999989, + 0.9999999999999989, + 0.3519819220126548, + 0.33366957490319443, + 0.5930408094818157, + 0.9999999999999989, + 0.5446789088158385, + 0.33922581740779856, + 0.4313362270174821, + 0.6028300673069745, + 0.9999999999999989, + 0.3378902621494418, + 0.31852292156585715, + 0.9999999999999989, + 0.9999999999999989, + 0.6992863338404928, + 0.9999999999999989, + 0.3813752218335903, + 0.3432266898087745, + 0.9999999999999989, + 0.3077127475673308, + 0.9999999999999989, + 0.5320401985777546, + 0.9999999999999989, + 0.772276936152534, + 0.9999999999999989, + 0.5834872591357397, + 0.826285927489642, + 0.7766544899210908, + 0.6146819096056937, + 0.24660849678074562, + 0.5458265045292806 + ], + "u_ladder": [ + 0.625, + 0.625, + 0.75, + 0.625, + 0.75, + 0.375, + 0.75, + 0.875, + 0.375, + 0.375, + 0.5, + 0.875, + 0.375, + 1.0, + 0.625, + 0.75, + 0.625, + 0.875, + 0.25, + 0.125, + 0.375, + 1.0, + 0.125, + 0.75, + 0.25, + 0.125, + 0.875, + 0.5, + 0.5, + 0.375, + 0.75, + 0.75, + 1.0, + 0.5, + 0.75, + 0.375, + 0.875, + 0.25, + 1.0, + 0.625, + 0.875, + 0.125, + 1.0, + 0.375, + 0.375, + 1.0, + 0.375, + 0.375, + 0.25, + 1.0, + 1.0, + 0.375, + 0.375, + 0.125, + 0.375, + 1.0, + 0.125, + 0.375, + 0.625, + 0.125, + 0.875, + 0.875, + 0.5, + 1.0, + 0.75, + 0.25, + 0.375, + 0.625, + 0.625, + 0.75, + 0.375, + 1.0, + 0.75, + 1.0, + 0.25, + 0.75, + 0.875, + 0.5, + 0.375, + 0.5, + 0.25, + 0.375, + 0.25, + 0.875, + 0.625, + 0.875, + 0.25, + 0.125, + 1.0, + 1.0, + 0.5, + 0.25, + 0.75, + 1.0, + 0.625, + 0.375, + 0.625, + 0.75, + 1.0, + 0.25, + 0.125, + 1.0, + 1.0, + 0.75, + 1.0, + 0.375, + 0.375, + 1.0, + 0.25, + 1.0, + 0.625, + 1.0, + 0.875, + 1.0, + 0.75, + 0.875, + 0.875, + 0.75, + 0.125, + 0.625 + ], + "m": 40 + }, + { + "seed": 7, + "rho1": 0.3073199527744982, + "rho_eps_partial": 0.7811638644448495, + "dS": 0.0, + "s_h": 0.0, + "s_n": 0.0, + "excl_h": 0, + "excl_n": 0, + "r_bar_h": 0.8594287101441209, + "r_bar_n": 0.999935600133097, + "v_u1_median": 0.75, + "v_u0_median": 0.5357142857142857, + "v_ladder": [ + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.5357142857142857, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75 + ], + "sigma_ladder": [ + 0.635128332767633, + 0.29778933672513885, + 0.275750939801987, + 0.3298693985840334, + 0.5241032154648894, + 0.8262576711272406, + 0.26197789721768666, + 0.4692793625494776, + 0.9999999999999989, + 0.37734710568737084, + 0.3688386700516825, + 0.48954599584532904, + 0.9999999999999989, + 0.4303019423402899, + 0.4580846688043852, + 0.3804851218761232, + 0.3959138212202932, + 0.79363365610116, + 0.9999999999999989, + 0.42766105453337744, + 0.9999999999999989, + 0.8260100587755346, + 0.6270470713168518, + 0.6203909550052223, + 0.43204809611252015, + 0.3847434830698348, + 0.5367089889882968, + 0.36911265137407767, + 0.3735079253509129, + 0.33808097593847763, + 0.37001348841197146, + 0.46913522426128784, + 0.3071753877395399, + 0.38797984975969213, + 0.5196682978160051, + 0.7739516337954102, + 0.9999999999999989, + 0.3631615353430475, + 0.410948500646787, + 0.9999999999999989, + 0.9999999999999989, + 0.42702073197300144, + 0.3801023208850105, + 0.9999999999999989, + 0.8151666470736805, + 0.6222551080994313, + 0.47149880190401794, + 0.35210754716612225, + 0.4749837066165317, + 0.591380279148653, + 0.39113464975696427, + 0.4044895304799852, + 0.6192148237626126, + 0.34497812722065413, + 0.9999999999999989, + 0.6107116240081938, + 0.6245807800125942, + 0.6410363556139232, + 0.4815506502586504, + 0.5129235624939025, + 0.4185224344620347, + 0.9999999999999989, + 0.8362349373621233, + 0.5346623074714377, + 0.6230665245092268, + 0.3064182611433273, + 0.36738980232704815, + 0.9999999999999989, + 0.4695521290549217, + 0.9999999999999989, + 0.4156463990291093, + 0.32007897804210284, + 0.9999999999999989, + 0.3493360525352013, + 0.2648391892427479, + 0.7859276435271935, + 0.9999999999999989, + 0.388604916407696, + 0.35111323581035153, + 0.9999999999999989, + 0.6586790327476747, + 0.5104414363444644, + 0.3812013102636934, + 0.2287411158668217, + 0.3252604567543679, + 0.3711810921632148, + 0.36174639784992557, + 0.36333531884720144, + 0.9999999999999989, + 0.42399424009614656, + 0.5080937109822143, + 0.3066566063438471, + 0.4096470165188829, + 0.34549266899634373, + 0.27606887951575393, + 0.3624031066758916, + 0.5228803146934997, + 0.5011909490113888, + 0.8017923468381387, + 0.5685959137501299, + 0.36561095948278804, + 0.3822564228901405, + 0.6294241868605617, + 0.449003895717417, + 0.3571644552394971, + 0.4601146058514837, + 0.9999999999999989, + 0.40188326098843946, + 0.37969274947306003, + 0.3368616188596883, + 0.4194715605304533, + 0.2842733389048559, + 0.3527501200398443, + 0.3747257312594258, + 0.9999999999999989, + 0.3100713048108924, + 0.3813904157322439, + 0.3176009796462168, + 0.5055278067070638, + 0.814685557550424 + ], + "u_ladder": [ + 0.75, + 0.25, + 0.125, + 0.25, + 0.125, + 0.875, + 0.25, + 0.125, + 1.0, + 0.5, + 0.375, + 0.625, + 1.0, + 0.5, + 0.625, + 0.375, + 0.5, + 0.875, + 1.0, + 0.125, + 1.0, + 0.875, + 0.75, + 0.75, + 0.5, + 0.375, + 0.625, + 0.375, + 0.25, + 0.125, + 0.25, + 0.125, + 0.125, + 0.375, + 0.625, + 0.875, + 1.0, + 0.375, + 0.5, + 1.0, + 1.0, + 0.5, + 0.5, + 1.0, + 0.875, + 0.75, + 0.625, + 0.125, + 0.625, + 0.75, + 0.5, + 0.5, + 0.75, + 0.25, + 1.0, + 0.75, + 0.75, + 0.75, + 0.125, + 0.625, + 0.5, + 1.0, + 0.875, + 0.625, + 0.75, + 0.25, + 0.125, + 1.0, + 0.625, + 1.0, + 0.5, + 0.25, + 1.0, + 0.375, + 0.375, + 0.875, + 1.0, + 0.5, + 0.25, + 1.0, + 0.75, + 0.625, + 0.125, + 0.125, + 0.25, + 0.5, + 0.25, + 0.375, + 1.0, + 0.125, + 0.625, + 0.375, + 0.25, + 0.375, + 0.375, + 0.375, + 0.625, + 0.625, + 0.875, + 0.625, + 0.5, + 0.125, + 0.75, + 0.625, + 0.125, + 0.625, + 1.0, + 0.375, + 0.25, + 0.25, + 0.5, + 0.25, + 0.125, + 0.5, + 1.0, + 0.25, + 0.375, + 0.375, + 0.625, + 0.875 + ], + "m": 40 + }, + { + "seed": 42, + "rho1": 0.3713799569414542, + "rho_eps_partial": 0.7678029326937686, + "dS": 0.0, + "s_h": 0.0, + "s_n": 0.0, + "excl_h": 0, + "excl_n": 0, + "r_bar_h": 0.8594357373541688, + "r_bar_n": 0.9999314467802236, + "v_u1_median": 0.75, + "v_u0_median": 0.5357142857142857, + "v_ladder": [ + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75 + ], + "sigma_ladder": [ + 0.633866530102696, + 0.799601847175094, + 0.9999999999999989, + 0.6403176827024347, + 0.33565985950215, + 0.9999999999999989, + 0.4331044607292366, + 0.3889787628363302, + 0.34143704074083037, + 0.788295294804846, + 0.5547034224484096, + 0.2778883772217732, + 0.9999999999999989, + 0.7830325911143128, + 0.35104961920103367, + 0.3458710206759636, + 0.5022697984023355, + 0.5295323451572326, + 0.4566094135533267, + 0.39706051692417665, + 0.43709675293324723, + 0.319841020311524, + 0.8184166772121519, + 0.3277543033644454, + 0.7856534845710801, + 0.5240266464697163, + 0.9999999999999989, + 0.6055152797145034, + 0.8358838465949691, + 0.386328317417525, + 0.2790231869331173, + 0.4458651488522204, + 0.4381194520418033, + 0.6336778620365886, + 0.42975543607609007, + 0.3920797127610007, + 0.4514177899743069, + 0.9999999999999989, + 0.31491931234954074, + 0.6025657971153695, + 0.3081053869084714, + 0.8195441441386088, + 0.9999999999999989, + 0.9999999999999989, + 0.41417479587499273, + 0.4365725940428719, + 0.3821276258565734, + 0.34301013105908856, + 0.9999999999999989, + 0.5130671638187544, + 0.6063642773011855, + 0.8054306794141424, + 0.6102711463502876, + 0.272621200299246, + 0.9999999999999989, + 0.4336251778391551, + 0.44294490525990365, + 0.48498222031673277, + 0.9999999999999989, + 0.7901079470929998, + 0.37537351420240705, + 0.7949192231074679, + 0.25749456826110767, + 0.3140025421422997, + 0.31623964632553675, + 0.6334110611126121, + 0.2639831503162346, + 0.3815096935298962, + 0.6103810573426409, + 0.6790111402102428, + 0.3509621979793766, + 0.6689275690691482, + 0.40918521003329705, + 0.4365372863163865, + 0.3400012408320398, + 0.45210013376208324, + 0.5433072294587036, + 0.6281843108114616, + 0.28359674587910555, + 0.35036324204895214, + 0.29438704912782715, + 0.34323018557291246, + 0.9999999999999989, + 0.4039018660367992, + 0.42223098797455527, + 0.6467049481194032, + 0.27150855265350143, + 0.3133555006603742, + 0.35444570211757886, + 0.45128350948697754, + 0.6429933213639598, + 0.6482800348954861, + 0.34533938583136053, + 0.28789315835353685, + 0.42557191385275966, + 0.6200977321711639, + 0.4868808800996674, + 0.2796305091715873, + 0.44473106516060523, + 0.9999999999999989, + 0.3470480298775521, + 0.4467031593273259, + 0.9999999999999989, + 0.33336522140523916, + 0.27695448875767703, + 0.9999999999999989, + 0.334744197615456, + 0.9999999999999989, + 0.6503894620460702, + 0.3476103155328133, + 0.3066406524803011, + 0.3309557399908269, + 0.7815188077173485, + 0.4215725259699677, + 0.8026742970066418, + 0.9999999999999989, + 0.35997600929684176, + 0.3017515867478107, + 0.9999999999999989, + 0.4187285818925327 + ], + "u_ladder": [ + 0.75, + 0.875, + 1.0, + 0.75, + 0.375, + 1.0, + 0.5, + 0.5, + 0.375, + 0.875, + 0.625, + 0.25, + 1.0, + 0.875, + 0.5, + 0.25, + 0.625, + 0.625, + 0.625, + 0.25, + 0.375, + 0.25, + 0.875, + 0.375, + 0.875, + 0.625, + 1.0, + 0.75, + 0.875, + 0.125, + 0.125, + 0.25, + 0.5, + 0.75, + 0.5, + 0.125, + 0.5, + 1.0, + 0.25, + 0.75, + 0.125, + 0.875, + 1.0, + 1.0, + 0.375, + 0.5, + 0.25, + 0.375, + 1.0, + 0.625, + 0.75, + 0.875, + 0.75, + 0.125, + 1.0, + 0.625, + 0.125, + 0.625, + 1.0, + 0.875, + 0.125, + 0.875, + 0.125, + 0.375, + 0.125, + 0.75, + 0.125, + 0.5, + 0.75, + 0.75, + 0.375, + 0.75, + 0.125, + 0.25, + 0.125, + 0.375, + 0.25, + 0.75, + 0.375, + 0.5, + 0.125, + 0.375, + 1.0, + 0.5, + 0.5, + 0.75, + 0.25, + 0.375, + 0.375, + 0.625, + 0.75, + 0.75, + 0.125, + 0.25, + 0.5, + 0.75, + 0.125, + 0.25, + 0.25, + 1.0, + 0.125, + 0.625, + 1.0, + 0.25, + 0.125, + 1.0, + 0.375, + 1.0, + 0.75, + 0.5, + 0.25, + 0.125, + 0.875, + 0.5, + 0.875, + 1.0, + 0.125, + 0.25, + 1.0, + 0.25 + ], + "m": 40 + }, + { + "seed": 99, + "rho1": 0.3119313841238974, + "rho_eps_partial": 0.7432461504342116, + "dS": 0.0, + "s_h": 0.0, + "s_n": 0.0, + "excl_h": 0, + "excl_n": 0, + "r_bar_h": 0.8594325150730867, + "r_bar_n": 0.9999313351490426, + "v_u1_median": 0.75, + "v_u0_median": 0.5357142857142857, + "v_ladder": [ + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.5357142857142857, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.5357142857142857, + 0.75, + 0.5357142857142857, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.75, + 0.5357142857142857, + 0.5357142857142857 + ], + "sigma_ladder": [ + 0.62059848082065, + 0.6153159945987906, + 0.9999999999999989, + 0.3804842860495738, + 0.9999999999999989, + 0.9999999999999989, + 0.6184021394413298, + 0.45770930214996886, + 0.7874437936900608, + 0.269794125206906, + 0.9999999999999989, + 0.4253292369054056, + 0.24276977292472052, + 0.3752237084444303, + 0.46205028440097495, + 0.605699932375175, + 0.5189143517520725, + 0.633244037232547, + 0.8048989893034338, + 0.9999999999999989, + 0.9999999999999989, + 0.300091566659224, + 0.39568079931642347, + 0.32031645607777864, + 0.2649055749667721, + 0.26977410735471213, + 0.378338777266829, + 0.4587469645599964, + 0.7947705523516314, + 0.6257641941652353, + 0.9999999999999989, + 0.34932569396809593, + 0.6263181306740445, + 0.30015732560693964, + 0.6297769913339445, + 0.29471223962730353, + 0.47967939007708266, + 0.9999999999999989, + 0.8391689379506696, + 0.2552249841801781, + 0.29057672970602677, + 0.531981061683856, + 0.3227637940698189, + 0.3511690443044938, + 0.6178154352999355, + 0.2814382759542312, + 0.5320677412788334, + 0.2578773761623019, + 0.4549375289754917, + 0.5109741754875127, + 0.7994281924499849, + 0.8391032883186004, + 0.30631307557580667, + 0.7988809299678651, + 0.3502836680835912, + 0.28989999965938396, + 0.3532593043494631, + 0.9999999999999989, + 0.9999999999999989, + 0.9999999999999989, + 0.39026512534604396, + 0.4335333249897099, + 0.2741175465805527, + 0.3701681631165327, + 0.4862799199776278, + 0.4509691102302843, + 0.9999999999999989, + 0.33518284790853287, + 0.9999999999999989, + 0.3957762060836138, + 0.6539330766272149, + 0.7870076817080042, + 0.5530928978651387, + 0.4334191685116337, + 0.23698570779659375, + 0.544969865452223, + 0.6164910268807081, + 0.4067881530335037, + 0.5268415467003259, + 0.33906895411867577, + 0.31814217244705756, + 0.31039472152071135, + 0.6230836303627661, + 0.3190427680703208, + 0.24868341044607667, + 0.40348653433906767, + 0.9999999999999989, + 0.9999999999999989, + 0.4315615904935671, + 0.8078681288448885, + 0.802668638582449, + 0.41973945586053485, + 0.3455802173665585, + 0.3939236016650152, + 0.33744709288676206, + 0.49793106355368544, + 0.37033214612396875, + 0.3031353526976823, + 0.46980141584174684, + 0.40688402897613324, + 0.5212547076400911, + 0.3656415362618935, + 0.2981209239967365, + 0.5146859787861541, + 0.36005075369541745, + 0.41428379975294455, + 0.3535019398109305, + 0.5321215024289654, + 0.8014285191970228, + 0.9999999999999989, + 0.3537889722946059, + 0.5140663556264673, + 0.31188126322773113, + 0.9999999999999989, + 0.3959774797712615, + 0.6296081803832164, + 0.637159724396109, + 0.4004031607258674, + 0.6122727976297344, + 0.3308675371434145 + ], + "u_ladder": [ + 0.75, + 0.75, + 1.0, + 0.375, + 1.0, + 1.0, + 0.75, + 0.5, + 0.875, + 0.25, + 1.0, + 0.5, + 0.25, + 0.5, + 0.5, + 0.75, + 0.125, + 0.75, + 0.875, + 1.0, + 1.0, + 0.375, + 0.125, + 0.125, + 0.25, + 0.125, + 0.5, + 0.25, + 0.875, + 0.75, + 1.0, + 0.25, + 0.75, + 0.375, + 0.75, + 0.125, + 0.625, + 1.0, + 0.875, + 0.25, + 0.375, + 0.625, + 0.375, + 0.375, + 0.75, + 0.375, + 0.625, + 0.25, + 0.5, + 0.625, + 0.875, + 0.875, + 0.25, + 0.875, + 0.25, + 0.125, + 0.5, + 1.0, + 1.0, + 1.0, + 0.125, + 0.375, + 0.25, + 0.5, + 0.125, + 0.5, + 1.0, + 0.125, + 1.0, + 0.5, + 0.75, + 0.875, + 0.625, + 0.625, + 0.25, + 0.625, + 0.75, + 0.5, + 0.625, + 0.5, + 0.25, + 0.375, + 0.75, + 0.375, + 0.25, + 0.5, + 1.0, + 1.0, + 0.5, + 0.875, + 0.875, + 0.125, + 0.125, + 0.5, + 0.25, + 0.25, + 0.375, + 0.125, + 0.625, + 0.125, + 0.625, + 0.125, + 0.375, + 0.625, + 0.5, + 0.375, + 0.125, + 0.625, + 0.875, + 1.0, + 0.375, + 0.625, + 0.375, + 1.0, + 0.5, + 0.75, + 0.75, + 0.5, + 0.75, + 0.25 + ], + "m": 40 + } + ], + "rho1_by_seed": [ + 0.4205083686367108, + 0.3607819987499131, + 0.3073199527744982, + 0.3713799569414542, + 0.3119313841238974 + ], + "rho_eps_by_seed": [ + 0.7139185325882231, + 0.7647305088104281, + 0.7811638644448495, + 0.7678029326937686, + 0.7432461504342116 + ], + "dS_by_seed": [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + "r_bar_h_by_seed": [ + 0.8594313901223745, + 0.8594242519727976, + 0.8594287101441209, + 0.8594357373541688, + 0.8594325150730867 + ], + "r_bar_n_by_seed": [ + 0.7500813705723652, + 0.9999429799567114, + 0.999935600133097, + 0.9999314467802236, + 0.9999313351490426 + ], + "v_u1_by_seed": [ + 0.75, + 0.75, + 0.75, + 0.75, + 0.75 + ], + "v_u0_by_seed": [ + 0.6428571428571428, + 0.5357142857142857, + 0.5357142857142857, + 0.5357142857142857, + 0.5357142857142857 + ], + "null_a_median_abs_rho": 0.060667407458851304, + "null_a3_median_abs_dS": 0.0, + "null_b_abs_rho": 0.11285505937912353, + "ctrl_mechanical": [ + { + "seed": 0, + "v0_irr_mean": 0.005952380952380952, + "v0_exact_mean": 0.6785714285714286 + }, + { + "seed": 1, + "v0_irr_mean": 0.017857142857142856, + "v0_exact_mean": 0.6785714285714286 + }, + { + "seed": 7, + "v0_irr_mean": 0.0, + "v0_exact_mean": 0.6785714285714286 + }, + { + "seed": 42, + "v0_irr_mean": 0.0, + "v0_exact_mean": 0.6785714285714286 + }, + { + "seed": 99, + "v0_irr_mean": 0.005952380952380952, + "v0_exact_mean": 0.6785714285714286 + } + ], + "p1": false, + "p2": false, + "p3": false, + "gates": { + "floor_v_u1": false, + "ceiling_v_u0": false, + "match_r_bar": false + }, + "triggers": { + "ns_p1_indifference": false, + "ns_p2bis_drive": true, + "ns_p3_structure": true + }, + "verdict": "NON_CONCLUSIF_INSTRUMENT (null b : saturation forte)", + "verdict_secondary": "NOT_SUPPORTED (p2bis : le drive porte tout ; p3 : structure indiscernable)", + "bands": { + "p1_min": 0.6, + "p1_fail": 0.2, + "p2_max": 0.2, + "p2_fail": 0.5, + "p3_min": 0.25, + "p3_fail": 0.1, + "match_r_bar_max": 0.15, + "ctrl_v0_max": 0.05 + } +} diff --git a/MyIA.AI.Notebooks/IIT/ICT-Series/ict/stv_valence_symmetry_v2.py b/MyIA.AI.Notebooks/IIT/ICT-Series/ict/stv_valence_symmetry_v2.py new file mode 100644 index 00000000000..7a3be267456 --- /dev/null +++ b/MyIA.AI.Notebooks/IIT/ICT-Series/ict/stv_valence_symmetry_v2.py @@ -0,0 +1,531 @@ +"""Case 17bis - STV v2 : seconde operationnalisation, structure du lock (iceberg #8182). + +Execution du pre-enregistrement +``docs/ict/stv-valence-symmetry-v2-pre-enregistrement.md`` (scelle AVANT ce +banc -- l'anteriorite repose sur la relation de parente des commits, lecon +case 8c). Le banc v1 (``stv_valence_symmetry.py``, case 17, verdict +``NON_CONCLUSIF_INSTRUMENT``) est CONSERVE tel quel -- jamais reecrit : ce +module est l'instrument n.o 2 du meme claim, pattern case 6 -> case 14. + +Les deux correctifs scelles (limite mesuree v1 -> correctif v2) : + +1. P3 lisait ``CV(r)`` : la coherence brute du bras N (collapse 1:1 parfait, + CV ~ 1e-15) y est MINIMALE -- l'observable etait aveugle au contraste + qu'elle visait. v2 : score de structure ``S`` = entropie normalisee (ln 6) + de la distribution des classes de ratio des paires verrouillees (6 classes + : 1:1, 4:3, 3:2, 2:1, 3:1, 4:1). Le bras H (echelle octave) est + structurellement riche, le bras N (quasi-unisson + irrationnels) + trivialement uniforme. +2. La perturbation d'energie v1 passait par l'heterogeneite d'amplitude + (``a_i * a_j`` par paire) : le drive decidait du verrouillage. v2 : + amplitudes unitaires partout, energie = drive global uniforme + ``K_eff = K2_c * (1 + eps)``, ``eps in {-0.1, 0, +0.1}``, applique a la + seule echelle (les bras H/N restent au point nominal). + +Mecanique heritee du banc v1 par import, jamais dupliquee : tirage des +configurations, detecteur m:n (concentration circulaire + derive nulle), +sigma octave-repliee, graines, constantes d'integration. Nouvelle fenetre de +calibration : ``v_bar(u = 1) in [0.5, 0.8]`` -- la lecture de l'instrument +lui-meme, plus le ``r_bar`` aveugle aux locks m:n de la fenetre v1. + +Predictions scellees (graines test (0, 1, 7, 42, 99), calibration gelee sur +(11, 22, 33), jamais relues) : + +* P1 attracteur ~ consonance (inchangee) : rho(v, sigma) >= 0.6, >= 4/5 ; +* P2bis dissociation drive : |rho(v, eps | decile de sigma)| <= 0.2, >= 4/5 ; +* P3bis discriminateur structure : dS = S(H) - S(N) >= 0.25 a coherence + brute appariee (porte |r_bar(H) - r_bar(N)| <= 0.15), >= 4/5 ; +* Null (a) sigma permute ; Null (a3) etiquettes H/N permutees ; Null (b) + couplage fort x8 sature -> NON_CONCLUSIF_INSTRUMENT ; +* portes instrumentales v_bar(u=1) >= 0.3, v_bar(u=0) <= 0.7 ; +* controle mecanique K_eff=0 sur irrationnelles : v <= 0.05 ; la + commensurabilite cinematique des membres exacts y est un plafond DECLARE + (mesure en diagnostic, pas une porte). + +References : celles du scelle v1 (Johnson 2016 ; Gomez-Emilsson 2020 ; +Johnson 2023). Pre-enregistrement : +``docs/ict/stv-valence-symmetry-v2-pre-enregistrement.md``. +""" + +from __future__ import annotations + +import argparse +import json +import os +from multiprocessing import Pool + +import numpy as np + +from ict import stv_valence_symmetry as v1 +from ict.stv_valence_symmetry import ( + DT, + K, + LOCK_MAX, + LOCK_TOL, + M_CONFIGS, + M_PAIRS, + SEEDS_CALIB, + SEEDS_TEST, + SLOPE_TOL, + SUBSAMPLE, + T_TOTAL, + _spearman, + _unwrap, + draw_configs, + integrate, + order_parameter, + sigma_config, +) + +# K2_c nominal : GELE par --calibrate (graines 11/22/33) — fenetre scellee +# v(u=1) in [0.5, 0.8], mediane mesuree 0.75 a K=48 (seul point de grille +# dans la fenetre ; trace : ict/results/stv_valence_symmetry_v2_calibration.json). +K2_COUPLING = 48.0 + +# --- Bandes scellees case 17bis (jamais recalculees apres mesure) --- +BAND_P1 = 0.6 # rho(v, sigma) >= +BAND_P1_FAIL = 0.2 # en deca : indifference au regime propre (NOT_SUPPORTED) +BAND_P2 = 0.2 # |rho(v, eps | decile sigma)| <= +BAND_P2_FAIL = 0.5 # au-dela : le drive porte tout (NOT_SUPPORTED) +BAND_P3 = 0.25 # dS = S(H) - S(N) >= +BAND_P3_FAIL = 0.10 # en deca : structure indiscernable (NOT_SUPPORTED) +GATE_V_U1 = 0.3 # plancher v_bar(u=1) +GATE_V_U0 = 0.7 # plafond v_bar(u=0) +GATE_MATCH_RB = 0.15 # porte d'appariement |r_bar(H) - r_bar(N)| <= +GATE_MIN_SEEDS = 3 +CTRL_V0_MAX = 0.05 # controle mecanique, configs irrationnelles +NULL_B_SCALE = 8.0 # couplage fort x K2_c +EPS_GRID = (-0.10, 0.0, 0.10) + +# Classes de ratio (m, n <= 4, m >= n, valeurs repliees distinctes). +RATIO_CLASSES = (1.0, 4.0 / 3.0, 1.5, 2.0, 3.0, 4.0) +_CLASS_INDEX = {round(c, 9): i for i, c in enumerate(RATIO_CLASSES)} +_LN_C = float(np.log(len(RATIO_CLASSES))) + +_DT_STORE = DT * SUBSAMPLE * 4 # espacement de la serie analysee (v1) + + +# --- Detecteur m:n v1 + classe du meilleur candidat --- + +def lock_analysis(phases_sub: np.ndarray) -> tuple[np.ndarray, np.ndarray, + np.ndarray]: + """Detecteur m:n v1 (meilleur candidat, criteres inchanges) + classe. + + Reprise EXACTE des criteres v1 par paire : combine ``psi = a*th_i - + b*th_j`` avec (a, b) <= 4, concentre (ecart-type circulaire < LOCK_TOL) + ET derive nulle (|dpsi/dt| < SLOPE_TOL) sur la seconde moitie ; parmi + les candidats satisfaisants, le MEILLEUR (ecart-type minimal) l'emporte + -- un verrouillage 2:1 satisfait aussi 4:2, le choix du minimal evite + le double compte et designe la classe primitive. + + Retourne ``(v, S, comptes)`` : + + * ``v`` : fraction de paires verrouillees (definition v1, inchangee) ; + * ``S`` : entropie normalisee (ln 6) de la distribution des classes des + paires verrouillees CLASSEES ; un verrouillage atypique (ratio hors + des 6 classes, ex. 2:3) compte dans ``v`` mais pas dans ``S`` ; + ``nan`` si aucune paire classee ; + * ``comptes`` : histogramme (n_conf, 6) des classes du meilleur candidat. + """ + uw = _unwrap(phases_sub[phases_sub.shape[0] // 2::4]) + i, j = np.triu_indices(K, k=1) + n_conf = uw.shape[1] + n_pair = i.size + best_std = np.full((n_conf, n_pair), np.inf) + best_cls = np.full((n_conf, n_pair), -1, dtype=int) + for a in range(1, LOCK_MAX + 1): + for b in range(1, LOCK_MAX + 1): + psi_raw = a * uw[:, :, i] - b * uw[:, :, j] + psi = psi_raw % (2.0 * np.pi) + z = np.exp(1j * psi).mean(axis=0) + circ_std = np.sqrt(np.maximum( + -2.0 * np.log(np.maximum(np.abs(z), 1e-12)), 0.0)) + diffs = np.diff(psi_raw, axis=0) + slope = (np.abs(diffs.mean(axis=0)) / _DT_STORE + if diffs.size else np.full(circ_std.shape, np.inf)) + ok = (circ_std < LOCK_TOL) & (np.abs(slope) < SLOPE_TOL) + cls = _CLASS_INDEX.get(round(a / b, 9), -1) + better = ok & (circ_std < best_std) + best_std = np.where(better, circ_std, best_std) + best_cls = np.where(better, cls, best_cls) + locked = best_std < np.inf + v = locked.sum(axis=1) / n_pair + counts = np.zeros((n_conf, len(RATIO_CLASSES)), dtype=int) + for ci in range(len(RATIO_CLASSES)): + counts[:, ci] = (locked & (best_cls == ci)).sum(axis=1) + n_classed = counts.sum(axis=1) + probs = counts / np.maximum(n_classed[:, None], 1) + with np.errstate(divide="ignore", invalid="ignore"): + ent = -(probs * np.where(probs > 0, + np.log(np.maximum(probs, 1e-300)), 0.0) + ).sum(axis=1) + s = np.where(n_classed > 0, ent / _LN_C, np.nan) + return v, s, counts + + +def u_hat(ratios_row: np.ndarray) -> float: + """Fraction de membres EXACTS de l'echelle octave (reconstruction de u). + + Le tirage v1 ne stocke pas u ; il se reconstruit exactement : un membre + decale differe de son ancre octave de >= 3 % en log, un membre exact + coincide au flottant pres (comparaison a 1e-9 pres). + """ + anchors = {round(float(x), 9) for x in v1.HARMONIC_LADDER} + exact = sum(1 for r in ratios_row if round(float(r), 9) in anchors) + return exact / len(ratios_row) + + +# --- Jambe d'une graine --- + +def run_seed_v2(seed: int, k2_c: float, m_configs: int = M_CONFIGS, + n_pairs: int = M_PAIRS, eps_grid=EPS_GRID) -> dict: + """Tous les bras v2 d'une graine. + + Jambe echelle : les ``m_configs`` configurations d'echelle integrees a + CHAQUE eps du grid (drive uniforme ``k2_c * (1 + eps)``, amplitudes + unitaires). Jambe paires : les ``2 * n_pairs`` configurations H/N + integrees une seule fois au point nominal ``k2_c`` (P3bis + portes). + """ + cfg = draw_configs(seed, m_configs, n_pairs=n_pairs) + n, m = cfg["n_ladder"], cfg["n_pairs"] + ratios, ph0 = cfg["ratios"], cfg["phases0"] + amps = np.ones_like(ph0) # amplitudes unitaires PARTOUT + + v_eps, s_eps0 = {}, {} + for eps in eps_grid: + ph = integrate(ratios[:n], ph0[:n], amps[:n], + k2_c * (1.0 + eps), t_total=T_TOTAL) + v, s, _c = lock_analysis(ph) + v_eps[str(eps)] = v.tolist() + s_eps0[str(eps)] = s.tolist() + + ph_p = integrate(ratios[n:], ph0[n:], amps[n:], k2_c, t_total=T_TOTAL) + v_p, s_p, _cp = lock_analysis(ph_p) + r_p = order_parameter(ph_p) + r_bar_p = r_p[len(r_p) // 2:].mean(axis=0) + + sig = np.array([sigma_config(rr) for rr in ratios[:n]]) + u = np.array([u_hat(rr) for rr in ratios[:n]]) + + return {"seed": seed, "k2_c": k2_c, "n": n, "m": m, + "v_eps": v_eps, "s_eps0": s_eps0, + "v_pairs": v_p.tolist(), "s_pairs": s_p.tolist(), + "r_bar_pairs": r_bar_p.tolist(), + "sigma_ladder": sig.tolist(), "u_ladder": u.tolist()} + + +# --- Statistiques scellees --- + +def _decile_partial_spearman(v_eps: dict, sigma0: np.ndarray) -> float: + """rho(v, eps | decile de sigma) : rangs residuels par decile (scelle). + + Pour chaque decile de sigma (12 deciles de 10 configurations sur + l'echelle de 120), ``v`` et ``eps`` sont remplaces par leur rang MOINS + le rang moyen du decile ; Spearman sur les rangs residuels pooles. + """ + eps_arr = np.concatenate( + [np.full(len(v_eps[str(e)]), float(e)) for e in EPS_GRID]) + v_arr = np.concatenate([np.asarray(v_eps[str(e)], dtype=float) + for e in EPS_GRID]) + v_rank = np.argsort(np.argsort(v_arr)).astype(float) + e_rank = np.argsort(np.argsort(eps_arr)).astype(float) + # Deciles de SIGMA (scelle : 12 deciles de 10 configs x 3 eps), pas de + # l'index — les blocs eps-major rendraient chaque decile eps-pur et la + # correlation partielle muette par construction. + sig_tile = np.tile(sigma0, len(EPS_GRID)) + order = np.argsort(sig_tile, kind="stable") + rv = np.empty_like(v_arr) + re = np.empty_like(eps_arr) + for idx in np.array_split(order, 12): + rv[idx] = v_rank[idx] - v_rank[idx].mean() + re[idx] = e_rank[idx] - e_rank[idx].mean() + if np.std(rv) == 0 or np.std(re) == 0: + return float("nan") + return float(np.corrcoef(rv, re)[0, 1]) + + +def _mean_s_excluding_nan(s_list: list) -> tuple: + arr = np.asarray([x for x in s_list if np.isfinite(x)], dtype=float) + excl = sum(1 for x in s_list if not np.isfinite(x)) + return (float(arr.mean()) if arr.size else float("nan")), excl + + +def _seed_result_v2(job: tuple) -> dict: + seed, k2_c = job + d = run_seed_v2(seed, k2_c) + sigma0 = np.asarray(d["sigma_ladder"]) + v0 = np.asarray(d["v_eps"]["0.0"]) + m = d["m"] + s_h, excl_h = _mean_s_excluding_nan(d["s_pairs"][:m]) + s_n, excl_n = _mean_s_excluding_nan(d["s_pairs"][m:]) + rb_h = float(np.median(np.asarray(d["r_bar_pairs"][:m]))) + rb_n = float(np.median(np.asarray(d["r_bar_pairs"][m:]))) + u_arr = np.asarray(d["u_ladder"]) + v_u1 = float(np.median(v0[u_arr >= 0.999])) if (u_arr >= 0.999).any() \ + else float("nan") + # Porte plafond scellee : « echelle entierement decalee » = ancre seule + # exacte, soit u_hat = 1/8 (l'ancre 1.0 est toujours presente dans le + # tirage v1, donc u_hat > 0 par construction -- un filtre a u_hat <= 0 + # serait toujours vide et la porte jamais evaluable). + v_u0 = float(np.median(v0[u_arr <= 1 / 8 + 1e-9])) \ + if (u_arr <= 1 / 8 + 1e-9).any() else float("nan") + return { + "seed": seed, + "rho1": float(_spearman(v0, sigma0)), + "rho_eps_partial": _decile_partial_spearman(d["v_eps"], sigma0), + "dS": s_h - s_n, "s_h": s_h, "s_n": s_n, + "excl_h": excl_h, "excl_n": excl_n, + "r_bar_h": rb_h, "r_bar_n": rb_n, + "v_u1_median": v_u1, "v_u0_median": v_u0, + "v_ladder": v0.tolist(), "sigma_ladder": sigma0.tolist(), + "u_ladder": u_arr.tolist(), + "v_eps": d["v_eps"], "s_pairs": d["s_pairs"], "m": m, + } + + +def _strong_result_v2(k2_c: float) -> float: + """Null (b) : couplage fort x8 -- si l'attracteur ne discrimine plus + (|rho| < 0.2), l'instrument est sature, NON_CONCLUSIF.""" + d = run_seed_v2(SEEDS_TEST[0], k2_c * NULL_B_SCALE, eps_grid=(0.0,)) + v0 = np.asarray(d["v_eps"]["0.0"]) + return abs(_spearman(v0, np.asarray(d["sigma_ladder"]))) + + +def _perm_null_a3(seed_data: dict, draws: int = 200) -> float: + """Null (a3) : etiquettes H/N permutees (graine 0, bras reutilise).""" + rng = np.random.default_rng(0) + s_pairs = np.asarray(seed_data["s_pairs"], dtype=float) + m = seed_data["m"] + vals = [] + for _ in range(draws): + sp = s_pairs[rng.permutation(2 * m)] + h, _ = _mean_s_excluding_nan(sp[:m].tolist()) + nn, _ = _mean_s_excluding_nan(sp[m:].tolist()) + if np.isfinite(h) and np.isfinite(nn): + vals.append(abs(h - nn)) + return float(np.median(vals)) if vals else float("nan") + + +def _mechanical_control_v2(seed: int) -> dict: + """K_eff = 0 : irrationnelles -> v ~ 0 (porte scellee) ; membres exacts + -> verrouillage cinematique SANS couplage (plafond DECLARE, diagnostic).""" + rng = np.random.default_rng(seed) + ratios_irr = np.array([ + np.concatenate([[1.0], np.exp(rng.uniform(np.log(1.05), np.log(1.95), + K - 1))]) + for _ in range(6)]) + ratios_exact = np.array([v1.HARMONIC_LADDER] * 4) + ratios = np.concatenate([ratios_irr, ratios_exact]) + ph0 = rng.uniform(0.0, 2.0 * np.pi, size=ratios.shape) + ph = integrate(ratios, ph0, np.ones_like(ph0), 0.0, t_total=10.0) + v, _s, _c = lock_analysis(ph) + return {"seed": seed, + "v0_irr_mean": float(v[:6].mean()), + "v0_exact_mean": float(v[6:].mean())} + + +def run_protocol_v2(k2_c: float = None, parallel: bool = True) -> dict: + """Run principal : graines test, K2_c gele par --calibrate.""" + if k2_c is None: + k2_c = K2_COUPLING + jobs = [(s, k2_c) for s in SEEDS_TEST] + if parallel and len(jobs) > 1 and (os.cpu_count() or 2) > 2: + n_proc = max(1, min(len(jobs) + 1, (os.cpu_count() or 2) - 1)) + with Pool(n_proc) as pool: + per_seed = pool.map(_seed_result_v2, jobs) + (null_b,) = pool.map(_strong_result_v2, [k2_c]) + ctrls = pool.map(_mechanical_control_v2, list(SEEDS_TEST)) + else: + per_seed = [_seed_result_v2(j) for j in jobs] + null_b = _strong_result_v2(k2_c) + ctrls = [_mechanical_control_v2(s) for s in SEEDS_TEST] + + rho1s = [d["rho1"] for d in per_seed] + rho_eps = [d["rho_eps_partial"] for d in per_seed] + dss = [d["dS"] for d in per_seed] + rb_h = [d["r_bar_h"] for d in per_seed] + rb_n = [d["r_bar_n"] for d in per_seed] + v_u1 = [d["v_u1_median"] for d in per_seed] + v_u0 = [d["v_u0_median"] for d in per_seed] + + # Null (a) : permutation sigma, graine 0. + perm_rng = np.random.default_rng(0) + v0 = np.asarray(per_seed[0]["v_ladder"]) + s0 = np.asarray(per_seed[0]["sigma_ladder"]) + null_a = float(np.median([ + abs(_spearman(v0, perm_rng.permutation(s0))) for _ in range(200)])) + # Null (a3) : permutation etiquettes H/N, graine 0. + null_a3 = _perm_null_a3(per_seed[0]) + + # Controle mecanique scelle « sur 5/5 graines » (§3) : la porte porte + # sur toutes les graines test, pas sur la seule graine 0. + ctrl_ok = all(c["v0_irr_mean"] <= CTRL_V0_MAX for c in ctrls) + + p1 = sum(r >= BAND_P1 for r in rho1s) >= 4 + p2 = sum(abs(r) <= BAND_P2 for r in rho_eps) >= 4 + p3_ok = sum(x >= BAND_P3 for x in dss) >= 4 + gate_floor = sum(np.isfinite(x) and x < GATE_V_U1 for x in v_u1) \ + >= GATE_MIN_SEEDS + gate_ceiling = sum(np.isfinite(x) and x > GATE_V_U0 for x in v_u0) \ + >= GATE_MIN_SEEDS + gate_match = sum(abs(h - n) > GATE_MATCH_RB + for h, n in zip(rb_h, rb_n)) >= GATE_MIN_SEEDS + + # Declencheurs NOT SUPPORTED du scelle §4 : « P1 < 0.2 (indifference) », + # pas « P1 rate sa bande 0.6 » -- quantifies >= 4/5 graines comme les + # predictions P1/P2bis/P3bis. Evalues NOMMEMENT pour chaque famille : + # le scelle ne fixe pas d'ordre de priorite entre familles, et un run + # peut declencher NON_CONCLUSIF_INSTRUMENT (instrument) ET une famille + # NOT_SUPPORTED (these) simultanement -- l'artefact porte alors les deux + # (#22401, reserve Hermes : jamais de famille escamotee par l'ordre du if). + ns_p1_indifference = sum(r < BAND_P1_FAIL for r in rho1s) >= 4 + ns_p2bis_drive = sum(abs(r) > BAND_P2_FAIL for r in rho_eps) >= 4 + ns_p3_structure = sum(x < BAND_P3_FAIL for x in dss) >= 4 + + if gate_floor: + verdict = "NON_CONCLUSIF_INSTRUMENT (porte plancher v(u=1))" + elif gate_ceiling: + verdict = "NON_CONCLUSIF_INSTRUMENT (porte plafond v(u=0))" + elif gate_match: + verdict = "NON_CONCLUSIF_INSTRUMENT (porte appariement r_bar H/N)" + elif null_b < 0.2: + verdict = "NON_CONCLUSIF_INSTRUMENT (null b : saturation forte)" + elif not ctrl_ok: + verdict = "NON_CONCLUSIF_INSTRUMENT (controle mecanique)" + elif p1 and p2 and p3_ok and null_a <= 0.2 and null_a3 <= 0.05: + verdict = "SUPPORTED" + elif ns_p1_indifference or ns_p2bis_drive or ns_p3_structure: + verdict = "NOT_SUPPORTED" + else: + verdict = "NON_CONCLUSIF" + + verdict_secondary = None + if verdict.startswith("NON_CONCLUSIF_INSTRUMENT") and ( + ns_p1_indifference or ns_p2bis_drive or ns_p3_structure): + familles = [] + if ns_p1_indifference: + familles.append("p1 : indifference au regime propre") + if ns_p2bis_drive: + familles.append("p2bis : le drive porte tout") + if ns_p3_structure: + familles.append("p3 : structure indiscernable") + verdict_secondary = "NOT_SUPPORTED (" + " ; ".join(familles) + ")" + + return { + "case": "17bis-stv-v2-lock-structure", + "k2_coupling": k2_c, + "seeds": list(SEEDS_TEST), "m_configs": M_CONFIGS, + "per_seed": [{k: d[k] for k in d if k not in ("v_eps", "s_pairs")} + for d in per_seed], + "rho1_by_seed": rho1s, "rho_eps_by_seed": rho_eps, + "dS_by_seed": dss, "r_bar_h_by_seed": rb_h, + "r_bar_n_by_seed": rb_n, "v_u1_by_seed": v_u1, "v_u0_by_seed": v_u0, + "null_a_median_abs_rho": null_a, "null_a3_median_abs_dS": null_a3, + "null_b_abs_rho": null_b, + "ctrl_mechanical": ctrls, + "p1": bool(p1), "p2": bool(p2), "p3": bool(p3_ok), + "gates": {"floor_v_u1": bool(gate_floor), + "ceiling_v_u0": bool(gate_ceiling), + "match_r_bar": bool(gate_match)}, + # Declencheurs NOT SUPPORTED evalues nommement meme quand l'ordre du + # if rend un verdict d'instrument en premier : le scelle ne priorise + # pas les familles, l'artefact porte donc les deux (#22401, Hermes). + "triggers": {"ns_p1_indifference": bool(ns_p1_indifference), + "ns_p2bis_drive": bool(ns_p2bis_drive), + "ns_p3_structure": bool(ns_p3_structure)}, + "verdict": verdict, + "verdict_secondary": verdict_secondary, + "bands": {"p1_min": BAND_P1, "p1_fail": BAND_P1_FAIL, + "p2_max": BAND_P2, + "p2_fail": BAND_P2_FAIL, "p3_min": BAND_P3, + "p3_fail": BAND_P3_FAIL, "match_r_bar_max": GATE_MATCH_RB, + "ctrl_v0_max": CTRL_V0_MAX}, + } + + +# --- Calibration (graines disjointes 11/22/33) --- + +def _calib_point(k_c: float) -> dict: + """Un point de la grille de calibration : v(u=1) et variance de v.""" + v_exact_pool, vvars = [], [] + for s in SEEDS_CALIB: + cfg = draw_configs(s, 24, n_pairs=6) + nl = cfg["n_ladder"] + ph = integrate(cfg["ratios"][:nl], cfg["phases0"][:nl], + np.ones((nl, K)), k_c, t_total=T_TOTAL) + v, _s, _c = lock_analysis(ph) + u_arr = np.array([u_hat(rr) for rr in cfg["ratios"][:nl]]) + v_exact_pool.extend(v[u_arr >= 0.999].tolist()) + vvars.append(float(np.var(v))) + med = float(np.median(v_exact_pool)) if v_exact_pool else float("nan") + return {"k2": k_c, "v_u1_median": med, "n_exact": len(v_exact_pool), + "v_variance_mean": float(np.mean(vvars))} + + +def calibrate_v2(parallel: bool = True) -> dict: + """Gel de K2_c : cible scellee ``v_bar(u = 1) in [0.5, 0.8]``. + + Mediane de ``v`` sur les configurations toutes-exactes (``u_hat = 1``) + au point nominal, pool des trois graines de calibration (11/22/33, + disjointes des graines de test). Parmi les K2_c dont la mediane tombe + dans la fenetre, on retient celui le plus proche de 0.65 (centre). + Repli declare si la fenetre est inatteignable sur toute la grille : + K2_c a variance de ``v`` maximale (sensibilite, neutre en signe). + """ + grid = [4.0, 8.0, 16.0, 24.0, 32.0, 48.0, 64.0, 96.0, 128.0] + if parallel and (os.cpu_count() or 2) > 2: + with Pool(min(len(grid), (os.cpu_count() or 2) - 1)) as pool: + trace = pool.map(_calib_point, grid) + else: + trace = [_calib_point(k_c) for k_c in grid] + best_window, best_var = None, None + for row in trace: + med = row["v_u1_median"] + if np.isfinite(med) and 0.5 <= med <= 0.8 \ + and (best_window is None + or abs(med - 0.65) < best_window[0]): + best_window = (abs(med - 0.65), row["k2"], med) + if best_var is None or row["v_variance_mean"] > best_var[0]: + best_var = (row["v_variance_mean"], row["k2"], med) + if best_window is not None: + return {"k2_coupling": best_window[1], + "source": "fenetre v(u=1) scellee", + "v_u1_median": best_window[2], "v_variance": None, + "trace": trace} + return {"k2_coupling": best_var[1], + "source": "repli variance v (declare)", + "v_u1_median": best_var[2], "v_variance": best_var[0], + "trace": trace} + + +def main() -> None: + ap = argparse.ArgumentParser( + description="Case 17bis - STV v2 : structure du lock") + ap.add_argument("--calibrate", action="store_true", + help="gel de K2_c sur graines disjointes (11/22/33)") + ap.add_argument("--k2", type=float, default=None, + help="K2_c explicite (defaut : K2_COUPLING gele)") + ap.add_argument("--out", type=str, default=None, + help="ecrire le JSON resultat a ce chemin") + ap.add_argument("--json", action="store_true", + help="sortie JSON sur stdout") + args = ap.parse_args() + if args.calibrate: + out = calibrate_v2() + else: + out = run_protocol_v2(k2_c=args.k2) + text = json.dumps(out, indent=2, ensure_ascii=False) + if args.out: + with open(args.out, "w", encoding="utf-8") as fh: + fh.write(text + "\n") + if args.json: + print(text) + else: + for key, val in out.items(): + if key in ("per_seed", "trace"): + continue + print(f"{key}: {val}") + + +if __name__ == "__main__": + main() diff --git a/MyIA.AI.Notebooks/IIT/ICT-Series/ict/tests/test_stv_valence_symmetry_v2.py b/MyIA.AI.Notebooks/IIT/ICT-Series/ict/tests/test_stv_valence_symmetry_v2.py new file mode 100644 index 00000000000..d14710bec43 --- /dev/null +++ b/MyIA.AI.Notebooks/IIT/ICT-Series/ict/tests/test_stv_valence_symmetry_v2.py @@ -0,0 +1,194 @@ +"""Tests instrument - case 17bis (STV v2, structure du lock). + +Chaque test cible une piece scellee du protocole : detecteur m:n + classe +(pas de double compte), reconstruction de u, Spearman partiel par decile, +exclusions NaN de S, null a3, controle mecanique (irrationnelles libres, +exactes = plafond cinematique DECLARE), determinisme de la jambe, echelle +du null b, et gel des bandes du scelle. +""" + +from __future__ import annotations + +import numpy as np +import pytest + +from ict import stv_valence_symmetry as v1 +from ict import stv_valence_symmetry_v2 as stv2 + +K = v1.K +N_TIMES = 1200 # fenetre analysee : seconde moitie, 1 point sur 4 + + +def _synth_phases(omegas, n_conf=1, seed=0): + """Phases (N_TIMES, n_conf, K) de rotations libres aux frequences donnees.""" + rng = np.random.default_rng(seed) + dt = stv2.DT * stv2.SUBSAMPLE + t = np.arange(N_TIMES) * dt + ph = omegas[None, None, :] * t[:, None, None] + ph = ph + rng.uniform(0, 2 * np.pi, size=(1, n_conf, K)) + return np.broadcast_to(ph, (N_TIMES, n_conf, K)).copy() + + +# --- Detecteur m:n + classes --- + +def test_lock_unison_all_1_1(): + v, s, counts = stv2.lock_analysis(_synth_phases(np.ones(K))) + assert v[0] == pytest.approx(1.0) + assert counts[0, 0] == K * (K - 1) // 2 # toutes en classe 1:1 + assert s[0] == pytest.approx(0.0, abs=1e-12) + + +def test_lock_mixed_1_1_and_2_1(): + # 4 lentes (indice bas) puis 4 rapides : croisees -> 2:1 classees. + omegas = np.array([1.0] * 4 + [2.0] * 4) + v, s, counts = stv2.lock_analysis(_synth_phases(omegas)) + assert v[0] == pytest.approx(1.0) + assert counts[0, 0] == 12 and counts[0, 3] == 16 # 1:1 et 2:1 + assert s[0] == pytest.approx( + -(12 / 28 * np.log(12 / 28) + 16 / 28 * np.log(16 / 28)) + / np.log(6), rel=1e-6) + + +def test_lock_reversed_order_unclassed_counts_in_v(): + # Rapides en indice bas : croisees -> ratio 1:2, HORS des 6 classes. + # Elles comptent dans v mais pas dans S (comportement declare). + omegas = np.array([2.0] * 4 + [1.0] * 4) + v, s, counts = stv2.lock_analysis(_synth_phases(omegas)) + assert v[0] == pytest.approx(1.0) + assert counts.sum(axis=1)[0] == 12 # seules les 1:1 classees + assert 0.0 < s[0] < 1e-12 or s[0] == 0.0 # distribution uniforme + + +def test_lock_free_incommensurate(): + # Racines de premiers distincts : aucun |a*om_i - b*om_j| < SLOPE_TOL + # (min mesure ~ 0.096), aucune paire ne verrouille. + omegas = np.sqrt(np.array([1.0, 2.0, 3.0, 5.0, 7.0, 11.0, 13.0, 17.0])) + v, s, _c = stv2.lock_analysis(_synth_phases(omegas)) + assert v[0] < 0.05 + assert not np.isfinite(s[0]) + + +# --- Reconstruction de u --- + +def test_u_hat_full_ladder_exact(): + assert stv2.u_hat(np.array(v1.HARMONIC_LADDER)) == pytest.approx(1.0) + + +def test_u_hat_one_member_shifted(): + row = np.array(v1.HARMONIC_LADDER, dtype=float) + row[3] *= 1.05 + assert stv2.u_hat(row) == pytest.approx((K - 1) / K) + + +def test_gate_pools_available_sealed_semantics(): + """Portes scellees : pools u_hat = 1 (echelle exacte) et u_hat = 1/8 + (echelle entierement decalee -- ancre seule exacte) non vides aux + graines test. Un filtre a u_hat <= 0 serait toujours vide : l'ancre + 1.0 est toujours presente dans le tirage v1.""" + for seed in stv2.SEEDS_TEST: + cfg = v1.draw_configs(seed, stv2.M_CONFIGS, n_pairs=stv2.M_PAIRS) + u_arr = np.array([stv2.u_hat(rr) + for rr in cfg["ratios"][:cfg["n_ladder"]]]) + assert u_arr.min() == pytest.approx(1 / 8) + assert (u_arr >= 0.999).sum() >= 5 # pool porte plancher + assert (u_arr <= 1 / 8 + 1e-9).sum() >= 5 # pool porte plafond + + +# --- Spearman partiel par deciles de sigma --- + +def test_partial_spearman_independent_eps(): + rng = np.random.default_rng(7) + sigma0 = rng.uniform(0.2, 0.9, 120) + v_base = rng.normal(0.5, 0.1, 120) + v_eps = {str(e): v_base.tolist() for e in stv2.EPS_GRID} + assert abs(stv2._decile_partial_spearman(v_eps, sigma0)) < 0.25 + + +def test_partial_spearman_driven_eps(): + rng = np.random.default_rng(7) + sigma0 = rng.uniform(0.2, 0.9, 120) + v_eps = {str(e): (0.5 + 3.0 * e + 0.01 * rng.normal(size=120)).tolist() + for e in stv2.EPS_GRID} + # Rangs globaux aux ex aequo d'eps pres : 0.85, tres au-dela du cas + # independant (< 0.25 ci-dessus). + assert stv2._decile_partial_spearman(v_eps, sigma0) > 0.85 + + +# --- Moyennes S avec exclusions, null a3 --- + +def test_mean_s_excluding_nan(): + mean, excl = stv2._mean_s_excluding_nan([0.5, float("nan"), 0.7]) + assert mean == pytest.approx(0.6) + assert excl == 1 + mean0, excl0 = stv2._mean_s_excluding_nan([float("nan")]) + assert not np.isfinite(mean0) and excl0 == 1 + + +def test_perm_null_a3_identical_pools_zero(): + d = {"s_pairs": [0.5] * 40, "m": 20} + assert stv2._perm_null_a3(d, draws=50) == pytest.approx(0.0) + + +def test_perm_null_a3_below_true_contrast(): + rng = np.random.default_rng(1) + h = rng.uniform(0.7, 0.9, 20).tolist() + n = rng.uniform(0.1, 0.3, 20).tolist() + d = {"s_pairs": h + n, "m": 20} + null = stv2._perm_null_a3(d, draws=200) + assert 0.0 <= null < 0.4 # tres en deca du contraste vrai ~0.6 + + +# --- Controle mecanique --- + +def test_mechanical_control_irr_free_exact_kinematic_5_seeds(): + """Controle mecanique scelle « sur 5/5 graines » (§3) : chaque graine + porte sa propre instance du controle (irrationnelles libres -> porte ; + membres exacts -> plafond cinematique DECLARE, diagnostic).""" + for seed in stv2.SEEDS_TEST: + ctrl = stv2._mechanical_control_v2(seed) + assert ctrl["seed"] == seed + assert ctrl["v0_irr_mean"] <= stv2.CTRL_V0_MAX # porte scellee + assert ctrl["v0_exact_mean"] > 0.4 # plafond DECLARE (diag) + + +# --- Jambe complete (short) + determinisme --- + +def test_run_seed_v2_smoke_deterministic(monkeypatch): + monkeypatch.setattr(stv2, "T_TOTAL", 3.0) + a = stv2.run_seed_v2(0, 8.0, m_configs=4, n_pairs=2, eps_grid=(0.0,)) + b = stv2.run_seed_v2(0, 8.0, m_configs=4, n_pairs=2, eps_grid=(0.0,)) + # Comparaison par JSON : l'egalite flottante directe est muette sur les + # nan (S des configurations sans paire classee), presents ici. + import json + assert json.dumps(a) == json.dumps(b) + for key in ("v_eps", "v_pairs", "s_pairs", "r_bar_pairs", + "sigma_ladder", "u_ladder"): + assert key in a + assert len(a["v_pairs"]) == 4 and len(a["u_ladder"]) == 4 + + +def test_strong_null_uses_x8_scale(monkeypatch): + captured = {} + + def fake_run(seed, k2_c, **kw): + captured["seed"], captured["k2_c"] = seed, k2_c + return {"v_eps": {"0.0": [0.1, 0.4]}, + "sigma_ladder": [0.3, 0.5]} + + monkeypatch.setattr(stv2, "run_seed_v2", fake_run) + stv2._strong_result_v2(10.0) + assert captured["k2_c"] == pytest.approx(10.0 * stv2.NULL_B_SCALE) + assert captured["seed"] == v1.SEEDS_TEST[0] + + +# --- Gel des bandes scellees --- + +def test_sealed_bands_frozen(): + assert stv2.BAND_P1 == 0.6 and stv2.BAND_P1_FAIL == 0.2 + assert stv2.BAND_P2 == 0.2 + assert stv2.BAND_P3 == 0.25 and stv2.BAND_P2_FAIL == 0.5 + assert stv2.BAND_P3_FAIL == 0.10 + assert stv2.GATE_V_U1 == 0.3 and stv2.GATE_V_U0 == 0.7 + assert stv2.GATE_MATCH_RB == 0.15 and stv2.CTRL_V0_MAX == 0.05 + assert stv2.NULL_B_SCALE == 8.0 + assert stv2.RATIO_CLASSES == (1.0, 4 / 3, 1.5, 2.0, 3.0, 4.0) diff --git a/docs/README.md b/docs/README.md index 166804e2e48..9d1f7ec5ecd 100644 --- a/docs/README.md +++ b/docs/README.md @@ -226,6 +226,7 @@ Grade distinct des synthèses ci-dessus : ces documents sont **grade T-pré-enre | [ict/strates-as-adjunctions-prototype.md](ict/strates-as-adjunctions-prototype.md) | Prototype **grade C** : les strates ICT comme adjonctions — conjecture du jalon 3 de #8182 (TOE ↔ conscience), explicitement non démontrée | | [ict/butlin-indicators-pre-enregistrement.md](ict/butlin-indicators-pre-enregistrement.md) | Case 19 — le mot « using » de RPT-1 (Butlin et al. 2023) : protocole scellé avant écriture du banc, dissociation procédurale entre inspection structurelle et sonde causale | | [ict/assembly-theory-pre-enregistrement.md](ict/assembly-theory-pre-enregistrement.md) | Case 20 — l'assembly index mesuré (Sharma et al. 2023) contre la lecture « compression LZ » (Abrahão et al. 2024) : solveur exact à deux implémentations, échelle périodique certifiée `ai = log2 n`, règle de décision scellée par pentes | +| [ict/stv-valence-symmetry-v2-pre-enregistrement.md](ict/stv-valence-symmetry-v2-pre-enregistrement.md) | Case 17bis — seconde opérationnalisation STV scellée avant le banc : observable d'entropie des classes de ratio du lock (correctif de l'aveuglement `CV` mesuré au case 17), drive découplé de la structure de verrouillage | ## Curriculum (docs/curriculum/) diff --git a/docs/ict/stv-valence-symmetry-v2-pre-enregistrement.md b/docs/ict/stv-valence-symmetry-v2-pre-enregistrement.md new file mode 100644 index 00000000000..3ff887ebbdc --- /dev/null +++ b/docs/ict/stv-valence-symmetry-v2-pre-enregistrement.md @@ -0,0 +1,88 @@ +# Pré-enregistrement — STV v2 : seconde opérationnalisation (case 17bis : structure du lock ⟂ drive) + +> **Grade C explicite.** Ce document **scelle** le protocole de la seconde opérationnalisation de la tranche STV Gómez-Emilsson/Johnson de la veille [#8182](https://github.com/jsboige/CoursIA/issues/8182), **AVANT toute écriture du banc de mesure** — pattern case 6 → case 14 et case 3 → case 15 : quand le premier instrument est `NON CONCLUSIF_INSTRUMENT` pour une limite **mesurée**, la réponse est un **second instrument pré-enregistré**, jamais un amendement post-hoc du premier. Le banc (`ict/stv_valence_symmetry_v2.py`) vit dans un second commit de la même PR — l'antériorité portée par la relation de parenté des commits (leçon case 8c). +> +> **Cycle du 2026-10-24**, lane `myia-po-2023:CoursIA`. Claim posé sur [#8182](https://github.com/jsboige/CoursIA/issues/8182) au moment du lancement. + +## 0. Sources, cadre et thèse — hérités de la case 17, inchangés + +Les sources primaires, leur archivage au gisement, le crédit témoins et les spot-checks firsthand sont ceux du scellé case 17 ([`stv-valence-symmetry-pre-enregistrement.md`](stv-valence-symmetry-pre-enregistrement.md) §1) : Johnson *Principia Qualia* (2016), Gómez-Emilsson « STV 2020 Overview », Johnson 2023 — **aucune nouvelle source n'est requise** : la thèse testée est la même, seul l'instrument change. La question falsifiable est la même : *l'attracteur suit-il la consonance, indépendamment du drive, et la cohérence brute sans structure harmonique se distingue-t-elle de la cohérence harmonique ?* + +**Héritage direct du scellé v1/v3** (non re-spécifié ici, repris tel quel) : le couplage `H(φ) = Σ_{h≤4} sin(hφ)/h` à contenu harmonique fixe non accordé ; σ = harmonicité octave-repliée `p, q ≤ 4`, `τ = 0.03` ; le tirage des configurations (`draw_configs` v3 : échelle à membres exacts/décalés ±3-8 %, étal apparié ; bras N = 6 proches + 2 irrationnels) ; graines de test `(0, 1, 7, 42, 99)`, graines de calibration disjointes `(11, 22, 33)` ; DT = 5e-4, T = 40, sous-échantillonnage 10 ; `M = 120` configurations + `40` paires H/N par graine. + +## 1. Les deux limites mesurées qui fondent cette seconde opérationnalisation + +Le run case 17 ([§7 du scellé](stv-valence-symmetry-pre-enregistrement.md)) a verdicté `NON CONCLUSIF_INSTRUMENT (null b)` et **rapporté** (pas réparé) deux limites d'instrument : + +1. **L'observable de P3 est aveugle au contraste qu'elle vise.** `CV(r)` mesure le battement de la cohérence brute ; le bras N y atteint la cohérence **maximale** (collapse 1:1 parfait, r̄(N) = 0.9999) au lieu de la « cohérence sans structure » attendue. Le discriminateur jhana/crise de la source (« high coherence alone is insufficient — must be harmonic structure ») exige un observable qui lit la **structure** du lock, pas sa seule existence. +2. **La perturbation d'énergie v1 passe par l'hétérogénéité d'amplitude** (`a_i ∈ {1 ± 0.1}` dans le produit `a_i·a_j` du couplage) : le drive modifie alors **par paire** la force de couplage effective, et c'est ce canal — pas un lien valence-énergie — qui a produit `|ρ(v, E)| = 0.31-0.42` (échec P2). La dissociation « attracteur ⟂ énergie » exige que le drive ne décide pas de la structure de verrouillage. + +## 2. Les deux correctifs d'instrument (et uniquement eux) + +### 2.1 — Observable de structure du lock (correctif de la limite 1) + +Pour chaque paire verrouillée (critères v3 inchangés : concentration circulaire < 1.5 rad **et** |dψ/dt| < 0.03 rad/unité sur la seconde moitié, meilleur candidat (m, n) ≤ 4 par écart-type circulaire minimal), on enregistre la **classe du ratio** `m/n` repliée à ses valeurs distinctes : **{1:1, 4:3, 3:2, 2:1, 3:1, 4:1} — 6 classes**. + +**Score de structure** : `S = −Σ_c p_c·ln p_c / ln(6)` — entropie de Shannon normalisée (nats) de la distribution des classes **parmi les paires verrouillées** de la configuration. `S = 0` si toutes les paires verrouillées sont dans la même classe ; `S → 1` si elles se répartissent uniformément sur les 6 classes. Si aucune paire n'est verrouillée, S n'est pas défini et la configuration n'entre pas dans la jambe P3 (déclaré ; le compte des exclusions figure dans les résultats). + +**Anti-circularité** (même discipline que v pour σ) : la **classe** est lue sur la dynamique (quel couple (m, n) s'est **installé**), jamais sur le ratio naturel. Une paire de rapport naturel 2.05 qui ne verrouille pas ne contribue **pas** ; une paire de rapport 2.0 qui verrouille à 2:1 le doit à la dynamique. Le contenu informatif de S est le **fait que des locks structurés s'installent**, pas la géométrie du tirage. + +**Lecture STV du contraste** : bras H (échelle octave) = analogue jhana — cohérent **et** structurellement riche (locks 2:1, 3:1, 3:2…) ; bras N (quasi-unisson + irrationnels) = analogue crise — cohérent **trivialement** (collapse 1:1, S ≈ 0). + +### 2.2 — Régime de drive uniforme (correctif de la limite 2) + +Amplitudes `a_i ≡ 1` **partout** (le tirage v3 les fixe déjà à 1 ; la perturbation v1 était la seule source d'hétérogénéité — elle est retirée). La dimension « énergie » devient le **drive global uniforme** : `K_eff = K2_c·(1+ε)`, `ε ∈ {−0.10, 0, +0.10}` — le drive agit sur le niveau global de couplage, **jamais par paire**. P2bis teste si `v` suit ce drive (ce que la STV nie : « it is the end result, the attractor ») ou la configuration (ce qu'elle affirme). + +**Portée déclarée du correctif** : avec `a_i ≡ 1`, « énergie » et « force de couplage » sont la même variable — le test v2 porte le canal qui restait après fermeture du canal par-paire. C'est une restriction honnête du claim opérationalisé, pas une victoire par construction : P2bis peut encore échouer (v peut suivre le drive global). + +### 2.3 — Fenêtre de calibration re-ciblée sur l'observable réelle + +La calibration v1 gelait `K_c` sur `r̄(H) ∈ [0.5, 0.8]` — or `r` est **aveugle aux locks m:n** (constat v2-amendement, §6bis du scellé v1) : la fenêtre garantissait un régime de collapse 1:1, pas un régime de langues m:n. v2 gèle `K2_c` sur la lecture de l'instrument lui-même : **`v̄(u=1) ∈ [0.5, 0.8]`** (fraction verrouillée de l'échelle octave **exacte**, u = 1) sur les graines de calibration `(11, 22, 33)`, balayée sur la même grille `[4, 8, 16, 24, 32, 48, 64, 96, 128]`. Repli déclaré si la fenêtre est inatteignable : `K2_c` à **variance de v sur l'échelle u maximale** (sensibilité d'instrument, neutre en signe). + +## 3. Prédictions scellées (aucune bande ne sera recalibrée après mesure) + +| # | Prédiction | Bande / critère | +|---|---|---| +| **P1** (attracteur ∼ consonance — inchangée) | ρ de Spearman ρ(v, σ) sur l'échelle de consonance, à ε = 0 | ≥ **0.6** sur ≥ 4/5 graines | +| **P2bis** (dissociation drive) | Corrélation partielle de Spearman v ∼ ε **contrôlée par le décile de σ** (rangs résiduels par décile, jambe ε ∈ {−0.1, 0, +0.1} de chaque configuration) : \|ρ(v, ε \| σ-décile)\| | ≤ **0.2** sur ≥ 4/5 graines | +| **P3bis** (le discriminateur jhana/crise, par la structure) | À cohérence brute appariée (\|r̄(H) − r̄(N)\| ≤ 0.15 — **porte d'appariement**, voir gates) : `ΔS = S(H) − S(N)` par graine (moyenne sur les paires) | ≥ **0.25** sur ≥ 4/5 graines | +| **Null (a)** | σ permuté (étiquettes mélangées) : ρ(v, σ-permuté) | \|ρ\| ≤ 0.2 en médiane 5 graines | +| **Null (a3)** | Étiquettes H/N permutées : ΔS-permuté | \|ΔS\| ≤ 0.05 en médiane 5 graines | +| **Null (b)** | Couplage fort (K2_c × 8) : ρ(v, σ) | < 0.2 → `NON CONCLUSIF_INSTRUMENT` (régime saturation) | +| **Contrôle mécanique** | K_eff = 0 sur configurations **irrationnelles** (tirage dissident) : phases libres, le détecteur ne compte rien | v(K=0, irrationnelles) ≤ **0.05** sur 5/5 graines | + +**Note de contrôle (défaut analytique détecté en concevant le banc, corrigé AVANT le commit du scellé — motif 6bis du v1 : un critère insatisfaisable par construction n'est pas une prédiction).** Les membres **exact** de l'échelle octave sont commensurables : une paire de rapport naturel 2/1, 3/1, 4/1, 3/2, 4/3 possède un couple (m, n) ≤ 4 dont la phase combinée est **stationnaire même à couplage nul** (ψ = constante cinématique — concentration et dérive nulles satisfaites sans aucun verrouillage). À K_eff = 0 ces paires sont donc comptées par le détecteur : v(K=0, échelle exacte) ≈ 20/28 = 0.71 **par construction**, pas par bug. Le contrôle mécanique porte donc sur les configurations **irrationnelles** (dérive ≥ DISSIDENT_DIST ≫ SLOPE_TOL à couplage nul → aucun compte attendu). En complément **diagnostique déclaré** (pas une porte) : v(K=0) sur échelle exacte est mesuré et rapporté — c'est le plafond cinématique du détecteur. Au point de travail K2_c > 0, l'argument cinématique ne tient plus : le couplage avec les membres incommensurables injecte dans chaque phase des composantes aux fréquences des autres, détruisant la stationnarité des paires non réellement entraînées (mesuré v1 : v max 0.536 ≪ 0.71 à K_c = 32) — la part cinématique de v au point de travail est une question empirique, déclarée ici, tranchée par les résultats. + +**Portes instrumentales** (leçon cases 8b/8c/16/17) : + +- `v̄(u=1) < 0.3` (plancher : l'échelle exacte n'entraine pas) sur ≥ 3/5 graines → `NON CONCLUSIF_INSTRUMENT` ; +- `v̄(u=0) > 0.7` (plafond : tout entraine, y compris l'échelle entièrement décalée) sur ≥ 3/5 graines → `NON CONCLUSIF_INSTRUMENT` ; +- **porte d'appariement P3bis** : `|r̄(H) − r̄(N)| > 0.15` sur ≥ 3/5 graines → P3bis `NON CONCLUSIF_INSTRUMENT` (le contraste serait porté par le niveau de cohérence, pas par la structure). + +## 4. Verdicts bornés + +- **SUPPORTED** : P1 ∧ P2bis ∧ P3bis ∧ Null (a) ∧ Null (a3) ∧ contrôle mécanique, aucune porte (les trois régimes : l'attracteur suit la consonance pas le drive ; la cohérence sans structure se distingue de la cohétrie harmonique). +- **NOT SUPPORTED** : P1 < 0.2 (l'attracteur est indifférent à la consonance même à régime propre), ou |ρ(v, ε)| > 0.5 (c'est le drive qui porte tout — rejet direct du « not the energy »), ou ΔS < 0.10 (structure indiscernable entre bras même par la structure du lock). +- **NON CONCLUSIF_INSTRUMENT** : Null (b), une porte instrumentale, la porte d'appariement, ou échec du contrôle mécanique. + +## 5. Honnêteté grade C (limites — cumul du scellé v1 §6 et des siennes) + +1. **Tout ce que §6 du scellé v1 déclarait reste vrai** : aucune phénoménologie ni valence émotionnelle n'est mesurée ; P1 reste partiellement vraie par la physique des langues d'Arnold (la charge de substance reste P2bis + P3bis) ; Plomp-Levelt/octave-replié comme modèle de σ est un choix déclaré ; la STV est déclarée robuste à l'échec algorithmique par ses auteurs ; le substrat Kuramoto est partagé avec les cases 6/14 à observables distincts. +2. **S hérite partiellement de la configuration** : les classes disponibles dépendent des détunings naturels (une paire d'écart 16:1 ne peut pas verrouiller à (m, n) ≤ 4). La jambe dynamique est que le lock **s'installe** — mais un partisan de la STV ne pourrait pas revendiquer S comme mesure phénoménologique ; c'est un discriminateur de substrat. +3. **Le plafond structurel v1 demeure** : seuls 20 des 28 couples de l'échelle octave ont un candidat (m, n) ≤ 4 — v reste borné par ~0.71 au régime m:n (déjà déclaré v1 §6ter.2) ; S le partage. +4. **La porte d'appariement est déclarée, pas garantie** : si le bras N ne collapse pas 1:1 à K2_c gelé (régime différent du run v1), P3bis peut être non concluant pour appariement — c'est un résultat honnête, pas un échec de thèse. +5. **Second instrument ≠ clôture** : même SUPPORTED, la case 17bis dit « oui, sur jouet, avec un instrument qui lit la structure » — rien de plus (pattern 6 → 14 : deux opérationnalisations, une thèse, jamais une validation). +6. **Commensurabilité cinématique** (cf. note de contrôle §3) : à couplage nul, les paires exactes commensurables satisfont les critères du détecteur sans verrouillage. Au point de travail, la perturbation croisée des membres incommensurables détruit cette stationnarité gratuite — mais la part résiduelle de v et de S(H) qui reste cinématique **n'est pas séparée** par cet instrument ; elle est déclarée, plafonnée par le diagnostic v(K=0, échelle exacte), et reportée dans les résultats. + +## 6. Anti-duplication + +Case 17 v1/v3 = instrument n° 1 (`NON CONCLUSIF_INSTRUMENT`, conservé tel quel — jamais réécrit) ; la présente = instrument n° 2 du **même claim**. Distinct de : case s ⟂ π (canaux saillance/valence, [#9553](https://github.com/jsboige/CoursIA/pull/9553)) ; cases 6/14 (frontière topologique, autre claim du même premier auteur) ; case 16 (MPS alertness). La ligne matrice `dissociations-matrix.md` ne sera **pas** éditée dans cette PR — deux PRs ouvertes (#22270, #22289) touchent déjà ce fichier ; la mise à jour de la ligne case 17 → 17bis est différée à une PR dédiée une fois celles-ci mergées. + +## 7. Ce qui suit + +1. **Ce document, committé, est le scellé.** Antériorité par parenté de commits (leçon case 8c). +2. Le banc `ict/stv_valence_symmetry_v2.py` + tests + artefact de résultats : second commit de la même PR (pattern #17164). Calibration (graines 11/22/33) → gel K2_c → run principal (5 graines) → nulls → JSON committé. +3. Verdict rapporté sur [#8182](https://github.com/jsboige/CoursIA/issues/8182) avec les mesures brutes par graine. +4. Statut au scellé : **`PRÉDIT` — banc non écrit.** + +*See [#8182](https://github.com/jsboige/CoursIA/issues/8182) — la veille ne se clôt pas sur une tranche.*