quantum-simulator 0.1.2__py3-none-any.whl

quantum_simulator/__init__.py

@@ -0,0 +1,15 @@
+"""
+Quantum Computer Simulator
+
+A Python library for simulating quantum computers and quantum algorithms.
+"""
+
+__version__ = "0.1.2"
+__author__ = "Nathaniel Schultz"
+__email__ = "nate.schultz@outlook.com"
+
+from .simulator import QuantumSimulator
+from .gates import QuantumGate
+from .circuits import QuantumCircuit
+
+__all__ = ["QuantumSimulator", "QuantumGate", "QuantumCircuit"]

quantum_simulator/circuits.py

@@ -0,0 +1,48 @@
+"""
+Quantum circuits implementation.
+"""
+
+from typing import List, Tuple
+from .simulator import QuantumSimulator
+from .gates import QuantumGate
+
+
+class QuantumCircuit:
+    """A quantum circuit representation."""
+    
+    def __init__(self, num_qubits: int):
+        """
+        Initialize a quantum circuit.
+        
+        Args:
+            num_qubits: Number of qubits in the circuit
+        """
+        self.num_qubits = num_qubits
+        self.gates: List[Tuple[QuantumGate, List[int]]] = []
+    
+    def add_gate(self, gate: QuantumGate, target_qubits: List[int]) -> None:
+        """
+        Add a gate to the circuit.
+        
+        Args:
+            gate: The quantum gate to add
+            target_qubits: List of qubit indices the gate acts on
+        """
+        self.gates.append((gate, target_qubits))
+    
+    def execute(self, simulator: QuantumSimulator) -> None:
+        """
+        Execute the circuit on a quantum simulator.
+        
+        Args:
+            simulator: The quantum simulator to run the circuit on
+        """
+        for gate, target_qubits in self.gates:
+            simulator.state_vector = gate.apply(simulator.state_vector, target_qubits)
+    
+    def __str__(self) -> str:
+        """String representation of the circuit."""
+        circuit_str = f"QuantumCircuit({self.num_qubits} qubits)\n"
+        for i, (gate, targets) in enumerate(self.gates):
+            circuit_str += f"  {i}: {gate.name} on qubits {targets}\n"
+        return circuit_str

quantum_simulator/gates.py

@@ -0,0 +1,96 @@
+"""
+Quantum gates implementation.
+"""
+
+import numpy as np
+from typing import List
+
+
+class QuantumGate:
+    """Base class for quantum gates."""
+    
+    def __init__(self, name: str, matrix: np.ndarray):
+        """
+        Initialize a quantum gate.
+        
+        Args:
+            name: Name of the gate
+            matrix: Unitary matrix representing the gate
+        """
+        self.name = name
+        self.matrix = matrix
+        self.num_qubits = int(np.log2(matrix.shape[0]))
+    
+    def apply(self, state_vector: np.ndarray, target_qubits: List[int]) -> np.ndarray:
+        """
+        Apply the gate to specific qubits.
+        
+        Args:
+            state_vector: Current quantum state vector
+            target_qubits: List of qubit indices to apply the gate to
+            
+        Returns:
+            New state vector after applying the gate
+        """
+        n_qubits = int(np.log2(len(state_vector)))
+        
+        if self.num_qubits == 1 and len(target_qubits) == 1:
+            # Single-qubit gate
+            return self._apply_single_qubit_gate(state_vector, target_qubits[0], n_qubits)
+        elif self.num_qubits == 2 and len(target_qubits) == 2:
+            # Two-qubit gate (like CNOT)
+            return self._apply_two_qubit_gate(state_vector, target_qubits[0], target_qubits[1], n_qubits)
+        else:
+            raise ValueError(f"Gate requires {self.num_qubits} qubits, got {len(target_qubits)}")
+    
+    def _apply_single_qubit_gate(self, state_vector: np.ndarray, target_qubit: int, n_qubits: int) -> np.ndarray:
+        """Apply a single-qubit gate to the state vector."""
+        new_state = np.zeros_like(state_vector)
+        
+        for i in range(len(state_vector)):
+            # Extract the bit value of the target qubit from state index i
+            bit_val = (i >> target_qubit) & 1
+            
+            # Apply gate matrix
+            for new_bit_val in range(2):
+                # Flip the target qubit bit to new_bit_val
+                new_i = i ^ (bit_val << target_qubit) | (new_bit_val << target_qubit)
+                new_state[new_i] += self.matrix[new_bit_val, bit_val] * state_vector[i]
+        
+        return new_state
+    
+    def _apply_two_qubit_gate(self, state_vector: np.ndarray, control_qubit: int, target_qubit: int, n_qubits: int) -> np.ndarray:
+        """Apply a two-qubit gate to the state vector."""
+        new_state = np.zeros_like(state_vector)
+        
+        for i in range(len(state_vector)):
+            # Extract control and target qubit values
+            control_bit = (i >> control_qubit) & 1
+            target_bit = (i >> target_qubit) & 1
+            
+            # For CNOT: flip target if control is 1, otherwise leave unchanged
+            if self.name == "CNOT":
+                if control_bit == 1:
+                    # Flip the target qubit
+                    flipped_i = i ^ (1 << target_qubit)
+                    new_state[flipped_i] += state_vector[i]
+                else:
+                    # Control is 0, no change
+                    new_state[i] += state_vector[i]
+        
+        return new_state
+
+
+# Common single-qubit gates
+X_GATE = QuantumGate("X", np.array([[0, 1], [1, 0]], dtype=complex))
+Y_GATE = QuantumGate("Y", np.array([[0, -1j], [1j, 0]], dtype=complex))
+Z_GATE = QuantumGate("Z", np.array([[1, 0], [0, -1]], dtype=complex))
+H_GATE = QuantumGate("H", np.array([[1, 1], [1, -1]], dtype=complex) / np.sqrt(2))
+
+# Two-qubit gates
+CNOT_GATE = QuantumGate("CNOT", np.array([
+    [1, 0, 0, 0],
+    [0, 1, 0, 0],
+    [0, 0, 0, 1],
+    [0, 0, 1, 0]
+], dtype=complex))

