fqkit 0.1.0__tar.gz

fqkit-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Felix
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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 OR COPYRIGHT HOLDERS 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.

fqkit-0.1.0/PKG-INFO

@@ -0,0 +1,237 @@
+Metadata-Version: 2.4
+Name: fqkit
+Version: 0.1.0
+Summary: A lightweight Python framework for building and simulating quantum circuits.
+Author-email: Felix <felixo6996@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Felixowusu20/Fqkit
+Keywords: quantum,quantum-computing,simulator,education,qiskit
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Provides-Extra: ibm
+Requires-Dist: qiskit>=1.3; extra == "ibm"
+Requires-Dist: qiskit-ibm-runtime>=0.30; extra == "ibm"
+Provides-Extra: braket
+Requires-Dist: amazon-braket-sdk>=1.88; extra == "braket"
+Provides-Extra: hardware
+Requires-Dist: qiskit>=1.3; extra == "hardware"
+Requires-Dist: qiskit-ibm-runtime>=0.30; extra == "hardware"
+Requires-Dist: amazon-braket-sdk>=1.88; extra == "hardware"
+Dynamic: license-file
+
+# FQkit
+
+FQkit is a small Python framework for building and simulating quantum
+circuits. The source stays short on purpose, so you can learn how a quantum
+computer works by reading it and changing it.
+
+> **Documentation website:** the full docs live in [`website/`](website): a
+> Next.js + Nextra site. Run it locally with `cd website && npm install && npm
+> run dev`, or deploy it for free on Vercel (see the
+> [website README](website/README.md)).
+
+## Features
+
+- Qubits and parameterized gates (`H`, `RX`, `RY`, `RZ`)
+- Multi-qubit gates: `CNOT`, `CZ`, `SWAP`, `Toffoli`
+- Circuit construction with `QuantumCircuit`
+- Parameter binding for variational circuits
+- A statevector simulator that returns the final state
+- Measurement with shot-based sampling
+- Export to OpenQASM 2.0: run your circuits on real IBM hardware via Qiskit
+
+## Installation
+
+```bash
+pip install fqkit
+```
+
+FQkit needs Python 3.9 or newer. NumPy is installed with it.
+
+To work on the source, clone the repository and install it in editable mode:
+
+```bash
+git clone https://github.com/Felixowusu20/Fqkit.git
+cd Fqkit
+pip install -e ".[dev]"
+pytest
+```
+
+## Quick start
+
+Build a Bell state, an entangled pair of qubits, and measure it:
+
+```python
+from fqkit import QuantumCircuit, Hadamard, CNOT, run, measure_all
+
+qc = QuantumCircuit(2)
+qc.add_gate(Hadamard(), [0])      # put qubit 0 into superposition
+qc.add_gate(CNOT(), [0, 1])       # entangle qubit 1 with qubit 0
+
+state = run(qc)                   # -> array([0.707, 0, 0, 0.707])
+counts = measure_all(state, shots=1024)
+
+print("State :", state)
+print("Counts:", counts)          # -> {'00': ~512, '11': ~512}
+```
+
+## Variational circuits
+
+Gates can take symbolic `Parameter`s that you bind to numbers later: the basis
+of variational algorithms like VQE and QAOA:
+
+```python
+from fqkit import QuantumCircuit, Hadamard, RX, Parameter, bind_parameters, run, measure_all
+
+theta = Parameter("theta")
+
+qc = QuantumCircuit(2)
+qc.add_gate(Hadamard(), [0])
+qc.add_gate(RX(theta), [1])
+
+bind_parameters(qc, {"theta": 3.14159})
+
+counts = measure_all(run(qc), shots=1024)
+print(counts)
+```
+
+## Export to OpenQASM: run on real hardware
+
+Any circuit can be exported to OpenQASM 2.0, the open standard that Qiskit
+reads. That means a circuit you build in fqkit can run on a **real quantum
+computer** through IBM Quantum's free tier: no hardware of your own needed.
+Everything in this pipeline (OpenQASM, Qiskit, the IBM free tier) costs nothing.
+
+```python
+from fqkit import QuantumCircuit, Hadamard, CNOT
+
+qc = QuantumCircuit(2)
+qc.add_gate(Hadamard(), [0])
+qc.add_gate(CNOT(), [0, 1])
+
+print(qc.to_qasm())          # or: to_qasm(qc)
+```
+
+```
+OPENQASM 2.0;
+include "qelib1.inc";
+qreg q[2];
+creg c[2];
+h q[0];
+cx q[0], q[1];
+measure q -> c;
+```
+
+### Load it in Qiskit (free)
+
+`pip install qiskit` (free and open source), then:
+
+```python
+from qiskit import QuantumCircuit as QiskitCircuit
+from qiskit.quantum_info import Statevector
+
+qiskit_qc = QiskitCircuit.from_qasm_str(qc.to_qasm(measure=False))
+print(Statevector.from_instruction(qiskit_qc).probabilities_dict())
+# {'00': 0.5, '11': 0.5}
+```
+
+### Run on real hardware
+
+`run()` stays on your computer. Hardware jobs go through `fqkit.hardware`,
+which calls the vendor SDK, waits on the queue, and returns counts in fqkit
+bit order (qubit 0 on the left). The vendor packages are optional, so a normal
+install still depends only on NumPy.
+
+```bash
+pip install "fqkit[ibm]"       # IBM Quantum, through Qiskit Runtime
+pip install "fqkit[braket]"    # IonQ, Rigetti, IQM, and AQT, through Amazon Braket
+pip install "fqkit[hardware]"  # both
+```
+
+```python
+from fqkit.hardware import providers, submit
+
+providers()                    # ibm, ionq, rigetti, iqm, aqt
+
+job = submit(qc, "ibm", shots=1024)
+print(job.job_id, job.status())   # QUEUED, RUNNING, COMPLETED, CANCELLED, FAILED
+print(job.counts())               # waits for the device
+
+job = submit(qc, "ionq", shots=100)
+job = submit(qc, "rigetti", shots=100)
+```
+
+IBM needs a free account at https://quantum.cloud.ibm.com. Save the token once
+with `QiskitRuntimeService.save_account`, or pass `token=` to `submit`. With
+no backend name, fqkit picks the least busy real device. Pass
+`backend="ibm_..."` to choose one, or `backends("ibm", live=True)` to list
+the devices that are up.
+
+IonQ, Rigetti, IQM, and AQT are one Amazon Braket account. Those QPU tasks are
+billed by AWS. `submit(qc, "ionq")` targets IonQ Forte-1. Pass `backend=` as a
+full device ARN when you need a different chip. `job.status()` returns
+immediately. `job.counts()` blocks until the machine finishes. `get_job(machine,
+job_id)` reconnects to a job you already submitted.
+
+The lessons in the browser keep using the local simulator. A hardware token
+stays in your own Python process.
+
+## Project layout
+
+```
+fqkit/
+  core/
+    qubit.py              # Qubit: an index into Hilbert space
+    parameter.py          # Parameter: a symbolic variable
+    gate.py               # Gate + H, RX, RY, RZ, CNOT, CZ, SWAP, Toffoli
+    operation.py          # Operation: a gate applied to specific qubits
+    circuit.py            # QuantumCircuit: an ordered list of operations
+    parameter_binding.py  # bind_parameters: substitute symbols -> numbers
+    simulator.py          # run: apply gates to a statevector
+    measurement.py        # measure_all: sample |amplitude|^2
+    qasm.py               # to_qasm: export circuits to OpenQASM 2.0
+  hardware/
+    ibm.py                # IBM Quantum via Qiskit Runtime
+    braket.py             # IonQ, Rigetti, IQM, AQT via Amazon Braket
+```
+
+## Convention
+
+FQkit uses **big-endian** qubit ordering: qubit 0 is the most significant bit
+of the state-vector index, and the first qubit passed to a multi-qubit gate is
+its most significant qubit (for `CNOT`, the control).
+
+## Testing
+
+FQkit ships with a `pytest` suite covering the simulator, every gate, parameter
+binding, measurement, input validation, and the OpenQASM export, including
+round-trip tests that load an exported circuit into Qiskit and check that the
+statevectors match fqkit's own simulator.
+
+```bash
+pip install -e ".[dev]"   # installs pytest
+pytest -v                 # 46 tests
+```
+
+The Qiskit round-trip tests are skipped automatically if Qiskit is not
+installed. Install it (free) with `pip install qiskit` to run those too.
+
+| Test file | Covers |
+|---|---|
+| `tests/test_fqkit.py` | Single- and multi-qubit gates, entanglement (Bell states), reversed and non-adjacent controls, parameter binding, unbound-parameter errors, measurement statistics, and input validation |
+| `tests/test_qasm.py` | OpenQASM string output, gate-name mapping, error handling, and Qiskit round-trip equivalence |
+| `tests/test_hardware.py` | Machine selection, OpenQASM 3 for Braket, Runtime and Braket submission with stand-in SDKs, job status, and bit order |

