[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6CXG44CG1KY8TCKQN7HXPJ4":3,"skill-same:01M6CXG44CG1KY8TCKQN7HXPJ4":50},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":15,"categories":16,"keywords":17,"publishedAt":23,"linkOnly":24,"markdownContent":25,"markdownBody":26,"frontMatter":27,"refName":30,"commitSha":31,"skillDirectory":5,"forksCount":32,"repositoryHtmlUrl":33,"repositoryHomepageUrl":6,"ownerHtmlUrl":34,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":35,"install":36,"resources":49},"01M6CXG44CG1KY8TCKQN7HXPJ4","quantum-computing",null,"Quantum computing concepts and NeuralBlitz quantum neuron implementation","ffsshhttiikk\u002Fopencode-agents-skills","ffsshhttiikk","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F226346827?v=4","01M6CWD9RR3Y7VRQX3MXYC8FYH","01M6CWD9WVPYAZW0J82G1VKGHY",3,"MIT","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fquantum-computing\u002FSKILL.md",[],[18,19,20,21,22],"quantum computing","opencode","implementation","domain","domain-specific","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":14,"metadata":28,"description":7,"compatibility":19},{"audience":29,"category":22},"developers","main","5f7a3e453c98261f93d19a6a7de44ad8f7b72d41",2,"https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk","2026-03-01 06:55:40",{"source":8,"skillName":5,"commands":37,"prompt":47,"zipAvailable":48},[38,41,44],{"tool":39,"command":40},"npx","npx skills add ffsshhttiikk\u002Fopencode-agents-skills --skill quantum-computing",{"tool":42,"command":43},"bunx","bunx skills add ffsshhttiikk\u002Fopencode-agents-skills --skill quantum-computing",{"tool":45,"command":46},"pnpm","pnpm dlx skills add ffsshhttiikk\u002Fopencode-agents-skills --skill quantum-computing","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fquantum-computing\u002FSKILL.md",true,[],[51,62,72,81,91,100],{"skillNo":52,"name":53,"nameZh":6,"description":54,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":55,"categories":56,"keywords":57,"publishedAt":23},"01M6CXT9TXDF79BWJTMQAPB49G","xamarin","Xamarin cross-platform development","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fxamarin\u002FSKILL.md",[],[53,58,59,60,19,61],"platform","cross-platform","mobile","development",{"skillNo":63,"name":64,"nameZh":6,"description":65,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":66,"categories":67,"keywords":68,"publishedAt":23},"01M6CXT8AD04MFYDA32VW3FKAG","wrangling","Data wrangling fundamentals","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fwrangling\u002FSKILL.md",[],[64,69,19,70,71],"data wrangling","science","data",{"skillNo":73,"name":74,"nameZh":6,"description":75,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":76,"categories":77,"keywords":78,"publishedAt":23},"01M6CXT717GCN7SRRNPBDP4508","windows","Windows operating system administration and scripting","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fwindows\u002FSKILL.md",[],[74,79,19,80],"system","scripting",{"skillNo":82,"name":83,"nameZh":6,"description":84,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":85,"categories":86,"keywords":87,"publishedAt":23},"01M6CXT54K794NMEM3XAPZZDKT","wide-column","Wide-column data model","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fwide-column\u002FSKILL.md",[],[88,89,19,90,71],"wide column","databases","model",{"skillNo":92,"name":93,"nameZh":6,"description":94,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":95,"categories":96,"keywords":97,"publishedAt":23},"01M6CXT28FMT2P4V9GZE67WA8E","wide-column-stores","Wide-column database stores","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fwide-column-stores\u002FSKILL.md",[],[98,89,19,99],"wide column stores","database",{"skillNo":101,"name":102,"nameZh":6,"description":103,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":104,"categories":105,"keywords":106,"publishedAt":23},"01M6CXT0D0M0Q4T2N7C2RX7DSN","websockets","WebSocket implementation and best practices","https:\u002F\u002Fgithub.com\u002Fffsshhttiikk\u002Fopencode-agents-skills\u002Fblob\u002Fmain\u002Fwebsockets\u002FSKILL.md",[],[102,107,108,109,19,110,20],"websocket","real-time","time","best practices"]