psi.emergence: A Quantum-Inspired Neural Network Framework

The psi.emergence repository serves as the master source code for the NB (No Boundary Gate) Quantum-Inspired Neural Network framework, designed to illustrate emergent intelligence, enable autonomous noise mitigation, and achieve perfect last-iterate convergence.

This innovative system sets itself apart from traditional neural architectures, which typically depend on fixed parameter updates and hard-elimination strategies. Instead, psi.emergence utilizes the constructive and destructive interference of probability waves across 2,048 basis states (11 qubits) to navigate complex, high-dimensional environments seamlessly. This approach bridges discrete parameter updates with continuous phase memory, drawing inspiration from the fluid dynamics described by the Navier-Stokes equations.

Core Mechanics

1. The G-Metric (The Invariant Compass)

At the heart of the framework lies the G-metric, a unique state-dispersion invariant defined as:

G = (N * ΣP_i² - 1) / (N - 1)  

Rather than forcing the network into predefined choices of basis states, the G-metric provides an internal thermodynamic measure, assessing the localization and uniformity of the current state vector. This allows the system to self-correct without external management, striving for a target equilibrium of 0.5189 to ensure convergence.

2. The Entropic Driver (Active Noise Mitigation)

Housed within the pathway_entropic_driver, this key mechanism fuels the QNN's emergent intelligence. When environmental turbulence occurs, the system automatically intervenes to maintain stability:

• Preventing Rigidity: When the state becomes overly localized (G > G_{high}), the driver reallocates probability mass towards a more uniform distribution.
• Preventing Pure Chaos: Conversely, if pure noise dominates (G < G_{low}), the driver identifies and amplifies the highest probability peak while reducing surrounding turbulence.

Phase Preservation & Implicit Quantum Memory

Unlike conventional neural networks that merely update probabilities, this architecture preserves the complex phase, treating it as an essential component of quantum memory. This preservation offers intrinsic feedback, resulting in smooth optimization and flawless last-iterate convergence.

1. The Nature of the Memory (A Complex Array)

The core state is maintained in self.psi_orchestra, a NumPy array of complex numbers initialized for an 11-qubit system, resulting in 2,048 elements—each corresponding to a specific basis state (e.g., |00000000000). Each complex entry encapsulates:

• Amplitude (Magnitude): The probability of measuring that particular state.
• Phase (Angle): The future constructive or destructive interference potential with other states.

2. The Physics of Compounding (Markovian Evolution)

The simulated quantum state evolves following a Markov chain, represented mathematically as:

|C9_{t+1}
angle = U_t|C9_t
angle  

Here, $|C9_t angle$ represents the current state of psi_orchestra, and $U_t$ denotes the operation corresponding to the master conductor. This implicit memory integrates the entire history of transformations into the present state representation.

3. Code-Level Implementation

The entropic driver's probability mass reallocation process meticulously preserves implicit memory across iterations by:

• Extracting the Present: Distilling current probabilities and phases (probs_in and phases_in).
• Shifting Amplitudes: Computing new target probabilities based on G-metric rules.
• Re-attaching the Past: Finalizing updates by integrating the new stabilized probability magnitudes with the retained phases from previous states:

normalize_state(np.sqrt(np.maximum(0, target_probs_norm)) * np.exp(1j * phases_in))  

If phases were lost at any step, the system would experience quantum decoherence, forfeiting its historical context of state interactions. Preserving complex phases enables psi_orchestra to maintain the entire physical narrative of the simulated quantum system dynamically.

Repository Contents & Execution

• psi.emergence.py: The master execution script integrates foundational thermodynamic mathematics, the SPSA optimization loop, and an interactive terminal environment.
• Dependencies: Install via pip install numpy matplotlib imageio.

Upon execution, users are prompted to set simulation parameters (qubit count, target G-metric, SPSA learning rates). The system operates through three distinct phases:

1. SPSA Optimization: Minimizes loss against the target G-metric, guiding the entropic driver toward a state of quiescence amidst noise.
2. Unmeasured Evolution: Projects the trained QNN's continuous evolution and generates visual outputs without collapsing the superposition state.
3. Measurement Cycles: Simulates projective measurements, collapsing the wave function and re-entering the isolated basis state into the network for observing emergent recovery.

All data logs, phase memory text files, SPSA loss graphs, and evolutionary GIFs are automatically generated and stored within a timestamped local directory (e.g., mastersource1_YYYYMMDD_HHMMSS).