fqkit-0.1.0/README.md

@@ -0,0 +1,202 @@
+# FQkit
+
+FQkit is a small Python framework for building and simulating quantum
+circuits. The source stays short on purpose, so you can learn how a quantum
+computer works by reading it and changing it.
+
+> **Documentation website:** the full docs live in [`website/`](website): a
+> Next.js + Nextra site. Run it locally with `cd website && npm install && npm
+> run dev`, or deploy it for free on Vercel (see the
+> [website README](website/README.md)).
+
+## Features
+
+- Qubits and parameterized gates (`H`, `RX`, `RY`, `RZ`)
+- Multi-qubit gates: `CNOT`, `CZ`, `SWAP`, `Toffoli`
+- Circuit construction with `QuantumCircuit`
+- Parameter binding for variational circuits
+- A statevector simulator that returns the final state
+- Measurement with shot-based sampling
+- Export to OpenQASM 2.0: run your circuits on real IBM hardware via Qiskit
+
+## Installation
+
+```bash
+pip install fqkit
+```
+
+FQkit needs Python 3.9 or newer. NumPy is installed with it.
+
+To work on the source, clone the repository and install it in editable mode:
+
+```bash
+git clone https://github.com/Felixowusu20/Fqkit.git
+cd Fqkit
+pip install -e ".[dev]"
+pytest
+```
+
+## Quick start
+
+Build a Bell state, an entangled pair of qubits, and measure it:
+
+```python
+from fqkit import QuantumCircuit, Hadamard, CNOT, run, measure_all
+
+qc = QuantumCircuit(2)
+qc.add_gate(Hadamard(), [0])      # put qubit 0 into superposition
+qc.add_gate(CNOT(), [0, 1])       # entangle qubit 1 with qubit 0
+
+state = run(qc)                   # -> array([0.707, 0, 0, 0.707])
+counts = measure_all(state, shots=1024)
+
+print("State :", state)
+print("Counts:", counts)          # -> {'00': ~512, '11': ~512}
+```
+
+## Variational circuits
+
+Gates can take symbolic `Parameter`s that you bind to numbers later: the basis
+of variational algorithms like VQE and QAOA:
+
+```python
+from fqkit import QuantumCircuit, Hadamard, RX, Parameter, bind_parameters, run, measure_all
+
+theta = Parameter("theta")
+
+qc = QuantumCircuit(2)
+qc.add_gate(Hadamard(), [0])
+qc.add_gate(RX(theta), [1])
+
+bind_parameters(qc, {"theta": 3.14159})
+
+counts = measure_all(run(qc), shots=1024)
+print(counts)
+```
+
+## Export to OpenQASM: run on real hardware
+
+Any circuit can be exported to OpenQASM 2.0, the open standard that Qiskit
+reads. That means a circuit you build in fqkit can run on a **real quantum
+computer** through IBM Quantum's free tier: no hardware of your own needed.
+Everything in this pipeline (OpenQASM, Qiskit, the IBM free tier) costs nothing.
+
+```python
+from fqkit import QuantumCircuit, Hadamard, CNOT
+
+qc = QuantumCircuit(2)
+qc.add_gate(Hadamard(), [0])
+qc.add_gate(CNOT(), [0, 1])
+
+print(qc.to_qasm())          # or: to_qasm(qc)
+```
+
+```
+OPENQASM 2.0;
+include "qelib1.inc";
+qreg q[2];
+creg c[2];
+h q[0];
+cx q[0], q[1];
+measure q -> c;
+```
+
+### Load it in Qiskit (free)
+
+`pip install qiskit` (free and open source), then:
+
+```python
+from qiskit import QuantumCircuit as QiskitCircuit
+from qiskit.quantum_info import Statevector
+
+qiskit_qc = QiskitCircuit.from_qasm_str(qc.to_qasm(measure=False))
+print(Statevector.from_instruction(qiskit_qc).probabilities_dict())
+# {'00': 0.5, '11': 0.5}
+```
+
+### Run on real hardware
+
+`run()` stays on your computer. Hardware jobs go through `fqkit.hardware`,
+which calls the vendor SDK, waits on the queue, and returns counts in fqkit
+bit order (qubit 0 on the left). The vendor packages are optional, so a normal
+install still depends only on NumPy.
+
+```bash
+pip install "fqkit[ibm]"       # IBM Quantum, through Qiskit Runtime
+pip install "fqkit[braket]"    # IonQ, Rigetti, IQM, and AQT, through Amazon Braket
+pip install "fqkit[hardware]"  # both
+```
+
+```python
+from fqkit.hardware import providers, submit
+
+providers()                    # ibm, ionq, rigetti, iqm, aqt
+
+job = submit(qc, "ibm", shots=1024)
+print(job.job_id, job.status())   # QUEUED, RUNNING, COMPLETED, CANCELLED, FAILED
+print(job.counts())               # waits for the device
+
+job = submit(qc, "ionq", shots=100)
+job = submit(qc, "rigetti", shots=100)
+```
+
+IBM needs a free account at https://quantum.cloud.ibm.com. Save the token once
+with `QiskitRuntimeService.save_account`, or pass `token=` to `submit`. With
+no backend name, fqkit picks the least busy real device. Pass
+`backend="ibm_..."` to choose one, or `backends("ibm", live=True)` to list
+the devices that are up.
+
+IonQ, Rigetti, IQM, and AQT are one Amazon Braket account. Those QPU tasks are
+billed by AWS. `submit(qc, "ionq")` targets IonQ Forte-1. Pass `backend=` as a
+full device ARN when you need a different chip. `job.status()` returns
+immediately. `job.counts()` blocks until the machine finishes. `get_job(machine,
+job_id)` reconnects to a job you already submitted.
+
+The lessons in the browser keep using the local simulator. A hardware token
+stays in your own Python process.
+
+## Project layout
+
+```
+fqkit/
+  core/
+    qubit.py              # Qubit: an index into Hilbert space
+    parameter.py          # Parameter: a symbolic variable
+    gate.py               # Gate + H, RX, RY, RZ, CNOT, CZ, SWAP, Toffoli
+    operation.py          # Operation: a gate applied to specific qubits
+    circuit.py            # QuantumCircuit: an ordered list of operations
+    parameter_binding.py  # bind_parameters: substitute symbols -> numbers
+    simulator.py          # run: apply gates to a statevector
+    measurement.py        # measure_all: sample |amplitude|^2
+    qasm.py               # to_qasm: export circuits to OpenQASM 2.0
+  hardware/
+    ibm.py                # IBM Quantum via Qiskit Runtime
+    braket.py             # IonQ, Rigetti, IQM, AQT via Amazon Braket
+```
+
+## Convention
+
+FQkit uses **big-endian** qubit ordering: qubit 0 is the most significant bit
+of the state-vector index, and the first qubit passed to a multi-qubit gate is
+its most significant qubit (for `CNOT`, the control).
+
+## Testing
+
+FQkit ships with a `pytest` suite covering the simulator, every gate, parameter
+binding, measurement, input validation, and the OpenQASM export, including
+round-trip tests that load an exported circuit into Qiskit and check that the
+statevectors match fqkit's own simulator.
+
+```bash
+pip install -e ".[dev]"   # installs pytest
+pytest -v                 # 46 tests
+```
+
+The Qiskit round-trip tests are skipped automatically if Qiskit is not
+installed. Install it (free) with `pip install qiskit` to run those too.
+
+| Test file | Covers |
+|---|---|
+| `tests/test_fqkit.py` | Single- and multi-qubit gates, entanglement (Bell states), reversed and non-adjacent controls, parameter binding, unbound-parameter errors, measurement statistics, and input validation |
+| `tests/test_qasm.py` | OpenQASM string output, gate-name mapping, error handling, and Qiskit round-trip equivalence |
+| `tests/test_hardware.py` | Machine selection, OpenQASM 3 for Braket, Runtime and Braket submission with stand-in SDKs, job status, and bit order |