quantum_simulator/simulator.py

@@ -0,0 +1,64 @@
+"""
+Quantum simulator implementation.
+"""
+
+import numpy as np
+from typing import List, Tuple, Optional
+
+
+class QuantumSimulator:
+    """A quantum computer simulator."""
+    
+    def __init__(self, num_qubits: int):
+        """
+        Initialize the quantum simulator.
+        
+        Args:
+            num_qubits: Number of qubits in the quantum system
+        """
+        self.num_qubits = num_qubits
+        self.num_states = 2 ** num_qubits
+        # Initialize all qubits in |0> state
+        self.state_vector = np.zeros(self.num_states, dtype=complex)
+        self.state_vector[0] = 1.0
+    
+    def reset(self) -> None:
+        """Reset all qubits to |0> state."""
+        self.state_vector = np.zeros(self.num_states, dtype=complex)
+        self.state_vector[0] = 1.0
+    
+    def get_state_vector(self) -> np.ndarray:
+        """Get the current state vector."""
+        return self.state_vector.copy()
+    
+    def measure(self, qubit: int) -> int:
+        """
+        Measure a specific qubit.
+        
+        Args:
+            qubit: Index of the qubit to measure (0-indexed)
+            
+        Returns:
+            Measurement result (0 or 1)
+        """
+        # This is a simplified measurement implementation
+        probabilities = np.abs(self.state_vector) ** 2
+        # Calculate probability of measuring |0> for the specified qubit
+        prob_0 = sum(probabilities[i] for i in range(self.num_states) 
+                    if not (i >> qubit) & 1)
+        
+        # Simulate measurement outcome
+        result = 0 if np.random.random() < prob_0 else 1
+        
+        # Collapse the state vector (simplified)
+        new_state = np.zeros_like(self.state_vector)
+        norm = 0
+        for i in range(self.num_states):
+            if ((i >> qubit) & 1) == result:
+                new_state[i] = self.state_vector[i]
+                norm += abs(self.state_vector[i]) ** 2
+        
+        if norm > 0:
+            self.state_vector = new_state / np.sqrt(norm)
+        
+        return result

quantum_simulator-0.1.2.dist-info/METADATA

