[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6HAESXCCR11J371PMKX5BH9":3,"skill-same:01M6HAESXCCR11J371PMKX5BH9":56},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":27,"linkOnly":28,"markdownContent":29,"markdownBody":30,"frontMatter":31,"refName":34,"commitSha":35,"skillDirectory":36,"forksCount":14,"repositoryHtmlUrl":37,"repositoryHomepageUrl":6,"ownerHtmlUrl":38,"ownerBlogUrl":39,"ownerDescription":40,"updatedAt":41,"install":42,"resources":55},"01M6HAESXCCR11J371PMKX5BH9","quantum-computing",null,"Quantum computing concepts and NeuralBlitz quantum neuron implementation","NeuralBlitz\u002FMito","NeuralBlitz","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F79354388?v=4","01M6H8T2TFH477HRS0KTSTKR2E","David Riggs","01M6H8T2YQQDXPYM092P670Z21",0,"MIT","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fquantum-computing\u002FSKILL.md",[],[19,20,21,22,23,24,25,26],"quantum computing","quantum","opencode","implementation","domain","domain-specific","concepts","neuron","2026-11-10 10:12:30",false,"---\nname: quantum-computing\ndescription: Quantum computing concepts and NeuralBlitz quantum neuron implementation\nlicense: MIT\ncompatibility: opencode\nmetadata:\n  audience: developers\n  category: domain-specific\n---\n## What I do\n- Implement quantum-inspired neural networks\n- Model quantum spiking neurons\n- Handle quantum state evolution\n- Manage superposition and entanglement\n- Implement quantum tunneling behavior\n- Handle coherence and decoherence\n- Work with multi-reality networks\n- Optimize quantum circuit simulation\n\n## When to use me\nWhen working with the NeuralBlitz quantum computing components or implementing quantum-inspired algorithms.\n\n## Quantum State Representation\n```python\nimport numpy as np\nfrom typing import Optional, Tuple\nfrom scipy.linalg import expm\n\n\nclass QuantumState:\n    \"\"\"\n    Quantum state vector in Hilbert space.\n    \n    The state is represented as a normalized complex vector.\n    For n qubits, the state space has dimension 2^n.\n    \"\"\"\n    \n    def __init__(self, num_qubits: int) -> None:\n        \"\"\"\n        Initialize quantum state to |0⟩^n.\n        \n        Args:\n            num_qubits: Number of qubits (must be positive integer)\n        \"\"\"\n        self.num_qubits = num_qubits\n        self.dim = 2 ** num_qubits\n        self.state = np.zeros(self.dim, dtype=complex)\n        self.state[0] = 1.0  # |0⟩ state\n    \n    @property\n    def data(self) -> np.ndarray:\n        \"\"\"Return the state vector (read-only view).\"\"\"\n        return self.state.copy()\n    \n    def normalize(self) -> None:\n        \"\"\"Normalize state vector to unit length.\"\"\"\n        norm = np.linalg.norm(self.state)\n        if norm > 0:\n            self.state \u002F= norm\n    \n    def measure(self) -> int:\n        \"\"\"\n        Measure state in computational basis.\n        \n        Returns:\n            Measured basis state index with probability = |\u003Cx|ψ⟩|²\n        \"\"\"\n        probs = np.abs(self.state) ** 2\n        probs \u002F= probs.sum()\n        return np.random.choice(len(self.state), p=probabilities)\n    \n    def fidelity(self, other: 'QuantumState') -> float:\n        \"\"\"\n        Calculate fidelity between two quantum states.\n        \n        Fidelity = |⟨ψ|φ⟩|² for pure states.\n        \n        Args:\n            other: Another quantum state to compare\n            \n        Returns:\n            Fidelity value between 0 and 1\n        \"\"\"\n        overlap = np.vdot(self.state, other.state)\n        return np.abs(overlap) ** 2\n```\n\n## Quantum Gates\n```python\nclass QuantumGate:\n    \"\"\"Quantum gate operations on state vectors.\"\"\"\n    \n    @staticmethod\n    def hadamard(num_qubits: int, target: int) -> np.ndarray:\n        \"\"\"\n        Create Hadamard gate for superposition.\n        \n        H|0⟩ = (|0⟩ + |1⟩)\u002F√2\n        H|1⟩ = (|0⟩ - |1⟩)\u002F√2\n        \"\"\"\n        H = np.array([[1, 1], [1, -1]]) \u002F np.sqrt(2)\n        return QuantumGate.expand_gate(H, num_qubits, target)\n    \n    @staticmethod\n    def pauli_x(num_qubits: int, target: int) -> np.ndarray:\n        \"\"\"Pauli-X (NOT) gate: |0⟩→|1⟩, |1⟩→|0⟩\"\"\"\n        X = np.array([[0, 1], [1, 0]])\n        return QuantumGate.expand_gate(X, num_qubits, target)\n    \n    @staticmethod\n    def pauli_z(num_qubits: int, target: int) -> np.ndarray:\n        \"\"\"Pauli-Z gate: |1⟩→-|1⟩, |0⟩→|0⟩\"\"\"\n        Z = np.array([[1, 0], [0, -1]])\n        return QuantumGate.expand_gate(Z, num_qubits, target)\n    \n    @staticmethod\n    def cnot(num_qubits: int, control: int, target: int) -> np.ndarray:\n        \"\"\"Controlled-NOT gate (CNOT).\"\"\"\n        dim = 2 ** num_qubits\n        matrix = np.eye(dim, dtype=complex)\n        \n        for i in range(dim):\n            if (i >> control) & 1 and not (i >> target) & 1:\n                j = i | (1 \u003C\u003C target)\n                k = i & ~(1 \u003C\u003C target)\n                matrix[j, i] = 1\n                matrix[k, i] = 0\n        \n        return matrix\n    \n    @staticmethod\n    def rz(angle: float, num_qubits: int, target: int) -> np.ndarray:\n        \"\"\"\n        Rotation around Z-axis by angle.\n        \n        Rz(θ) = exp(-iθZ\u002F2)\n        \"\"\"\n        RZ = np.array([\n            [np.exp(-1j * angle \u002F 2), 0],\n            [0, np.exp(1j * angle \u002F 2)]\n        ])\n        return QuantumGate.expand_gate(RZ, num_qubits, target)\n    \n    @staticmethod\n    def expand_gate(\n        gate: np.ndarray,\n        num_qubits: int,\n        target: int\n    ) -> np.ndarray:\n        \"\"\"\n        Expand single-qubit gate to full operator.\n        \n        Uses tensor product to embed single-qubit operation\n        into larger Hilbert space.\n        \"\"\"\n        dim = 2 ** num_qubits\n        \n        if target \u003C 0 or target >= num_qubits:\n            raise ValueError(f\"Invalid target qubit: {target}\")\n        \n        result = np.eye(1, dtype=complex)\n        \n        for i in range(num_qubits):\n            if i == target:\n                result = np.kron(result, gate)\n            else:\n                result = np.kron(result, np.eye(2, dtype=complex))\n        \n        return result\n```\n\n## Quantum Spiking Neuron\n```python\nclass QuantumSpikingNeuron:\n    \"\"\"\n    Quantum-inspired spiking neuron model.\n    \n    Combines quantum mechanics with spiking neural network principles:\n    - Quantum superposition for input integration\n    - Quantum tunneling for spike generation\n    - Coherence time limiting neural activity\n    \"\"\"\n    \n    def __init__(\n        self,\n        num_qubits: int = 4,\n        coherence_time: float = 100.0,\n        tunneling: float = 0.1,\n        threshold: float = 0.5,\n    ) -> None:\n        self.num_qubits = num_qubits\n        self.coherence_time = coherence_time\n        self.tunneling = tunneling\n        self.threshold = threshold\n        self.state = QuantumState(num_qubits)\n        self.weights = np.random.randn(num_qubits) * 0.1\n        self.spike_history: list[float] = []\n        self.last_update: float = 0.0\n    \n    def evolve(\n        self,\n        inputs: np.ndarray,\n        dt: float,\n        hamiltonian: Optional[np.ndarray] = None\n    ) -> Tuple[np.ndarray, bool]:\n        \"\"\"\n        Evolve quantum state and potentially spike.\n        \n        Args:\n            inputs: Input currents from connected neurons\n            dt: Time step in milliseconds\n            hamiltonian: Optional custom Hamiltonian matrix\n            \n        Returns:\n            Tuple of (output_state, did_spike)\n        \"\"\"\n        if len(inputs) != self.num_qubits:\n            raise ValueError(f\"Expected {self.num_qubits} inputs, got {len(inputs)}\")\n        \n        self.last_update = dt\n        \n        # Create Hamiltonian from inputs (H = -Σ w_i |i⟩⟨i|)\n        if hamiltonian is None:\n            hamiltonian = np.diag(-self.weights * inputs)\n        \n        # Time evolution operator: U(t) = exp(-iHt)\n        evolution = expm(-1j * hamiltonian * dt)\n        \n        # Apply evolution\n        self.state.state = evolution @ self.state.state\n        \n        # Apply tunneling (stochastic spike mechanism)\n        spike_probability = self._calculate_spike_probability()\n        should_spike = np.random.random() \u003C spike_probability\n        \n        if should_spike:\n            self._emit_spike()\n            return self.state.state, True\n        \n        return self.state.state, False\n    \n    def _calculate_spike_probability(self) -> float:\n        \"\"\"\n        Calculate spike probability based on quantum state.\n        \n        Uses probability amplitude in excited states\n        modulated by tunneling rate.\n        \"\"\"\n        excited_prob = np.sum(np.abs(self.state.state[2 ** (self.num_qubits - 1):]) ** 2)\n        coherence_factor = np.exp(-self.last_update \u002F self.coherence_time)\n        \n        return excited_prob * self.tunneling * coherence_factor\n    \n    def _emit_spike(self) -> None:\n        \"\"\"Reset state after spike emission.\"\"\"\n        self.spike_history.append(self.last_update)\n        \n        # Collapse to ground state (reset)\n        self.state = QuantumState(self.num_qubits)\n        \n        # Keep last spike time for refractory period\n        self._refractory_timer = 5.0  # ms\n    \n    def get_membrane_potential(self) -> float:\n        \"\"\"Estimate membrane potential from state vector.\"\"\"\n        return np.sum(\n            np.arange(2 ** self.num_qubits) * \n            np.abs(self.state.state) ** 2\n        )\n```\n\n## Multi-Reality Network\n```python\nclass MultiRealityNetwork:\n    \"\"\"\n    Network that spans multiple parallel realities.\n    \n    Each reality maintains its own quantum state,\n    and entanglement allows correlation between realities.\n    \"\"\"\n    \n    def __init__(\n        self,\n        num_realities: int = 4,\n        neurons_per_reality: int = 20,\n        entanglement_strength: float = 0.1,\n    ) -> None:\n        self.num_realities = num_realities\n        self.neurons_per_reality = neurons_per_reality\n        self.entanglement_strength = entanglement_strength\n        \n        self.neurons: list[list[QuantumSpikingNeuron]] = []\n        self.entanglement_matrix: np.ndarray\n        \n        self._initialize_network()\n    \n    def _initialize_network(self) -> None:\n        \"\"\"Initialize neurons in each reality.\"\"\"\n        for r in range(self.num_realities):\n            reality_neurons = [\n                QuantumSpikingNeuron(\n                    num_qubits=4,\n                    coherence_time=100.0,\n                    tunneling=0.1,\n                )\n                for _ in range(self.neurons_per_reality)\n            ]\n            self.neurons.append(reality_neurons)\n        \n        self.entanglement_matrix = np.eye(self.num_realities)\n    \n    def evolve_cycle(self, dt: float) -> list[list[bool]]:\n        \"\"\"\n        Evolve all neurons across all realities.\n        \n        Returns:\n            Matrix of spike events (reality × neuron)\n        \"\"\"\n        spike_matrix = []\n        \n        for r in range(self.num_realities):\n            reality_spikes = []\n            \n            for neuron in self.neurons[r]:\n                inputs = self._get_inputs(r, neuron)\n                _, spiked = neuron.evolve(inputs, dt)\n                reality_spikes.append(spiked)\n            \n            spike_matrix.append(reality_spikes)\n        \n        self._apply_entanglement(spike_matrix)\n        \n        return spike_matrix\n    \n    def _get_inputs(\n        self,\n        reality: int,\n        target_neuron: QuantumSpikingNeuron\n    ) -> np.ndarray:\n        \"\"\"Get inputs from neurons in same reality.\"\"\"\n        inputs = np.zeros(target_neuron.num_qubits)\n        \n        for i, neuron in enumerate(self.neurons[reality]):\n            if neuron is not target_neuron:\n                inputs[i] = neuron.get_membrane_potential()\n        \n        return inputs\n    \n    def _apply_entanglement(self, spike_matrix: list[list[bool]]) -> None:\n        \"\"\"\n        Apply quantum entanglement between realities.\n        \n        Correlates activity across realities based on\n        entanglement matrix.\n        \"\"\"\n        spike_array = np.array(spike_matrix)\n        \n        for i in range(self.num_realities):\n            for j in range(i + 1, self.num_realities):\n                correlation = self.entanglement_matrix[i, j]\n                \n                if correlation > 0:\n                    self._entangle_realities(\n                        spike_array[i],\n                        spike_array[j],\n                        correlation\n                    )\n    \n    def _entangle_realities(\n        self,\n        spikes_a: np.ndarray,\n        spikes_b: np.ndarray,\n        strength: float\n    ) -> None:\n        \"\"\"\n        Entangle activity between two realities.\n        \n        Adjusts spike probabilities based on correlated\n        activity patterns.\n        \"\"\"\n        agreement = np.sum(spikes_a == spikes_b) \u002F len(spikes_a)\n        \n        if agreement > 0.8:\n            # Strong correlation - reinforce\n            adjustment = strength * (1 - agreement)\n        elif agreement \u003C 0.2:\n            # Strong anti-correlation\n            adjustment = -strength * (0.5 - agreement)\n        else:\n            adjustment = 0\n        \n        self.entanglement_matrix = np.clip(\n            self.entanglement_matrix + adjustment * 0.01,\n            0, 1\n        )\n```\n","## What I do\n- Implement quantum-inspired neural networks\n- Model quantum spiking neurons\n- Handle quantum state evolution\n- Manage superposition and entanglement\n- Implement quantum tunneling behavior\n- Handle coherence and decoherence\n- Work with multi-reality networks\n- Optimize quantum circuit simulation\n\n## When to use me\nWhen working with the NeuralBlitz quantum computing components or implementing quantum-inspired algorithms.\n\n## Quantum State Representation\n```python\nimport numpy as np\nfrom typing import Optional, Tuple\nfrom scipy.linalg import expm\n\n\nclass QuantumState:\n    \"\"\"\n    Quantum state vector in Hilbert space.\n    \n    The state is represented as a normalized complex vector.\n    For n qubits, the state space has dimension 2^n.\n    \"\"\"\n    \n    def __init__(self, num_qubits: int) -> None:\n        \"\"\"\n        Initialize quantum state to |0⟩^n.\n        \n        Args:\n            num_qubits: Number of qubits (must be positive integer)\n        \"\"\"\n        self.num_qubits = num_qubits\n        self.dim = 2 ** num_qubits\n        self.state = np.zeros(self.dim, dtype=complex)\n        self.state[0] = 1.0  # |0⟩ state\n    \n    @property\n    def data(self) -> np.ndarray:\n        \"\"\"Return the state vector (read-only view).\"\"\"\n        return self.state.copy()\n    \n    def normalize(self) -> None:\n        \"\"\"Normalize state vector to unit length.\"\"\"\n        norm = np.linalg.norm(self.state)\n        if norm > 0:\n            self.state \u002F= norm\n    \n    def measure(self) -> int:\n        \"\"\"\n        Measure state in computational basis.\n        \n        Returns:\n            Measured basis state index with probability = |\u003Cx|ψ⟩|²\n        \"\"\"\n        probs = np.abs(self.state) ** 2\n        probs \u002F= probs.sum()\n        return np.random.choice(len(self.state), p=probabilities)\n    \n    def fidelity(self, other: 'QuantumState') -> float:\n        \"\"\"\n        Calculate fidelity between two quantum states.\n        \n        Fidelity = |⟨ψ|φ⟩|² for pure states.\n        \n        Args:\n            other: Another quantum state to compare\n            \n        Returns:\n            Fidelity value between 0 and 1\n        \"\"\"\n        overlap = np.vdot(self.state, other.state)\n        return np.abs(overlap) ** 2\n```\n\n## Quantum Gates\n```python\nclass QuantumGate:\n    \"\"\"Quantum gate operations on state vectors.\"\"\"\n    \n    @staticmethod\n    def hadamard(num_qubits: int, target: int) -> np.ndarray:\n        \"\"\"\n        Create Hadamard gate for superposition.\n        \n        H|0⟩ = (|0⟩ + |1⟩)\u002F√2\n        H|1⟩ = (|0⟩ - |1⟩)\u002F√2\n        \"\"\"\n        H = np.array([[1, 1], [1, -1]]) \u002F np.sqrt(2)\n        return QuantumGate.expand_gate(H, num_qubits, target)\n    \n    @staticmethod\n    def pauli_x(num_qubits: int, target: int) -> np.ndarray:\n        \"\"\"Pauli-X (NOT) gate: |0⟩→|1⟩, |1⟩→|0⟩\"\"\"\n        X = np.array([[0, 1], [1, 0]])\n        return QuantumGate.expand_gate(X, num_qubits, target)\n    \n    @staticmethod\n    def pauli_z(num_qubits: int, target: int) -> np.ndarray:\n        \"\"\"Pauli-Z gate: |1⟩→-|1⟩, |0⟩→|0⟩\"\"\"\n        Z = np.array([[1, 0], [0, -1]])\n        return QuantumGate.expand_gate(Z, num_qubits, target)\n    \n    @staticmethod\n    def cnot(num_qubits: int, control: int, target: int) -> np.ndarray:\n        \"\"\"Controlled-NOT gate (CNOT).\"\"\"\n        dim = 2 ** num_qubits\n        matrix = np.eye(dim, dtype=complex)\n        \n        for i in range(dim):\n            if (i >> control) & 1 and not (i >> target) & 1:\n                j = i | (1 \u003C\u003C target)\n                k = i & ~(1 \u003C\u003C target)\n                matrix[j, i] = 1\n                matrix[k, i] = 0\n        \n        return matrix\n    \n    @staticmethod\n    def rz(angle: float, num_qubits: int, target: int) -> np.ndarray:\n        \"\"\"\n        Rotation around Z-axis by angle.\n        \n        Rz(θ) = exp(-iθZ\u002F2)\n        \"\"\"\n        RZ = np.array([\n            [np.exp(-1j * angle \u002F 2), 0],\n            [0, np.exp(1j * angle \u002F 2)]\n        ])\n        return QuantumGate.expand_gate(RZ, num_qubits, target)\n    \n    @staticmethod\n    def expand_gate(\n        gate: np.ndarray,\n        num_qubits: int,\n        target: int\n    ) -> np.ndarray:\n        \"\"\"\n        Expand single-qubit gate to full operator.\n        \n        Uses tensor product to embed single-qubit operation\n        into larger Hilbert space.\n        \"\"\"\n        dim = 2 ** num_qubits\n        \n        if target \u003C 0 or target >= num_qubits:\n            raise ValueError(f\"Invalid target qubit: {target}\")\n        \n        result = np.eye(1, dtype=complex)\n        \n        for i in range(num_qubits):\n            if i == target:\n                result = np.kron(result, gate)\n            else:\n                result = np.kron(result, np.eye(2, dtype=complex))\n        \n        return result\n```\n\n## Quantum Spiking Neuron\n```python\nclass QuantumSpikingNeuron:\n    \"\"\"\n    Quantum-inspired spiking neuron model.\n    \n    Combines quantum mechanics with spiking neural network principles:\n    - Quantum superposition for input integration\n    - Quantum tunneling for spike generation\n    - Coherence time limiting neural activity\n    \"\"\"\n    \n    def __init__(\n        self,\n        num_qubits: int = 4,\n        coherence_time: float = 100.0,\n        tunneling: float = 0.1,\n        threshold: float = 0.5,\n    ) -> None:\n        self.num_qubits = num_qubits\n        self.coherence_time = coherence_time\n        self.tunneling = tunneling\n        self.threshold = threshold\n        self.state = QuantumState(num_qubits)\n        self.weights = np.random.randn(num_qubits) * 0.1\n        self.spike_history: list[float] = []\n        self.last_update: float = 0.0\n    \n    def evolve(\n        self,\n        inputs: np.ndarray,\n        dt: float,\n        hamiltonian: Optional[np.ndarray] = None\n    ) -> Tuple[np.ndarray, bool]:\n        \"\"\"\n        Evolve quantum state and potentially spike.\n        \n        Args:\n            inputs: Input currents from connected neurons\n            dt: Time step in milliseconds\n            hamiltonian: Optional custom Hamiltonian matrix\n            \n        Returns:\n            Tuple of (output_state, did_spike)\n        \"\"\"\n        if len(inputs) != self.num_qubits:\n            raise ValueError(f\"Expected {self.num_qubits} inputs, got {len(inputs)}\")\n        \n        self.last_update = dt\n        \n        # Create Hamiltonian from inputs (H = -Σ w_i |i⟩⟨i|)\n        if hamiltonian is None:\n            hamiltonian = np.diag(-self.weights * inputs)\n        \n        # Time evolution operator: U(t) = exp(-iHt)\n        evolution = expm(-1j * hamiltonian * dt)\n        \n        # Apply evolution\n        self.state.state = evolution @ self.state.state\n        \n        # Apply tunneling (stochastic spike mechanism)\n        spike_probability = self._calculate_spike_probability()\n        should_spike = np.random.random() \u003C spike_probability\n        \n        if should_spike:\n            self._emit_spike()\n            return self.state.state, True\n        \n        return self.state.state, False\n    \n    def _calculate_spike_probability(self) -> float:\n        \"\"\"\n        Calculate spike probability based on quantum state.\n        \n        Uses probability amplitude in excited states\n        modulated by tunneling rate.\n        \"\"\"\n        excited_prob = np.sum(np.abs(self.state.state[2 ** (self.num_qubits - 1):]) ** 2)\n        coherence_factor = np.exp(-self.last_update \u002F self.coherence_time)\n        \n        return excited_prob * self.tunneling * coherence_factor\n    \n    def _emit_spike(self) -> None:\n        \"\"\"Reset state after spike emission.\"\"\"\n        self.spike_history.append(self.last_update)\n        \n        # Collapse to ground state (reset)\n        self.state = QuantumState(self.num_qubits)\n        \n        # Keep last spike time for refractory period\n        self._refractory_timer = 5.0  # ms\n    \n    def get_membrane_potential(self) -> float:\n        \"\"\"Estimate membrane potential from state vector.\"\"\"\n        return np.sum(\n            np.arange(2 ** self.num_qubits) * \n            np.abs(self.state.state) ** 2\n        )\n```\n\n## Multi-Reality Network\n```python\nclass MultiRealityNetwork:\n    \"\"\"\n    Network that spans multiple parallel realities.\n    \n    Each reality maintains its own quantum state,\n    and entanglement allows correlation between realities.\n    \"\"\"\n    \n    def __init__(\n        self,\n        num_realities: int = 4,\n        neurons_per_reality: int = 20,\n        entanglement_strength: float = 0.1,\n    ) -> None:\n        self.num_realities = num_realities\n        self.neurons_per_reality = neurons_per_reality\n        self.entanglement_strength = entanglement_strength\n        \n        self.neurons: list[list[QuantumSpikingNeuron]] = []\n        self.entanglement_matrix: np.ndarray\n        \n        self._initialize_network()\n    \n    def _initialize_network(self) -> None:\n        \"\"\"Initialize neurons in each reality.\"\"\"\n        for r in range(self.num_realities):\n            reality_neurons = [\n                QuantumSpikingNeuron(\n                    num_qubits=4,\n                    coherence_time=100.0,\n                    tunneling=0.1,\n                )\n                for _ in range(self.neurons_per_reality)\n            ]\n            self.neurons.append(reality_neurons)\n        \n        self.entanglement_matrix = np.eye(self.num_realities)\n    \n    def evolve_cycle(self, dt: float) -> list[list[bool]]:\n        \"\"\"\n        Evolve all neurons across all realities.\n        \n        Returns:\n            Matrix of spike events (reality × neuron)\n        \"\"\"\n        spike_matrix = []\n        \n        for r in range(self.num_realities):\n            reality_spikes = []\n            \n            for neuron in self.neurons[r]:\n                inputs = self._get_inputs(r, neuron)\n                _, spiked = neuron.evolve(inputs, dt)\n                reality_spikes.append(spiked)\n            \n            spike_matrix.append(reality_spikes)\n        \n        self._apply_entanglement(spike_matrix)\n        \n        return spike_matrix\n    \n    def _get_inputs(\n        self,\n        reality: int,\n        target_neuron: QuantumSpikingNeuron\n    ) -> np.ndarray:\n        \"\"\"Get inputs from neurons in same reality.\"\"\"\n        inputs = np.zeros(target_neuron.num_qubits)\n        \n        for i, neuron in enumerate(self.neurons[reality]):\n            if neuron is not target_neuron:\n                inputs[i] = neuron.get_membrane_potential()\n        \n        return inputs\n    \n    def _apply_entanglement(self, spike_matrix: list[list[bool]]) -> None:\n        \"\"\"\n        Apply quantum entanglement between realities.\n        \n        Correlates activity across realities based on\n        entanglement matrix.\n        \"\"\"\n        spike_array = np.array(spike_matrix)\n        \n        for i in range(self.num_realities):\n            for j in range(i + 1, self.num_realities):\n                correlation = self.entanglement_matrix[i, j]\n                \n                if correlation > 0:\n                    self._entangle_realities(\n                        spike_array[i],\n                        spike_array[j],\n                        correlation\n                    )\n    \n    def _entangle_realities(\n        self,\n        spikes_a: np.ndarray,\n        spikes_b: np.ndarray,\n        strength: float\n    ) -> None:\n        \"\"\"\n        Entangle activity between two realities.\n        \n        Adjusts spike probabilities based on correlated\n        activity patterns.\n        \"\"\"\n        agreement = np.sum(spikes_a == spikes_b) \u002F len(spikes_a)\n        \n        if agreement > 0.8:\n            # Strong correlation - reinforce\n            adjustment = strength * (1 - agreement)\n        elif agreement \u003C 0.2:\n            # Strong anti-correlation\n            adjustment = -strength * (0.5 - agreement)\n        else:\n            adjustment = 0\n        \n        self.entanglement_matrix = np.clip(\n            self.entanglement_matrix + adjustment * 0.01,\n            0, 1\n        )\n```\n",{"name":5,"license":15,"metadata":32,"description":7,"compatibility":21},{"audience":33,"category":24},"developers","main","2ea764e153842704d24a2e9aa4170441a7f03081",".opencode\u002Fskills\u002Fquantum-computing","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito","https:\u002F\u002Fgithub.com\u002FNeuralBlitz","nuralnexus.org","Independent Multidisciplinary Researcher, Creative Producer, and AI Systems Architect\r\nAn independent creator and research-driven systems designer.","2026-11-12 03:13:05",{"source":8,"skillName":5,"commands":43,"prompt":53,"zipAvailable":54},[44,47,50],{"tool":45,"command":46},"npx","npx skills add NeuralBlitz\u002FMito --skill quantum-computing",{"tool":48,"command":49},"bunx","bunx skills add NeuralBlitz\u002FMito --skill quantum-computing",{"tool":51,"command":52},"pnpm","pnpm dlx skills add NeuralBlitz\u002FMito --skill quantum-computing","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fquantum-computing\u002FSKILL.md",true,[],[57,73,85,98,106,131],{"skillNo":58,"name":59,"nameZh":6,"description":60,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":61,"categories":62,"keywords":63,"publishedAt":27},"01M6HAZSAQK1S27CEZYAYJTQDX","wireless-communications","Wireless systems, mobile networks, and 5G\u002F6G","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fwireless-communications\u002FSKILL.md",[],[64,65,66,67,68,69,70,71,21,72],"communications","wireless communications","wireless","systems","engineering","networks","5G","students","mobile",{"skillNo":74,"name":75,"nameZh":6,"description":76,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":77,"categories":78,"keywords":79,"publishedAt":27},"01M6HAZFX6E8NK3WZWDX5YCKYY","websockets","WebSocket implementation and best practices","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fwebassembly\u002Fwebsockets\u002FSKILL.md",[],[75,80,81,22,21,82,83,84],"websocket implementation","time","real-time","websocket","best practices",{"skillNo":86,"name":87,"nameZh":6,"description":88,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":89,"categories":90,"keywords":91,"publishedAt":27},"01M6HAZ6DAXBQ7QHXXM1EM7715","vulnerability-auditing","Vulnerability assessment and auditing","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fvulnerability-auditing\u002FSKILL.md",[],[92,93,94,95,21,96,97],"vulnerability","vulnerability auditing","security","vulnerability assessment","cybersecurity","assessment",{"skillNo":99,"name":100,"nameZh":6,"description":101,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":102,"categories":103,"keywords":104,"publishedAt":27},"01M6HAZ3FKF3CS9Z3J96RVE2ZE","vulnerability-assessment","Finding and assessing security vulnerabilities","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fvue\u002Fvulnerability-assessment\u002FSKILL.md",[],[95,92,97,94,105,21],"vulnerabilities",{"skillNo":107,"name":108,"nameZh":6,"description":109,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":110,"categories":111,"keywords":122,"publishedAt":27},"01M6HAYSHM6HKRKEHFP0SGZQX7","vlsi-design","Very-Large-Scale Integration circuit design and semiconductor engineering","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fvlsi-design\u002FSKILL.md",[112,117],{"categoryNo":113,"categoryName":114,"taxonomyType":115,"taxonomyTypeDesc":116},"01JBSEEDCAT000000000000015","视觉设计","SCENARIO","使用场景",{"categoryNo":118,"categoryName":119,"taxonomyType":120,"taxonomyTypeDesc":121},"01JBSEEDCAT000000000000032","设计师","PROFESSION","适用职业",[123,124,125,126,127,68,128,21,129,71,130],"vlsi design","VLSI","design","hardware","integration","computer","scale","circuit",{"skillNo":132,"name":133,"nameZh":6,"description":134,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":135,"categories":136,"keywords":137,"publishedAt":27},"01M6HAYPQ30FFE2JXD7WQJ8R6C","unsupervised","Unsupervised learning concepts","https:\u002F\u002Fgithub.com\u002FNeuralBlitz\u002FMito\u002Fblob\u002Fmain\u002F.opencode\u002Fskills\u002Fvisualization\u002Funsupervised\u002FSKILL.md",[],[133,138,21,139,140,141,25,142],"learning","intelligence","unsupervised learning","machine","machine-learning"]