fqkit-0.1.0/fqkit/__init__.py

@@ -0,0 +1,59 @@
+"""
+FQkit — a lightweight quantum circuit framework for learning and simulation.
+
+Quick start
+-----------
+    from fqkit import QuantumCircuit, Hadamard, CNOT, run, measure_all
+
+    qc = QuantumCircuit(2)
+    qc.add_gate(Hadamard(), [0])
+    qc.add_gate(CNOT(), [0, 1])
+
+    state = run(qc)
+    counts = measure_all(state, shots=1024)
+"""
+
+from fqkit.core import (
+    Qubit,
+    Parameter,
+    Gate,
+    Hadamard,
+    RX,
+    RY,
+    RZ,
+    CNOT,
+    CZ,
+    SWAP,
+    Toffoli,
+    Operation,
+    QuantumCircuit,
+    bind_parameters,
+    run,
+    apply_gate,
+    measure_all,
+    to_qasm,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Qubit",
+    "Parameter",
+    "Gate",
+    "Hadamard",
+    "RX",
+    "RY",
+    "RZ",
+    "CNOT",
+    "CZ",
+    "SWAP",
+    "Toffoli",
+    "Operation",
+    "QuantumCircuit",
+    "bind_parameters",
+    "run",
+    "apply_gate",
+    "measure_all",
+    "to_qasm",
+    "__version__",
+]