@@ -0,0 +1,218 @@
+Metadata-Version: 2.4
+Name: quantum-simulator
+Version: 0.1.2
+Summary: A Python library for simulating quantum computers and quantum algorithms
+Project-URL: Homepage, https://github.com/beefy/quantum-simulator
+Project-URL: Documentation, https://beefy.github.io/quantum-simulator/
+Project-URL: Repository, https://github.com/beefy/quantum-simulator.git
+Project-URL: Issues, https://github.com/beefy/quantum-simulator/issues
+Project-URL: Changelog, https://github.com/beefy/quantum-simulator/blob/main/CHANGELOG.md
+Author-email: Nathaniel Schultz <nate.schultz@outlook.com>
+Maintainer-email: Nathaniel Schultz <nate.schultz@outlook.com>
+License: Unlicense
+License-File: LICENSE
+Keywords: computing,quantum,quantum-algorithms,simulation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: Public Domain
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Requires-Dist: numpy>=1.20.0
+Provides-Extra: dev
+Requires-Dist: black; extra == 'dev'
+Requires-Dist: flake8; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pre-commit; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest>=6.0; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-autorefs; extra == 'docs'
+Requires-Dist: mkdocs-gen-files; extra == 'docs'
+Requires-Dist: mkdocs-literate-nav; extra == 'docs'
+Requires-Dist: mkdocs-material>=9.4.0; extra == 'docs'
+Requires-Dist: mkdocs-section-index; extra == 'docs'
+Requires-Dist: mkdocs>=1.4.0; extra == 'docs'
+Requires-Dist: mkdocstrings[python]>=0.19.0; extra == 'docs'
+Requires-Dist: pymdown-extensions>=9.0.0; extra == 'docs'
+Provides-Extra: test
+Requires-Dist: pytest-cov; extra == 'test'
+Requires-Dist: pytest>=6.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# Quantum Simulator
+
+[![Tests](https://github.com/beefy/quantum-simulator/actions/workflows/tests.yml/badge.svg)](https://github.com/beefy/quantum-simulator/actions/workflows/tests.yml)
+[![PyPI version](https://badge.fury.io/py/quantum-simulator.svg)](https://badge.fury.io/py/quantum-simulator)
+[![Documentation](https://img.shields.io/badge/docs-mkdocs-blue)](https://beefy.github.io/quantum-simulator/)
+[![Python versions](https://img.shields.io/pypi/pyversions/quantum-simulator)](https://pypi.org/project/quantum-simulator/)
+[![License: Unlicense](https://img.shields.io/badge/license-Unlicense-blue.svg)](http://unlicense.org/)
+
+A Python library for simulating quantum computers and quantum algorithms. This package provides an easy-to-use interface for quantum state simulation, gate operations, and circuit execution.
+
+## Features
+
+- 🔬 **Quantum State Simulation**: Accurate simulation of quantum states using state vectors
+- 🚪 **Quantum Gates**: Implementation of common single and multi-qubit gates (X, Y, Z, H, CNOT)
+- 🔗 **Quantum Circuits**: Build and execute complex quantum circuits
+- 📊 **Measurement**: Simulate quantum measurements with proper state collapse
+- 🎯 **Easy to Use**: Clean, intuitive API for quantum programming
+- 📚 **Well Documented**: Comprehensive documentation and examples
+
+## Quick Start
+
+### Installation
+
+```bash
+pip install quantum-simulator
+```
+
+### Basic Example
+
+```python
+from quantum_simulator import QuantumSimulator, QuantumCircuit
+from quantum_simulator.gates import H_GATE, CNOT_GATE
+
+# Create a 2-qubit quantum simulator
+sim = QuantumSimulator(2)
+
+# Build a Bell state circuit
+circuit = QuantumCircuit(2)
+circuit.add_gate(H_GATE, [0])        # Hadamard on qubit 0
+circuit.add_gate(CNOT_GATE, [0, 1])  # CNOT with control=0, target=1
+
+# Execute the circuit
+circuit.execute(sim)
+
+# Measure the qubits
+result0 = sim.measure(0)
+result1 = sim.measure(1)
+print(f"Measurement: {result0}, {result1}")
+```
+
+## Documentation
+
+Full documentation is available at **[beefy.github.io/quantum-simulator](https://beefy.github.io/quantum-simulator/)**
+
+- [Installation Guide](https://beefy.github.io/quantum-simulator/getting-started/installation/)
+- [Quick Start](https://beefy.github.io/quantum-simulator/getting-started/quickstart/)
+- [API Reference](https://beefy.github.io/quantum-simulator/reference/)
+- [Examples](https://beefy.github.io/quantum-simulator/getting-started/examples/)
+
+## Development
+
+### Setting Up Development Environment
+
+1. **Clone the repository**:
+   ```bash
+   git clone https://github.com/beefy/quantum-simulator.git
+   cd quantum-simulator
+   ```
+
+2. **Install in development mode**:
+   ```bash
+   pip install -e .[dev,docs]
+   ```
+
+3. **Run tests**:
+   ```bash
+   pytest --cov=quantum_simulator --cov-report=xml --cov-report=term
+   ```
+
+4. **Run lint checks**:
+   ```bash
+   flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+   mypy src/
+   ```
+
+4. **Build documentation**:
+   ```bash
+   mkdocs serve
+   ```
+
+## Publishing
+
+### Publishing to PyPI
+
+This project uses automated publishing via GitHub Actions. To publish a new version:
+
+#### 1. Prepare the Release
+
+1. **Update version** in `src/quantum_simulator/__init__.py`:
+   ```python
+   __version__ = "0.2.0"  # Increment version number
+   ```
+
+2. **Update CHANGELOG.md** with release notes
+
+3. **Commit changes**:
+   ```bash
+   git add .
+   git commit -m "Bump version to 0.2.0"
+   git push
+   ```
+
+#### 2. Create a Release
+
+1. **Create and push a tag**:
+   ```bash
+   git tag v0.2.0
+   git push origin v0.2.0
+   ```
+
+2. **Create a GitHub Release**:
+   - Go to [GitHub Releases](https://github.com/beefy/quantum-simulator/releases)
+   - Click "Create a new release"
+   - Choose the tag you just created
+   - Add release notes
+   - Click "Publish release"
+
+3. **Automated Publishing**:
+   - GitHub Actions will automatically build and publish to PyPI
+   - Check the [Actions tab](https://github.com/beefy/quantum-simulator/actions) for progress
+
+#### 3. Manual Publishing (if needed)
+
+If automated publishing fails, you can publish manually:
+
+```bash
+# Install build tools
+pip install build twine
+
+# Build the package
+python -m build
+
+# Upload to PyPI (requires PyPI API token)
+twine upload dist/*
+```
+
+### Publishing Documentation
+
+Documentation is automatically deployed to GitHub Pages on every push to the `main` branch.
+
+#### Manual Documentation Deployment
+
+```bash
+# Install documentation dependencies
+pip install -e .[docs]
+
+# Build and deploy to GitHub Pages
+mkdocs gh-deploy
+```
+
+#### Local Documentation Development
+
+```bash
+# Serve documentation locally with auto-reload
+mkdocs serve
+
+# Open http://localhost:8000 in your browser
+```

quantum_simulator-0.1.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+quantum_simulator/__init__.py,sha256=FoEw_1BFNSoVnGICjGQKbeeDiMjx1zWmA2oo8TF-h-c,378
+quantum_simulator/circuits.py,sha256=GEuH9qfOH0yYiC-T_3hADjpo55rwX84JT4oMtDrEVWE,1492
+quantum_simulator/gates.py,sha256=TP3WE09fyd6B-YSpJ0cOV5PFQ0FPuZY3Cc0HJUXNjLA,3599
+quantum_simulator/simulator.py,sha256=kI_UxbQZr9NG_ZfGR3oZk9D2DM4qHLp7S6OYSsig-Cc,2018
+quantum_simulator-0.1.2.dist-info/METADATA,sha256=HztRRcoHD-yk8OsS4AAUMAAPKmtRwOjRgZV1knd2Bzc,6986
+quantum_simulator-0.1.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+quantum_simulator-0.1.2.dist-info/entry_points.txt,sha256=ASQZ3hc87SvvB-KxgD3ZAxh09k4HWzJX0iciD1D5st4,59
+quantum_simulator-0.1.2.dist-info/licenses/LICENSE,sha256=awOCsWJ58m_2kBQwBUGWejVqZm6wuRtCL2hi9rfa0X4,1211
+quantum_simulator-0.1.2.dist-info/RECORD,,

quantum_simulator-0.1.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

quantum_simulator-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+quantum-sim = quantum_simulator.cli:main

quantum_simulator-0.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org>