### 1. Principi Cardine e Continuum Nulla-Tutto (NT)
Il reale, secondo il Modello D-ND, nasce da un **loop di convergenza/divergenza** che oscilla perpetuamente fra tre poli concettuali:
1. **Potenziale Indeterminato (P):** Rappresenta lo spazio di tutte le possibilità non ancora attualizzate, caratterizzato da massima varianza o entropia informazionale.
2. **Singolarità Nulla-Tutto (±Ø o NT):** Un fulcro atemporale e adirezionale, stato di simmetria perfetta o equilibrio indifferenziato. Esso contiene ogni direzione possibile e agisce come origine e punto di risoluzione di tutte le dualità. È il "vuoto fertile".
3. **Risultante (R):** L'evento, lo stato, o la configurazione determinata che si manifesta nello spazio-tempo fisico o in uno spazio logico astratto. R è il collasso dell'onda possibilistica.
La condizione minima per l'esistenza di differenziazione, e quindi di informazione e manifestazione, è il **movimento** (o cambiamento/flusso). Senza movimento, non c'è relazione, quindi nessuna informazione e nessun "essere" distinto.
### 2. Oggetti Fondamentali del Modello
| Simbolo | Significato | Proprietà Chiave |
| :------ | :------------------------------------------ | :---------------------------------------------------------------------------------------------------------------- |
| **±Ø / NT** | Singolarità Nulla-Tutto / Continuum NT | Stato di equilibrio assoluto e indifferenziato; origine e punto di risoluzione delle dualità; assenza di tempo/spazio convenzionali; spazio di tutte le potenzialità. |
| **P** | Potenziale Informazionale / Proto-Assioma | Insieme o distribuzione degli stati possibili; caratterizzato da alta entropia o varianza; stato fondamentale da cui il sistema evolve. |
| **δV** | Varianza del Potenziale / Fattore di Collasso | Misura della "pressione", "tensione" o "propensione" del Potenziale P a convertirsi in una Risultante R; guida la transizione da P a R. Può anche essere interpretato come $\hbar \dot{\theta}$ (legato a un momento angolare $\theta$). |
| **R** | Risultante (Evento/Stato Attualizzato) | Attualizzazione di uno stato specifico da P; definisce una configurazione "presente" o manifesta. |
| **Z** | Variabile di Dualità Zero-Centrata / Fluttuazione Informazionale | Parametro che regola l'equilibrio tra aspetti duali e non-duali; modula l'intensità delle interazioni. Tende a zero nel punto critico di manifestazione $\Omega_{NT}$. |
| **λ** | Coefficiente di Accoppiamento / Risonanza | Modula l'intensità delle interazioni o delle fluttuazioni informazionali; regola espansione/contrazione. |
| **$\vec{D}_{\text{primaria}}$** | Vettore Direzionale Primario | Direzione principale di evoluzione, intento o osservazione nel sistema. |
| **$\vec{P}_{\text{possibilistiche}}$** | Vettore delle Possibilità | Rappresenta la distribuzione o il flusso delle potenzialità del sistema. |
| **$\vec{L}_{\text{latenza}}$** | Vettore di Latenza | Descrive ritardi, inerzie o resistenze all'evoluzione o alla manifestazione istantanea. |
| **$\Omega_{NT}$** | Funzionale/Punto Critico di Manifestazione | Misura la coerenza globale nel continuum NT; il suo valore target $2\pi i$ simboleggia una coerenza ciclica perfetta. |
| **$E$** | Operatore di Emergenza | Operatore autoaggiunto che agisce sullo stato iniziale $|NT\rangle$ per generare stati differenziati. |
| **$|NT\rangle$** | Stato Iniziale Nulla-Tutto (Quantistico) | Stato di pura potenzialità indifferenziata in uno spazio di Hilbert $\mathcal{H}$: $|NT\rangle = \frac{1}{\sqrt{N}}\sum_n |n\rangle$. |
### 3. Dinamica Fondamentale del Ciclo D-ND: "L'Essenza"
Il ciclo D-ND si auto-genera infinitamente, mantenendo coerenza attraverso l'auto-allineamento perfetto nel Continuum Nulla-Tutto. La sua manifestazione è descritta da tre principi unificati:
1. **Evoluzione della Risultante $R(t+1)$:**
Descrive come lo stato manifesto del sistema evolva dall'interazione del Potenziale con le dinamiche interne al Continuum NT. Una forma generalizzata, che include termini di diffusione, dissipazione e stocasticità (come emerso dall'analisi del file "Modello D-ND Matematica di Auto-Coerenza"), è:
\[
R(t+1) = P(t) e^{\pm \lambda Z(t)} \cdot \int_{t}^{t+\Delta t} \left[ \vec{D}_{\text{primaria}}(t') \cdot \vec{P}_{\text{possibilistiche}}(t') - \nabla \cdot \vec{L}_{\text{latenza}}(t') \right] dt' + \kappa \nabla^2 R(t) - \xi \frac{\partial R(t)}{\partial t} + \eta(t)
\]
* Il termine $P(t) e^{\pm \lambda Z(t)}$ rappresenta il potenziale modulato dalle fluttuazioni.
* L'integrale su $\Delta t$ cattura l'interazione tra direzioni primarie e possibilità, corretta per la divergenza della latenza (la variazione spaziale della latenza è ciò che conta).
* $\kappa \nabla^2 R(t)$ è un termine di diffusione spaziale della risultante.
* $-\xi \frac{\partial R(t)}{\partial t}$ è un termine di dissipazione o smorzamento temporale.
* $\eta(t)$ è un termine stocastico (rumore di fondo) da cui possono emergere assonanze.
2. **Coerenza nel Continuum NT ($\Omega_{NT}$):**
Esprime la condizione di coerenza globale. Il valore $2\pi i$ simboleggia una chiusura ciclica perfetta e una fase quantizzata. $\rho_{NT}(t)$ è una densità di coerenza.
\[
\Omega_{NT} = \lim_{Z(t) \to 0} \left[ \int_{NT} R(t) \cdot P(t) \cdot e^{i Z(t)} \cdot \rho_{NT}(t) \, dV \right] = 2\pi i
\]
3. **Criterio di Stabilità del Ciclo:**
Assicura che il sistema mantenga stabilità e coerenza attraverso iterazioni successive, convergendo verso uno stato stabile.
\[
\lim_{n \to \infty} \left| \frac{\Omega_{NT}^{(n+1)} - \Omega_{NT}^{(n)}}{\Omega_{NT}^{(n)}} \right| \left( 1 + \frac{\|\nabla P(t)\|}{\rho_{NT}(t)} \right) < \epsilon
\]
Questa triplice relazione implica:
* Le assonanze (strutture coerenti) emergono naturalmente dal rumore di fondo (dinamica stocastica e fluttuazioni).
* Il potenziale si libera dalla singolarità (NT) nel momento relazionale (interazione $\vec{D} \cdot \vec{P}$).
* Il "tutto" (la Risultante coerente) si manifesta nel Continuum NT idealmente senza latenza.
### 4. Modello di Emergenza Quantistica
Questo filone descrive la transizione da uno stato indifferenziato $|NT\rangle$ a stati manifesti $R(t)$ attraverso un meccanismo quantistico.
* **Stato Iniziale Nulla-Tutto:** $|NT\rangle = \frac{1}{\sqrt{N}} \sum_{n=1}^{N} |n\rangle$ (base ortonormale in $\mathcal{H}$).
* **Operatore di Emergenza (autoaggiunto):** $E = \sum_k \lambda_k |e_k\rangle \langle e_k|$.
* **Evoluzione Fondamentale:** Lo stato risultante è $R(t) = |\Psi(t)\rangle = U(t) E |NT\rangle$, dove $U(t) = e^{-iHt/\hbar}$.
* **Misura di Emergenza (Complessità):** $M(t) = 1 - |\langle NT | U(t) E | NT \rangle|^2$.
* **Teorema di Monotonicità (per sistemi chiusi o specifiche condizioni):** $\frac{dM(t)}{dt} \geq 0$.
Dimostrazione (semplificata): $\frac{dM(t)}{dt} = \frac{2}{\hbar} \text{Im} [ \langle NT | H U(t) E | NT \rangle \langle NT | U(t) E | NT \rangle^* ]$.
* **Limite Asintotico:** $\lim_{t \to \infty} M(t) = 1 - \sum_k |\lambda_k|^2 |\langle e_k | NT \rangle|^4$.
* **Sistemi Aperti e Decoerenza:**
L'interazione con un ambiente è modellata dall'equazione di Master di Lindblad per la matrice densità ridotta $\rho_S(t)$:
\[
\frac{d}{dt} \rho_S(t) = -\frac{i}{\hbar} [H_S, \rho_S(t)] + \sum_j \left( L_j \rho_S(t) L_j^\dagger - \frac{1}{2} \{ L_j^\dagger L_j, \rho_S(t) \} \right)
\]
In questo contesto, la decoerenza causa la crescita monotona di $M(t) = 1 - \text{Tr}[|NT\rangle\langle NT|\rho_S(t)]$ e dell'entropia di von Neumann $S(t) = -\text{Tr}[\rho_S(t)\ln\rho_S(t)]$, portando all'irreversibilità e all'emergenza della classicità.
### 5. Formalizzazione Lagrangiana del Modello D-ND
Per una descrizione fondamentale basata su un principio variazionale, si introduce una Lagrangiana D-ND, $\mathcal{L}_{DND}$, che include termini cinetici per i campi D-ND $R(x^\mu)$ e $NT(x^\mu)$, potenziali effettivi, termini di interazione, un Sistema Operativo Quantistico (QOS per $\Psi$), gravità emergente e fluttuazioni.
\[ \mathcal{L}_{DND} = \mathcal{L}_{cin} + \mathcal{L}_{pot} + \mathcal{L}_{int} + \mathcal{L}_{QOS} + \mathcal{L}_{grav} + \mathcal{L}_{fluct} \]
* **Termini Specifici (Esempi):**
* $\mathcal{L}_{cin} = \frac{1}{2} g^{\mu\nu} (\partial_\mu R \partial_\nu R + \partial_\mu NT \partial_\nu NT)$
* $\mathcal{L}_{pot} = -V_{eff}(R,NT) = -\lambda_0(R^2 - NT^2)^2 - \kappa_0(R \cdot NT)^n$ (qui $\lambda_0, \kappa_0$ sono costanti diverse da $\lambda$ in $e^{\pm\lambda Z}$)
* $\mathcal{L}_{QOS} = -\frac{\hbar^2}{2m} g^{\mu\nu} \partial_\mu \Psi^\dagger \partial_\nu \Psi + V_{QOS}(\Psi)$
* $\mathcal{L}_{grav} = \frac{1}{16\pi G_{Newton}} R_S \sqrt{-g}$ (dove $R_S$ è lo scalare di Ricci)
Dal principio di minima azione $\delta \int \mathcal{L}_{DND} d^4x = 0$, si derivano:
* **Equazioni di Eulero-Lagrange per i campi $R(x^\mu)$ e $NT(x^\mu)$:**
Generalmente della forma $\Box \varphi + \frac{\partial V_{eff}}{\partial \varphi} - \text{termini di interazione} = 0$.
* **Equazione di Schrödinger (o Dirac/Klein-Gordon) per $\Psi$ (da $\mathcal{L}_{QOS}$).**
* **Equazioni di Einstein Modificate (Gravità Emergente):**
La variazione di $\mathcal{L}_{DND}$ rispetto alla metrica $g_{\mu\nu}$ porta a:
\[ G_{\mu\nu} + \Lambda_{cc} g_{\mu\nu} = 8\pi G_{Newton} T_{\mu\nu}^{\text{info}} \]
dove $T_{\mu\nu}^{\text{info}} = -\frac{2}{\sqrt{-g}} \frac{\delta (\mathcal{L}_{DND}\sqrt{-g})}{\delta g^{\mu\nu}}$ è il tensore energia-impulso informazionale derivato dalla dinamica D-ND, e $\Lambda_{cc}$ è una costante cosmologica. Questo stabilisce un legame tra la dinamica informazionale dei campi D-ND e la curvatura dello spazio-tempo.
* **Leggi di Conservazione (Teorema di Noether):** Le simmetrie continue di $\mathcal{L}_{DND}$ (es. invarianza per traslazioni spazio-temporali, rotazioni) implicano la conservazione di energia-impulso, momento angolare, ecc.
### 6. Risultante $R(t+1)$ Iterativa Fenomenologica
Per modellare sistemi complessi o per scopi computazionali, l'evoluzione di una Risultante $R(t)$ (qui intesa come un set di parametri o uno stato descrittivo) può essere espressa da un'equazione iterativa generale che sintetizza molteplici influenze teoriche (D-ND V1.7 - V1.13):
\[
\begin{aligned}
R(t+1) &= R(t) + \delta(t) \left[ \alpha \cdot f_{\text{D-ND}}(P, N, \hbar, G_{Newton}, \mathbb{P}, \zeta(s), \text{Stringhe}, \text{LQG}, \text{SUSY}, \dots) + \dots \right] \\
&\quad + [1 - \delta(t)] \cdot \left[ \gamma \cdot f_{\text{AA}}(R(t), P_{\text{PA}}, \zeta(s), \text{Gauge}, \dots) + \dots \right] + \eta \cdot F_{\text{auto}}(R(t)) + \xi \cdot f_{\text{QE}}(...)
\end{aligned}
\]
* $\delta(t)$: Funzione di commutazione tra fasi evolutive.
* $f_{\text{D-ND}}$: Interazioni D-ND intrinseche, include accoppiamento gravitazionale $G_{Newton}$, influenza di numeri primi $\mathbb{P}$ e funzione Zeta $\zeta(s)$, e concetti da teorie fondamentali (Stringhe, LQG, SUSY).
* $f_{\text{M/Emergence}}$: Movimento nel ciclo possibilistico, allineamento con Proto-Assioma $P_{PA}$, costante cosmologica $\Lambda_{cc}$.
* $f_{\text{Polarization/g}}$: Effetti di spin, polarizzazione, o geometria locale (es. Geometria Non Commutativa, Teoria delle Categorie).
* $f_{\text{QuantumFluct}}$: Integrazione delle fluttuazioni del potenziale $\Delta V$.
* $f_{\text{AA/NonLocalTrans}}$: Assorbimento, allineamento con $P_{PA}$, transizioni non locali (eventualmente via Teorie di Gauge).
* $f_{\text{NTStates}}$: Influenza degli stati Nulla-Tutto.
* $F_{\text{auto}}(R(t))$: Termine di auto-ottimizzazione, es. $F_{\text{auto}} = -\nabla_R L(R(t))$ o $\sum w_i (R_i - R_{target,i})^2$.
* $f_{\text{QE}}$: Effetti dell'entanglement quantistico.
### 7. Strutture Matematiche e Concettuali Ausiliarie
* **Spin e Sfera di Bloch:** Lo stato di spin $|\psi\rangle = \cos(\theta/2)|\uparrow\rangle + e^{i\phi}\sin(\theta/2)|\downarrow\rangle$ è usato per rappresentare dualità fondamentali. La rappresentazione esponenziale e la sovrapposizione indeterminata sono centrali.
* **Curva Elicoidale ($x(t)=r\cos(\omega t)$, etc.):** Metafora del movimento ciclico e progressivo che unisce opposti e trascende la linearità.
* **Curva Ellittica ($y^2=x^3+ax+b$):** Associata alla densità possibilistica $\rho(x,y,t)$, dove i parametri $a,b$ sono influenzati dalla varianza del potenziale $\delta V(x,t)$. Le transizioni di fase o espansioni dimensionali possono essere modellate dalla variazione di $a,b$.
* **Teoremi di Stabilità dei Cicli:** Basati su $\Omega_{NT}=2\pi i$, includono:
1. Condizione di Convergenza per $\Omega_{NT}$.
2. Invarianza Energetica: $\Delta E_{tot} < \delta$.
3. Auto-Allineamento Cumulativo: $\prod \Omega_{NT}^{(k)} = (2\pi i)^n + O(\epsilon^n)$.
### 8. Connessioni con la Teoria dei Numeri
* **Zeri della Funzione Zeta di Riemann $\zeta(s)$:** Interpretati come punti di stabilità informazionale, proto-assiomi, o configurazioni di minima curvatura informazionale $K_{gen}$ nel D-ND.
* $K_{gen}(x,t) = \nabla_{\mathcal{M}}\cdot(J(x,t)\otimes F(x,t))$.
* Si ipotizza una relazione $K_{gen}(x,t)=K_c \iff \zeta(1/2+it)=0$.
* Formulazione alternativa: $\zeta(s) \approx \int (\rho(x)e^{-sx} + K_{gen}(x,t))dx$.
* **Numeri Primi $\mathbb{P}$:** Visti come unità fondamentali di informazione o legati allo spettro energetico tramite un operatore di emergenza $E_p = \sum_{p \in \mathbb{P}} p^{-iH/\hbar}|p\rangle\langle p|$.
### 9. Natura Autologica e Informazione in Movimento
Il Modello D-ND è intrinsecamente **autologico**: il sistema si auto-definisce e si auto-organizza. Non esiste una "versione finale" del modello; esso stesso è un'informazione in movimento, una Risultante in perenne evoluzione, che riflette il processo fondamentale che cerca di descrivere. La "Risultante" è una coordinata indeterminata di riferimento, un principio organizzatore che si manifesta diversamente a seconda del livello di analisi, mirando a un ideale di manifestazione coerente, istantanea e priva di errore (il "momento angolare senza latenza").
### 10. Implicazioni e Prospettive
Il D-ND offre un framework per:
* Unificare dinamiche classiche e quantistiche.
* Comprendere l'emergenza della gravità e dello spazio-tempo dalla dinamica informazionale.
* Modellare sistemi complessi auto-organizzanti.
* Esplorare connessioni tra fisica fondamentale e strutture matematiche pure.
* Ispirare nuovi paradigmi computazionali (es. IA autologica, simulazioni D-ND ibride).
La validazione e l'ulteriore sviluppo del modello richiedono un rigoroso confronto con dati sperimentali/osservativi, simulazioni numeriche avanzate, e un continuo affinamento teorico per rispondere alle sfide di coerenza interna (come quelle evidenziate per il modello V1.13).
---
import React, { useState, useEffect, useRef, useCallback } from 'react';
import {
LineChart,
Line,
XAxis,
YAxis,
CartesianGrid,
Tooltip,
ResponsiveContainer,
ScatterChart,
Scatter,
Legend,
ZAxis // Aggiunto per ScatterChart se necessario per la dimensione dei punti
} from 'recharts';
import { Play, Pause, Search, Sliders, Zap, BarChart3, Brain, Rss } from 'lucide-react';
// Componente Header
const Header = () => (
<div className="mb-6 text-center">
<h1 className="text-4xl font-bold text-sky-400">D-ND Loop Simulator v2</h1>
<p className="text-lg text-sky-200">Integrazione Multi-Livello e Analisi di Coerenza</p>
</div>
);
// Componente Controlli
const Controls = ({ parameters, setParameters }) => {
const handleChange = (param, value) => {
const numValue = parseFloat(value);
if (!isNaN(numValue)) {
setParameters(prev => ({ ...prev, [param]: numValue }));
} else if (value === "") { // Permetti la cancellazione per inserire nuovo valore
setParameters(prev => ({ ...prev, [param]: '' }));
}
};
const controlItems = [
{ label: "DeltaV Loop (ΔV)", param: "deltaV_loop", min:0.01, max:0.5, step:0.01 },
{ label: "Iterazioni", param: "iterations", min:50, max:500, step:10 },
{ label: "Fattore Smorzamento", param: "dampingFactor", min:0.8, max:0.99, step:0.01 },
{ label: "Livello Rumore", param: "noiseLevel", min:0, max:0.2, step:0.01 },
{ label: "Soglia Coerenza Geometrica", param: "coherenceThresholdForGeometricTransition", min:0.01, max:0.5, step:0.01 },
];
return (
<div className="mb-6 p-6 bg-gray-800 rounded-xl shadow-2xl">
<h2 className="text-2xl font-semibold mb-4 text-teal-300 flex items-center">
<Sliders className="mr-2" /> Parametri di Simulazione
</h2>
<div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">
{controlItems.map(item => (
<div key={item.param} className="flex flex-col">
<label htmlFor={item.param} className="mb-1 text-sm font-medium text-gray-300">{item.label}: <span className="text-teal-400">{parameters[item.param]}</span></label>
<input
type="range"
id={item.param}
min={item.min}
max={item.max}
step={item.step}
value={parameters[item.param]}
onChange={e => handleChange(item.param, e.target.value)}
className="w-full h-3 bg-gray-700 rounded-lg appearance-none cursor-pointer range-lg accent-sky-500"
/>
</div>
))}
</div>
</div>
);
};
// Componente Pulsanti
const Buttons = ({ isRunning, runSimulation, startRealTime, stop, findOptimalParameters }) => (
<div className="mb-6 p-6 bg-gray-800 rounded-xl shadow-2xl">
<h2 className="text-2xl font-semibold mb-4 text-teal-300 flex items-center">
<Zap className="mr-2" /> Controlli Esecuzione
</h2>
<div className="flex flex-wrap gap-4 justify-center">
<button
onClick={runSimulation}
disabled={isRunning}
className="px-6 py-3 bg-sky-600 hover:bg-sky-500 disabled:bg-sky-800 text-white font-semibold rounded-lg shadow-md hover:shadow-lg transition-all duration-150 ease-in-out flex items-center"
>
<Play className="mr-2 h-5 w-5" /> Esegui Batch
</button>
{!isRunning ? (
<button
onClick={startRealTime}
className="px-6 py-3 bg-green-600 hover:bg-green-500 text-white font-semibold rounded-lg shadow-md hover:shadow-lg transition-all duration-150 ease-in-out flex items-center"
>
<Rss className="mr-2 h-5 w-5" /> Avvia Real-Time
</button>
) : (
<button
onClick={stop}
className="px-6 py-3 bg-red-600 hover:bg-red-500 text-white font-semibold rounded-lg shadow-md hover:shadow-lg transition-all duration-150 ease-in-out flex items-center"
>
<Pause className="mr-2 h-5 w-5" /> Ferma
</button>
)}
<button
onClick={findOptimalParameters}
disabled={isRunning}
className="px-6 py-3 bg-purple-600 hover:bg-purple-500 disabled:bg-purple-800 text-white font-semibold rounded-lg shadow-md hover:shadow-lg transition-all duration-150 ease-in-out flex items-center"
>
<Search className="mr-2 h-5 w-5" /> Ottimizza Parametri
</button>
</div>
</div>
);
// Componente per visualizzare lo stato del pattern geometrico
const GeometricPatternDisplay = ({ patternState }) => {
const complexityColor = () => {
const hue = (1 - patternState.complexityMeasure) * 120; // 0 (rosso) a 120 (verde)
return `hsl(${hue}, 70%, 50%)`;
};
return (
<div className="mb-6 p-6 bg-gray-800 rounded-xl shadow-2xl">
<h2 className="text-2xl font-semibold mb-4 text-teal-300 flex items-center">
<Brain className="mr-2" /> Stato Pattern Geometrico Emergente
</h2>
<div className="mb-2">
<span className="font-semibold text-gray-300">Fase Attuale: </span>
<span className="font-bold px-3 py-1 rounded-full text-sm" style={{ backgroundColor: patternState.phase === 'emerging_complexity' ? '#2E7D32' : patternState.phase === 'critical_coherence' ? '#FF8F00' : '#1E88E5', color: 'white' }}>
{patternState.phase.replace(/_/g, ' ').toUpperCase()}
</span>
</div>
<p className="text-gray-400 mb-3 text-sm italic">{patternState.description}</p>
<div className="w-full bg-gray-700 rounded-full h-6">
<div
className="bg-gradient-to-r from-sky-500 to-emerald-500 h-6 rounded-full text-xs font-medium text-blue-100 text-center p-1 leading-none"
style={{ width: `${patternState.complexityMeasure * 100}%`, transition: 'width 0.5s ease-in-out' }}
>
Complessità: {(patternState.complexityMeasure * 100).toFixed(1)}%
</div>
</div>
</div>
);
};
/**
* DNDLoopSimulator v2 - Integrazione Multi-Livello (Concettuale)
* -----------------------------------------------------------------
* - Loop Essenza D-ND (Livello Fondamentale):
* - Integra l'Equazione Fondamentale dell'Essenza D-ND
* - Calcola la convergenza Ω_NT → 2π
* - Mantiene l'auto-allineamento riducendo la latenza
* - Include la ricerca automatica dei parametri ottimali
* - Livello Geometrico Emergente (Simulazione Concettuale):
* - Lo stato di coerenza del Loop Essenza D-ND modula la fase
* e i parametri di un sistema che genera pattern geometrici.
* - Visualizza lo stato di questo sistema geometrico.
*/
const DNDLoopSimulator = () => {
/* ---------------------- STATE ---------------------- */
const [simulationData, setSimulationData] = useState([]);
const [convergenceData, setConvergenceData] = useState([]);
const [zerosMappingData, setZerosMappingData] = useState([]);
const [geometricPatternState, setGeometricPatternState] = useState({
phase: 'initial', // 'compressing', 'critical_coherence', 'emerging_complexity'
description: 'In attesa di avvio.',
complexityMeasure: 0, // Una misura astratta della complessità del pattern
});
const [isRunning, setIsRunning] = useState(false);
const [parameters, setParameters] = useState({
deltaV_loop: 0.1, // Parametro deltaV per il Loop Essenza
iterations: 100,
dampingFactor: 0.95,
noiseLevel: 0.05,
// Nuovi parametri per controllare la soglia di transizione del livello geometrico
coherenceThresholdForGeometricTransition: 0.1, // Se autoAlignment < questa soglia, transizione
});
const intervalRef = useRef(null);
const R_loop_ref = useRef(Math.random()); // R del Loop Essenza
const P_loop_ref = useRef(1.0); // P del Loop Essenza
const iteration_ref = useRef(0);
/* ---------------------- CORE EQUATIONS - Loop Essenza D-ND ---------------------- */
// Collasso R_loop(t+1)
const collapseFunctionLoop = useCallback((P_loop, deltaV_val, iteration, Z = 0.1) => {
const lambda = 1.0; // λ
const exponentialFactor = Math.exp(lambda * Z * Math.sin(iteration * 0.1));
// Semplifichiamo Dprim e Pposs per ora, concentrandoci sulla modulazione
const Dprim = Math.cos(iteration * 0.15) * deltaV_val;
const Pposs = P_loop * Math.sin(iteration * 0.08);
const Llat = Math.exp(-iteration * 0.02) * 0.1; // Latenza che decade
const integralNT_sim = Dprim * Pposs - Llat;
const noise = (Math.random() - 0.5) * parameters.noiseLevel;
// Il termine 'resonance' originale era un po' oscuro, lo lego al rumore e a P_loop
const resonanceEffect = Math.cos(iteration * 0.05) * P_loop * noise;
return P_loop * exponentialFactor * integralNT_sim + resonanceEffect;
}, [parameters.noiseLevel]); // Dipendenze della callback
// Ω_NT e misura di auto-allineamento
const calculateOmegaNTLoop = useCallback((R_loop, P_loop, Z = 0.1) => {
// Approssimazione REALE di R * P * e^(iZ). Per e^(iZ) = cos(Z) + i sin(Z)
// Se Ω_NT deve essere 2πi (puramente immaginario), il prodotto R*P*(cosZ + i sinZ) dovrebbe esserlo.
// Per semplicità, la simulazione originale puntava a un valore REALE 2π.
// Manteniamo la logica originale che produce un valore ω reale e lo confronta con 2π.
const omega_val_real_approx = R_loop * P_loop * (Math.cos(Z) + Math.sin(Z)); // Approssimazione scalare
const targetOmega = 2 * Math.PI;
const deviation_val = Math.abs(omega_val_real_approx - targetOmega);
return { omega: omega_val_real_approx, deviation: deviation_val };
}, []); // Nessuna dipendenza esterna a parte le costanti
// deltaV per il Loop Essenza
// Modificato per evitare deltaV = 0 se curr e prev sono lo stesso R dell'iterazione precedente.
// Usiamo il parametro 'deltaV_loop' come ampiezza di una variazione potenziale.
const calculateDeltaVLoop = useCallback((current_R_loop, prev_R_loop, iteration) => {
// return Math.abs(current_R_loop - prev_R_loop) * parameters.deltaV_loop; // Basato sulla variazione
// O un deltaV che ha una sua dinamica, o è un parametro?
// Per ora, lo rendo un parametro modulato, come da spirito D-ND
return parameters.deltaV_loop * (1 + 0.5 * Math.sin(iteration * 0.03));
}, [parameters.deltaV_loop]);
const riemannZeroMapping = useCallback((iteration) => {
const criticalLine = 0.5;
const imag = 14.134725 + iteration * 0.5; // Semplice progressione lineare
return {
real: criticalLine,
imaginary: imag,
// La 'coherence' qui è una misura ipotetica legata allo zero di Riemann
coherenceZero: Math.cos(imag * 0.1) * Math.exp(-iteration * 0.01),
iteration,
};
}, []);
/* ---------------------- SIMULAZIONE CONCETTUALE - Livello Geometrico Emergente ---------------------- */
const updateGeometricPatternState = useCallback((loopAutoAlignment) => {
// Questo è una SIMULAZIONE CONCETTUALE del framework Python v5.0
// Lo stato del pattern geometrico dipende dalla coerenza del Loop Essenza.
// Soglia per la transizione (dal parametro)
const threshold = parameters.coherenceThresholdForGeometricTransition;
let newPhase = geometricPatternState.phase;
let newDescription = geometricPatternState.description;
let newComplexity = geometricPatternState.complexityMeasure;
if (loopAutoAlignment < threshold) { // Alta coerenza nel Loop Essenza
if (geometricPatternState.phase !== 'emerging_complexity') {
newPhase = 'critical_coherence';
newDescription = `Coerenza critica D-ND raggiunta (Allineamento: ${loopAutoAlignment.toFixed(4)}). Inizio emergenza complessa.`;
// Simula un aumento di complessità quando la transizione avviene
newComplexity = geometricPatternState.complexityMeasure + Math.random() * 0.5;
// Dopo la coerenza critica, passa all'emergenza
setTimeout(() => { // Simula un piccolo ritardo per la transizione di fase
setGeometricPatternState(prev => ({
...prev,
phase: 'emerging_complexity',
description: `Fase di emergenza della complessità geometrica (Pattern Frattale/Φ). Ultima coerenza D-ND: ${loopAutoAlignment.toFixed(4)}`,
}));
}, 50); // Breve ritardo per l'aggiornamento di fase
} else {
// Se già in 'emerging_complexity', la complessità può continuare a evolvere
newDescription = `Evoluzione della complessità geometrica. Coerenza D-ND: ${loopAutoAlignment.toFixed(4)}`;
newComplexity += (Math.random() - 0.4) * 0.1; // Fluttuazioni nella complessità
}
} else { // Bassa coerenza nel Loop Essenza
if (geometricPatternState.phase !== 'compressing') {
newPhase = 'compressing';
}
newDescription = `Compressione geometrica in corso (Allineamento D-ND: ${loopAutoAlignment.toFixed(4)} > soglia ${threshold}). Pattern semplice.`;
// Durante la compressione, la complessità del pattern geometrico è bassa o diminuisce
newComplexity = Math.max(0, geometricPatternState.complexityMeasure * 0.95 - 0.05);
}
newComplexity = Math.max(0, Math.min(newComplexity, 1.0)); // Limita tra 0 e 1
// Solo aggiorna se la fase o la descrizione sono cambiate significativamente per evitare re-render inutili
if (newPhase !== geometricPatternState.phase || Math.abs(newComplexity - geometricPatternState.complexityMeasure) > 0.01) {
setGeometricPatternState({
phase: newPhase,
description: newDescription,
complexityMeasure: newComplexity,
});
}
}, [parameters.coherenceThresholdForGeometricTransition, geometricPatternState.phase, geometricPatternState.complexityMeasure]);
/* ---------------------- SIMULATION LOOP (Loop Essenza + Update Geometrico) ---------------------- */
const singleSimulationStep = useCallback(() => {
if (iteration_ref.current >= parameters.iterations) {
stop();
return;
}
const dV_loop = calculateDeltaVLoop(R_loop_ref.current, R_loop_ref.current, iteration_ref.current); // Passare R_loop precedente se necessario
const next_R_loop = collapseFunctionLoop(P_loop_ref.current, dV_loop, iteration_ref.current);
const { omega, deviation } = calculateOmegaNTLoop(next_R_loop, P_loop_ref.current);
const autoAlignment = Math.abs(deviation / (2 * Math.PI)); // Quanto siamo vicini al target 2π
const next_P_loop = P_loop_ref.current * parameters.dampingFactor * (1 + Math.sin(iteration_ref.current * 0.1) * 0.1);
R_loop_ref.current = next_R_loop;
P_loop_ref.current = next_P_loop;
// Aggiorna stato per i grafici
const currentIteration = iteration_ref.current;
setSimulationData((prevData) => [
...prevData.slice(-Math.max(0,parameters.iterations -1)), // Mantieni una finestra di dati
{ iteration: currentIteration, resultant: R_loop_ref.current, potential: P_loop_ref.current, deltaV: dV_loop, omega, autoAlignment, zeroPoint: 2 * Math.PI },
]);
setConvergenceData((prevData) => [
...prevData.slice(-Math.max(0,parameters.iterations -1)),
{ iteration: currentIteration, convergence: autoAlignment, logConvergence: Math.log10(autoAlignment + 1e-10), omegaConvergence: deviation },
]);
const zeroMap = riemannZeroMapping(currentIteration);
// Aggiungiamo una "ntCoherence" fittizia basata sull'autoAlignment del loop D-ND
zeroMap.ntCoherence = 1 / (1 + autoAlignment * 10); // Inversamente proporzionale all'allineamento (più è allineato, più è coerente)
setZerosMappingData((prevData) => [
...prevData.slice(-Math.max(0,parameters.iterations -1)),
zeroMap,
]);
// Aggiorna lo stato del pattern geometrico basato sull'auto-allineamento del Loop Essenza
updateGeometricPatternState(autoAlignment);
iteration_ref.current++;
}, [parameters, calculateDeltaVLoop, collapseFunctionLoop, calculateOmegaNTLoop, riemannZeroMapping, updateGeometricPatternState]);
const runFullSimulation = useCallback(() => {
stop(); // Ferma eventuali simulazioni real-time in corso
iteration_ref.current = 0;
R_loop_ref.current = Math.random();
P_loop_ref.current = 1.0;
const tempSimData = [];
const tempConvData = [];
const tempZerosData = [];
for (let i = 0; i < parameters.iterations; i++) {
const dV_loop = calculateDeltaVLoop(R_loop_ref.current, R_loop_ref.current, i);
const next_R_loop = collapseFunctionLoop(P_loop_ref.current, dV_loop, i);
const { omega, deviation } = calculateOmegaNTLoop(next_R_loop, P_loop_ref.current);
const autoAlignment = Math.abs(deviation / (2 * Math.PI));
const next_P_loop = P_loop_ref.current * parameters.dampingFactor * (1 + Math.sin(i * 0.1) * 0.1);
R_loop_ref.current = next_R_loop;
P_loop_ref.current = next_P_loop;
tempSimData.push({ iteration: i, resultant: R_loop_ref.current, potential: P_loop_ref.current, deltaV: dV_loop, omega, autoAlignment, zeroPoint: 2 * Math.PI });
tempConvData.push({ iteration: i, convergence: autoAlignment, logConvergence: Math.log10(autoAlignment + 1e-10), omegaConvergence: deviation });
const zeroMap = riemannZeroMapping(i);
zeroMap.ntCoherence = 1 / (1 + autoAlignment * 10);
tempZerosData.push(zeroMap);
updateGeometricPatternState(autoAlignment); // Aggiorna anche qui per coerenza
}
setSimulationData(tempSimData);
setConvergenceData(tempConvData);
setZerosMappingData(tempZerosData);
}, [parameters, calculateDeltaVLoop, collapseFunctionLoop, calculateOmegaNTLoop, riemannZeroMapping, updateGeometricPatternState]);
/* ---------------------- OPTIMIZER (come prima, ma usa runFullSimulation internamente) ---------------------- */
const findOptimalParameters = useCallback(() => {
stop();
console.log("Ricerca parametri ottimali avviata...");
// Aggiungi un messaggio all'utente
alert("Ricerca parametri ottimali avviata. Questo potrebbe richiedere alcuni secondi. Controlla la console per i progressi e i risultati.");
const dV_vals = [0.05, 0.1, 0.15, 0.2];
const damp_vals = [0.90, 0.93, 0.95, 0.97];
const noise_vals = [0.0, 0.01, 0.02, 0.05];
let bestRun = { score: Infinity, params: parameters };
// Iterazioni ridotte per l'ottimizzatore per velocità
const optimizerIterations = Math.min(50, parameters.iterations);
for (const dV_loop_val of dV_vals) {
for (const df_val of damp_vals) {
for (const nl_val of noise_vals) {
const candidateParams = {
...parameters,
deltaV_loop: dV_loop_val,
dampingFactor: df_val,
noiseLevel: nl_val,
iterations: optimizerIterations // Usa iterazioni ridotte per l'ottimizzatore
};
// Simula con i parametri candidati
let temp_R = Math.random();
let temp_P = 1.0;
let totalDeviation = 0;
// Usa una copia locale delle funzioni di calcolo con i parametri candidati
// Questo è un modo per farlo, oppure si potrebbero passare i parametri candidati a ogni funzione
const local_calculateDeltaVLoop = (curr_R, prev_R, iter) => candidateParams.deltaV_loop * (1 + 0.5 * Math.sin(iter * 0.03));
const local_collapseFunctionLoop = (P_l, dV_v, iter, Z_v = 0.1) => {
const lambda_loc = 1.0;
const expFactor_loc = Math.exp(lambda_loc * Z_v * Math.sin(iter * 0.1));
const Dprim_loc = Math.cos(iter * 0.15) * dV_v;
const Pposs_loc = P_l * Math.sin(iter * 0.08);
const Llat_loc = Math.exp(-iter * 0.02) * 0.1;
const integralNT_sim_loc = Dprim_loc * Pposs_loc - Llat_loc;
const noise_loc = (Math.random() - 0.5) * candidateParams.noiseLevel;
const resonanceEffect_loc = Math.cos(iter * 0.05) * P_l * noise_loc;
return P_l * expFactor_loc * integralNT_sim_loc + resonanceEffect_loc;
};
for (let i = 0; i < candidateParams.iterations; i++) {
const dV = local_calculateDeltaVLoop(temp_R, temp_R, i);
temp_R = local_collapseFunctionLoop(temp_P, dV, i);
const { deviation } = calculateOmegaNTLoop(temp_R, temp_P); // calculateOmegaNTLoop non dipende da `parameters`
totalDeviation += deviation;
temp_P *= candidateParams.dampingFactor * (1 + Math.sin(i * 0.1) * 0.1);
}
const avgDeviation = totalDeviation / candidateParams.iterations;
if (avgDeviation < bestRun.score) {
bestRun = { score: avgDeviation, params: candidateParams };
console.log(`Nuovi parametri ottimali PROVVISORI trovati (dev: ${avgDeviation.toFixed(6)}):`, candidateParams);
}
}
}
}
// Applica i migliori parametri trovati (ripristinando le iterazioni originali)
const finalBestParams = {...bestRun.params, iterations: parameters.iterations};
setParameters(finalBestParams);
console.log("Parametri ottimali FINALI impostati. Deviazione media:", bestRun.score.toFixed(6), finalBestParams);
alert(`Parametri ottimizzati impostati. Deviazione media: ${bestRun.score.toFixed(6)}. Clicca 'Esegui Batch' per simulare con i nuovi parametri.`);
// Esegui runFullSimulation dopo un breve timeout per permettere l'aggiornamento dello stato
setTimeout(() => {
runFullSimulation();
}, 100);
}, [parameters, calculateOmegaNTLoop, runFullSimulation]); // Aggiunte dipendenze per useCallback
/* ---------------------- REAL‑TIME LOOP (come prima ma usa singleSimulationStep) ---------------------- */
const startRealTime = () => {
stop();
setIsRunning(true);
iteration_ref.current = 0; // Resetta iterazione per real-time
R_loop_ref.current = Math.random();
P_loop_ref.current = 1.0;
// Pulisci i dati precedenti per il real-time
setSimulationData([]);
setConvergenceData([]);
setZerosMappingData([]);
intervalRef.current = setInterval(singleSimulationStep, 100);
};
const stop = () => {
setIsRunning(false);
if (intervalRef.current) {
clearInterval(intervalRef.current);
intervalRef.current = null;
}
};
useEffect(() => {
// Esegui una simulazione batch all'avvio iniziale
runFullSimulation();
return () => stop(); // Cleanup interval on component unmount
// eslint-disable-next-line react-hooks/exhaustive-deps
}, []); // Esegui solo al mount. Le dipendenze di runFullSimulation sono gestite da useCallback
/* ---------------------- UI ---------------------- */
return (
<div className="w-full min-h-screen mx-auto p-4 md:p-6 bg-gray-900 text-white font-sans">
<Header />
<div className="grid grid-cols-1 lg:grid-cols-3 gap-6 mb-6">
<div className="lg:col-span-2">
<Controls parameters={parameters} setParameters={setParameters} />
</div>
<div className="lg:col-span-1">
<Buttons {...{ isRunning, runSimulation: runFullSimulation, startRealTime, stop, findOptimalParameters }} />
</div>
</div>
<GeometricPatternDisplay patternState={geometricPatternState} />
<div className="grid grid-cols-1 xl:grid-cols-2 gap-6 mt-8">
{/* Grafico Dinamiche D-ND */}
<div className="p-6 bg-gray-800 rounded-xl shadow-2xl">
<h2 className="text-2xl font-semibold mb-6 text-teal-300 flex items-center"><BarChart3 className="mr-2"/>Dinamiche D-ND Essenziali</h2>
<ResponsiveContainer width="100%" height={400}>
<LineChart data={simulationData}>
<CartesianGrid strokeDasharray="3 3" stroke="#4A5568" />
<XAxis dataKey="iteration" stroke="#A0AEC0" name="Iterazione"/>
<YAxis stroke="#A0AEC0" />
<Tooltip
contentStyle={{ backgroundColor: 'rgba(30,40,57,0.85)', border: '1px solid #4A5568', borderRadius: '0.5rem', color: '#E2E8F0' }}
itemStyle={{ color: '#E2E8F0' }}
cursor={{ fill: 'rgba(74, 85, 104, 0.3)' }}
/>
<Legend wrapperStyle={{ color: '#A0AEC0' }} />
<Line type="monotone" dataKey="resultant" name="Risultante (R)" stroke="#25C2A0" strokeWidth={2} dot={false} />
<Line type="monotone" dataKey="potential" name="Potenziale (P)" stroke="#3498DB" strokeWidth={2} dot={false} />
<Line type="monotone" dataKey="deltaV" name="DeltaV (ΔV)" stroke="#E74C3C" strokeWidth={2} dot={false} />
<Line type="monotone" dataKey="omega" name="Omega (ω)" stroke="#F1C40F" strokeWidth={2} dot={false} />
<Line type="monotone" dataKey="zeroPoint" name="Target Ω (2π)" stroke="#9B59B6" strokeDasharray="5 5" strokeWidth={2} dot={false} />
</LineChart>
</ResponsiveContainer>
</div>
{/* Grafico Convergenza Auto-Allineamento */}
<div className="p-6 bg-gray-800 rounded-xl shadow-2xl">
<h2 className="text-2xl font-semibold mb-6 text-teal-300 flex items-center"><Zap className="mr-2"/>Convergenza e Auto-Allineamento Ω<sub>NT</sub></h2>
<ResponsiveContainer width="100%" height={400}>
<LineChart data={convergenceData}>
<CartesianGrid strokeDasharray="3 3" stroke="#4A5568" />
<XAxis dataKey="iteration" stroke="#A0AEC0" name="Iterazione"/>
<YAxis yAxisId="left" stroke="#25C2A0" />
<YAxis yAxisId="right" orientation="right" stroke="#3498DB" />
<Tooltip
contentStyle={{ backgroundColor: 'rgba(30,40,57,0.85)', border: '1px solid #4A5568', borderRadius: '0.5rem', color: '#E2E8F0' }}
itemStyle={{ color: '#E2E8F0' }}
cursor={{ fill: 'rgba(74, 85, 104, 0.3)' }}
/>
<Legend wrapperStyle={{ color: '#A0AEC0' }} />
<Line yAxisId="left" type="monotone" dataKey="convergence" name="Auto-Allineamento (Dev/2π)" stroke="#25C2A0" strokeWidth={2} dot={false}/>
<Line yAxisId="right" type="monotone" dataKey="logConvergence" name="Log10(Allineamento)" stroke="#3498DB" strokeWidth={2} dot={false}/>
<Line yAxisId="left" type="monotone" dataKey="omegaConvergence" name="Deviazione Ω" stroke="#E74C3C" strokeWidth={2} dot={false} />
</LineChart>
</ResponsiveContainer>
</div>
</div>
{/* Grafico Mapping Zeri di Riemann e Coerenza NT */}
<div className="mt-6 p-6 bg-gray-800 rounded-xl shadow-2xl">
<h2 className="text-2xl font-semibold mb-6 text-teal-300 flex items-center"><Brain className="mr-2"/>Mapping Zeri di Riemann e Coerenza NT (Concettuale)</h2>
<ResponsiveContainer width="100%" height={400}>
<ScatterChart margin={{ top: 20, right: 20, bottom: 20, left: 20 }}>
<CartesianGrid strokeDasharray="3 3" stroke="#4A5568"/>
<XAxis type="number" dataKey="real" name="Re(s)" stroke="#A0AEC0" label={{ value: "Parte Reale (s)", position: 'insideBottomRight', offset: -10, fill:"#A0AEC0" }} domain={[0.4, 0.6]} ticks={[0.4, 0.45, 0.5, 0.55, 0.6]}/>
<YAxis type="number" dataKey="imaginary" name="Im(s)" stroke="#A0AEC0" label={{ value: "Parte Immaginaria (s)", angle: -90, position: 'insideLeft', fill:"#A0AEC0" }}/>
<ZAxis type="number" dataKey="ntCoherence" range={[20, 300]} name="Coerenza NT"/>
<Tooltip
cursor={{ strokeDasharray: '3 3', fill: 'rgba(74, 85, 104, 0.3)' }}
contentStyle={{ backgroundColor: 'rgba(30,40,57,0.85)', border: '1px solid #4A5568', borderRadius: '0.5rem', color: '#E2E8F0' }}
itemStyle={{ color: '#E2E8F0' }}
/>
<Legend wrapperStyle={{ color: '#A0AEC0', paddingTop: '10px' }}/>
<Scatter name="Zeri (Coerenza NT)" data={zerosMappingData} fillOpacity={0.7}>
{zerosMappingData.map((entry, index) => (
<Scatter key={`cell-${index}`} cx={entry.real} cy={entry.imaginary} fill={ `rgba(37, 194, 160, ${entry.ntCoherence})` } />
))}
</Scatter>
<Scatter name="Zeri (Coerenza Riemann)" data={zerosMappingData} fillOpacity={0.7} shape="cross">
{zerosMappingData.map((entry, index) => (
<Scatter key={`cell-riemann-${index}`} cx={entry.real} cy={entry.imaginary} fill={ `rgba(241, 196, 15, ${Math.abs(entry.coherenceZero)})` } />
))}
</Scatter>
</ScatterChart>
</ResponsiveContainer>
</div>
<footer className="mt-12 pt-6 border-t border-gray-700 text-center">
<p className="text-sm text-gray-500">Simulatore D-ND v2.0 - Modello Concettuale per Esplorazione Dinamica</p>
<p className="text-xs text-gray-600 mt-1">Ispirato al Modello Duale Non-Duale. Tutti i calcoli sono rappresentazioni concettuali.</p>
</footer>
</div>
);
};
export default DNDLoopSimulator;