fqkit-0.1.0/fqkit/core/__init__.py

@@ -0,0 +1,42 @@
+"""fqkit.core — the building blocks of an fqkit quantum circuit."""
+
+from fqkit.core.qubit import Qubit
+from fqkit.core.parameter import Parameter
+from fqkit.core.gate import (
+    Gate,
+    Hadamard,
+    RX,
+    RY,
+    RZ,
+    CNOT,
+    CZ,
+    SWAP,
+    Toffoli,
+)
+from fqkit.core.operation import Operation
+from fqkit.core.circuit import QuantumCircuit
+from fqkit.core.parameter_binding import bind_parameters
+from fqkit.core.simulator import run, apply_gate
+from fqkit.core.measurement import measure_all
+from fqkit.core.qasm import to_qasm
+
+__all__ = [
+    "Qubit",
+    "Parameter",
+    "Gate",
+    "Hadamard",
+    "RX",
+    "RY",
+    "RZ",
+    "CNOT",
+    "CZ",
+    "SWAP",
+    "Toffoli",
+    "Operation",
+    "QuantumCircuit",
+    "bind_parameters",
+    "run",
+    "apply_gate",
+    "measure_all",
+    "to_qasm",
+]

fqkit-0.1.0/fqkit/core/circuit.py

@@ -0,0 +1,40 @@
+from fqkit.core.operation import Operation
+from fqkit.core.qubit import Qubit
+from fqkit.core.qasm import to_qasm as _to_qasm
+
+class QuantumCircuit:
+    def __init__(self , num_qubits:int):
+        if num_qubits <= 0:
+            raise ValueError("A circuit needs at least one qubit.")
+        self.num_qubits = num_qubits
+        self.qubits = [Qubit(i) for i in range(num_qubits)]
+        self.operations = []
+
+    def add_gate(self, gate, target_qubits):
+        # Convert Qubit objects to indices automatically
+        target_qubits = [q.index if isinstance(q, Qubit) else q for q in target_qubits]
+
+        if len(target_qubits) != gate.num_qubits:
+            raise ValueError(f"Gate {gate.name} requires {gate.num_qubits} qubits, "
+                             f"but {len(target_qubits)} were provided.")
+        if min(target_qubits) < 0:
+            raise ValueError("Target qubit index cannot be negative")
+        if max(target_qubits) >= self.num_qubits:
+            raise ValueError("Target qubit index exceeds circuit size")
+        if len(set(target_qubits)) != len(target_qubits):
+            raise ValueError(f"Gate {gate.name} was given a repeated target qubit: "
+                             f"{target_qubits}")
+
+        op = Operation(gate, target_qubits)
+        self.operations.append(op)
+
+    def to_qasm(self, measure=True):
+        """Return this circuit as an OpenQASM 2.0 string.
+
+        See fqkit.core.qasm.to_qasm for details.
+        """
+        return _to_qasm(self, measure=measure)
+
+    def __repr__(self):
+        op_str = '\n'.join([str(op) for op in self.operations])
+        return f"QuantumCircuit({self.num_qubits}, [\n{op_str}\n])"

fqkit-0.1.0/fqkit/core/gate.py

@@ -0,0 +1,76 @@
+# Gates (unitary operators)
+# A gate is a unitary matrix: U such that U†U = I.
+# Some gates are parameterized.
+
+# BASE GATE CLASS
+
+class Gate:
+    def __init__(self ,name:str ,num_qubits:int ,matrix = None ,params = None):
+        self.name = name
+        self.num_qubits = num_qubits
+        self.matrix = matrix
+        self.params = params or []
+
+    def __repr__(self):
+        if self.params:
+            params = ', '.join([str(p) for p in self.params])
+            return f"{self.name}({params})"
+        else:
+            return f"{self.name}"
+        
+
+
+# # let try creating some gates (Hadamard, CNOT, RX , Toffoli , swap and the rest will be added)
+def Hadamard():
+    return Gate(name="H", num_qubits=1, matrix=[[1/2**0.5, 1/2**0.5], [1/2**0.5, -1/2**0.5]])
+
+
+# def CNOT():
+#     return Gate(name="CNOT", num_quibits=2, matrix=[[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]])
+def RX(theta):
+    return Gate(name="RX", num_qubits=1, params=[theta])
+
+
+def RY(theta):
+    return Gate(name="RY", num_qubits=1, params=[theta])
+
+
+def RZ(theta):
+    return Gate(name="RZ", num_qubits=1, params=[theta])
+def CNOT():
+    return Gate(name="CNOT", num_qubits=2, matrix=[[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]])
+
+
+# You can add more gates as needed
+# For example, CZ, SWAP, Toffoli, etc.
+
+def CZ():
+    return Gate(
+        name="CZ", 
+        num_qubits=2, 
+        matrix=[[1, 0, 0, 0], [0, 1, 0, 0],
+                [0, 0, 1, 0], [0, 0, 0, -1]])
+def SWAP():
+    return Gate(
+        name="SWAP",
+                 num_qubits=2,
+                 matrix=[[1, 0, 0, 0], [0, 0, 1, 0],
+                         [0, 1, 0, 0], [0, 0, 0, 1]])    
+def Toffoli():
+    return Gate(
+        name="Toffoli",
+        num_qubits=3,
+        matrix=[
+            [1, 0, 0, 0, 0, 0, 0, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0],
+            [0, 0, 1, 0, 0, 0, 0, 0],
+            [0, 0, 0, 1, 0, 0, 0, 0],
+            [0, 0, 0, 0, 1, 0, 0, 0],
+            [0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 1],
+            [0, 0, 0, 0, 0, 0, 1, 0]
+        ]
+    )
+
+
+