# Qubit-Flow Quantum Computing Language
**A complementary quantum computing language designed to work seamlessly with Synapse-Lang**
## Overview
Qubit-Flow is a specialized quantum computing language that complements Synapse-Lang's scientific reasoning capabilities. While Synapse-Lang excels at parallel hypothesis testing, uncertainty quantification, and scientific reasoning chains, Qubit-Flow provides direct quantum circuit manipulation, quantum algorithm implementation, and hardware-agnostic quantum execution.
## Key Features
### 🔬 **Complementary to Synapse-Lang**
- **Synapse-Lang**: Scientific reasoning, uncertainty propagation, parallel thought streams
- **Qubit-Flow**: Pure quantum computation, circuit design, quantum algorithm execution
- **Bridge Layer**: Seamless interoperability and quantum-enhanced scientific reasoning
### ⚛️ **Quantum-First Design**
```qubit-flow
# Direct quantum circuit construction
qubit q0 = |0⟩
qubit q1 = |+⟩
circuit bell_state(q0, q1) {
H[q0]
CNOT[q0, q1]
measure q0 -> result0
measure q1 -> result1
}
```
### 🧮 **Native Quantum Algorithms**
```qubit-flow
# Grover's search
grovers(16, oracle_function, 3)
# Shor's factoring
shors(15)
# Variational Quantum Eigensolver
vqe(hamiltonian, ansatz, "COBYLA")
# Quantum Fourier Transform
qft(q0, q1, q2, q3)
```
### 🔗 **Advanced Quantum Operations**
```qubit-flow
# Quantum entanglement
entangle(alice, bob) bell
# Quantum superposition with custom amplitudes
superpose charlie {
"0" = 0.6+0.0i
"1" = 0.8+0.0i
}
# Quantum teleportation
teleport source -> (entangled1, entangled2) -> target
```
## Hybrid Execution with Synapse-Lang
The real power comes from combining both languages for quantum-enhanced scientific reasoning:
### Example: Quantum Chemistry Simulation
**Synapse-Lang (Hypothesis and Uncertainty)**:
```synapse
uncertain bond_length = 1.54 ± 0.02
uncertain bond_energy = 348 ± 5
hypothesis molecular_structure {
assume: quantum_superposition_effects
predict: enhanced_stability
validate: vqe_ground_state
}
parallel {
branch classical: molecular_dynamics_simulation
branch quantum: quantum_chemistry_vqe
branch hybrid: quantum_classical_coupling
}
```
**Qubit-Flow (Quantum Computation)**:
```qubit-flow
# VQE for molecular ground state
qubit h1 = |0⟩
qubit h2 = |0⟩
# Prepare trial wavefunction
circuit molecular_ansatz(h1, h2) {
RY(theta1)[h1]
RY(theta2)[h2]
CNOT[h1, h2]
RY(theta3)[h2]
}
# Execute VQE
vqe(molecular_hamiltonian, molecular_ansatz, "COBYLA")
```
**Bridge Integration**:
```python
from synapse_qubit_bridge import create_hybrid_interpreter
bridge = create_hybrid_interpreter()
results = bridge.execute_hybrid(synapse_code, qubit_code)
# Quantum-enhanced uncertain values
quantum_bond_energy = bridge.quantum_enhance_uncertainty("bond_energy", "computational")
```
## Language Architecture
### Core Components
1. **Qubit-Flow Lexer** (`qubit_flow_lexer.py`)
- Quantum-specific tokens (H, X, Y, Z, CNOT, etc.)
- Scientific notation for quantum states (|ψ⟩, ⟨φ|)
- Complex number support (1+2i)
2. **Qubit-Flow AST** (`qubit_flow_ast.py`)
- Quantum circuit nodes
- Gate operation nodes
- Measurement and entanglement nodes
- Quantum algorithm nodes
3. **Qubit-Flow Parser** (`qubit_flow_parser.py`)
- Circuit definition parsing
- Quantum gate sequence parsing
- Algorithm parameter parsing
4. **Qubit-Flow Interpreter** (`qubit_flow_interpreter.py`)
- Quantum state simulation
- Gate operation execution
- Measurement simulation
- Algorithm implementations
5. **Synapse-Qubit Bridge** (`synapse_qubit_bridge.py`)
- Variable sharing between languages
- Quantum-enhanced uncertain values
- Parallel quantum reasoning
- Measurement feedback loops
## Quantum Operations Reference
### Single-Qubit Gates
```qubit-flow
H[q0] # Hadamard gate
X[q0] # Pauli-X (NOT gate)
Y[q0] # Pauli-Y gate
Z[q0] # Pauli-Z gate
RX(π/4)[q0] # X-rotation gate
RY(π/2)[q0] # Y-rotation gate
RZ(π/3)[q0] # Z-rotation gate
PHASE(π/6)[q0] # Phase gate
```
### Multi-Qubit Gates
```qubit-flow
CNOT[control, target] # Controlled-NOT
CZ[control, target] # Controlled-Z
TOFFOLI[control1, control2, target] # Toffoli gate
```
### Measurements
```qubit-flow
measure q0 -> classical_bit # Single measurement
measure q0, q1 -> c0, c1 # Multiple measurements
```
### Quantum Algorithms
```qubit-flow
# Grover's Algorithm
grovers(search_space_size, oracle_function, iterations)
# Shor's Algorithm
shors(number_to_factor)
# Variational Quantum Eigensolver
vqe(hamiltonian, ansatz_circuit, optimizer)
# Quantum Approximate Optimization Algorithm
qaoa(cost_hamiltonian, mixer_hamiltonian, layers)
# Quantum Fourier Transform
qft(qubit_list)
qft(qubit_list) inverse # Inverse QFT
```
## Integration Patterns
### Pattern 1: Quantum-Enhanced Hypothesis Testing
```python
# Use Synapse for hypothesis formation, Qubit-Flow for quantum verification
bridge = create_hybrid_interpreter()
synapse_hypothesis = """
hypothesis quantum_advantage {
assume: superposition_available
predict: exponential_speedup
validate: quantum_measurement
}
"""
qubit_verification = """
# Implement quantum algorithm to test hypothesis
grovers(1024, search_oracle, optimal_iterations)
"""
results = bridge.execute_hybrid(synapse_hypothesis, qubit_verification)
```
### Pattern 2: Uncertainty-Quantum State Mapping
```python
# Map classical uncertainty to quantum superposition
bridge.quantum_enhance_uncertainty("measurement", "hadamard")
# Perform quantum operations and feed back to uncertainty
measurement = bridge.quantum_measurement_feedback("q0", "Z")
```
### Pattern 3: Parallel Quantum Reasoning
```python
# Run multiple quantum-enhanced reasoning branches
reasoning_branches = [
("path1", synapse_code1, qubit_code1),
("path2", synapse_code2, qubit_code2),
("path3", synapse_code3, qubit_code3)
]
consensus = bridge.parallel_quantum_reasoning(reasoning_branches)
```
## Testing and Examples
Run the comprehensive test suite:
```bash
python test_qubit_flow.py
```
### Example Test Output
```
============================================================
TEST: Basic Qubit Operations
============================================================
Created qubits: 3 operations
qubit q0 = QuantumState(1 qubits): [1.+0.j 0.+0.j]
qubit q1 = QuantumState(1 qubits): [0.+0.j 1.+0.j]
qubit q2 = QuantumState(1 qubits): [0.70710678+0.j 0.70710678+0.j]
✓ All qubits created successfully
[PASSED] test_basic_qubit_operations
```
## Comparison: Synapse-Lang vs Qubit-Flow
| Feature | Synapse-Lang | Qubit-Flow |
|---------|--------------|------------|
| **Primary Focus** | Scientific reasoning | Quantum computation |
| **Uncertainty** | Built-in uncertainty propagation | Quantum superposition states |
| **Parallelism** | Thought streams & hypothesis testing | Quantum circuit parallelism |
| **Algorithms** | Scientific method, reasoning chains | Quantum algorithms (Shor's, Grover's) |
| **Hardware** | Classical computation | Quantum hardware abstraction |
| **Integration** | ✅ Seamless bridge layer | ✅ Seamless bridge layer |
## Future Extensions
- **Quantum Error Correction**: Built-in error mitigation strategies
- **Hardware Backends**: IBM Quantum, Google Quantum AI, IonQ integration
- **Advanced Algorithms**: QAOA, quantum machine learning, quantum chemistry
- **Optimization**: Circuit compilation and optimization
- **Visualization**: Quantum circuit diagrams and state visualization
## Contributing
Qubit-Flow is designed as a complementary language to enhance Synapse-Lang's scientific reasoning with quantum computational power. The bridge architecture allows both languages to leverage their respective strengths while maintaining clean separation of concerns.
---
*Quantum computing meets scientific reasoning - where uncertainty principles become computational advantages.*
Raw data
{
"_id": null,
"home_page": "https://github.com/MichaelCrowe11/synapse-lang",
"name": "synapse-qubit-flow",
"maintainer": "Michael Benjamin Crowe",
"docs_url": null,
"requires_python": ">=3.8",
"maintainer_email": null,
"keywords": "quantum-computing, quantum-circuits, quantum-algorithms, programming-language, interpreter, qiskit, pennylane, cirq, quantum-gates, qubit-operations",
"author": "Michael Benjamin Crowe",
"author_email": "michaelcrowe11@users.noreply.github.com",
"download_url": "https://files.pythonhosted.org/packages/49/d1/793599e39ea81b74b4eff354c4e62c8c9645e584a121377a3d7a72bcd3ae/synapse_qubit_flow-1.0.0.tar.gz",
"platform": null,
"description": "# Qubit-Flow Quantum Computing Language\r\n\r\n**A complementary quantum computing language designed to work seamlessly with Synapse-Lang**\r\n\r\n## Overview\r\n\r\nQubit-Flow is a specialized quantum computing language that complements Synapse-Lang's scientific reasoning capabilities. While Synapse-Lang excels at parallel hypothesis testing, uncertainty quantification, and scientific reasoning chains, Qubit-Flow provides direct quantum circuit manipulation, quantum algorithm implementation, and hardware-agnostic quantum execution.\r\n\r\n## Key Features\r\n\r\n### \ud83d\udd2c **Complementary to Synapse-Lang**\r\n- **Synapse-Lang**: Scientific reasoning, uncertainty propagation, parallel thought streams\r\n- **Qubit-Flow**: Pure quantum computation, circuit design, quantum algorithm execution\r\n- **Bridge Layer**: Seamless interoperability and quantum-enhanced scientific reasoning\r\n\r\n### \u269b\ufe0f **Quantum-First Design**\r\n```qubit-flow\r\n# Direct quantum circuit construction\r\nqubit q0 = |0\u27e9\r\nqubit q1 = |+\u27e9\r\n\r\ncircuit bell_state(q0, q1) {\r\n H[q0]\r\n CNOT[q0, q1]\r\n measure q0 -> result0\r\n measure q1 -> result1\r\n}\r\n```\r\n\r\n### \ud83e\uddee **Native Quantum Algorithms**\r\n```qubit-flow\r\n# Grover's search\r\ngrovers(16, oracle_function, 3)\r\n\r\n# Shor's factoring \r\nshors(15)\r\n\r\n# Variational Quantum Eigensolver\r\nvqe(hamiltonian, ansatz, \"COBYLA\")\r\n\r\n# Quantum Fourier Transform\r\nqft(q0, q1, q2, q3)\r\n```\r\n\r\n### \ud83d\udd17 **Advanced Quantum Operations**\r\n```qubit-flow\r\n# Quantum entanglement\r\nentangle(alice, bob) bell\r\n\r\n# Quantum superposition with custom amplitudes\r\nsuperpose charlie {\r\n \"0\" = 0.6+0.0i\r\n \"1\" = 0.8+0.0i\r\n}\r\n\r\n# Quantum teleportation\r\nteleport source -> (entangled1, entangled2) -> target\r\n```\r\n\r\n## Hybrid Execution with Synapse-Lang\r\n\r\nThe real power comes from combining both languages for quantum-enhanced scientific reasoning:\r\n\r\n### Example: Quantum Chemistry Simulation\r\n\r\n**Synapse-Lang (Hypothesis and Uncertainty)**:\r\n```synapse\r\nuncertain bond_length = 1.54 \u00b1 0.02\r\nuncertain bond_energy = 348 \u00b1 5\r\n\r\nhypothesis molecular_structure {\r\n assume: quantum_superposition_effects\r\n predict: enhanced_stability\r\n validate: vqe_ground_state\r\n}\r\n\r\nparallel {\r\n branch classical: molecular_dynamics_simulation\r\n branch quantum: quantum_chemistry_vqe\r\n branch hybrid: quantum_classical_coupling\r\n}\r\n```\r\n\r\n**Qubit-Flow (Quantum Computation)**:\r\n```qubit-flow\r\n# VQE for molecular ground state\r\nqubit h1 = |0\u27e9\r\nqubit h2 = |0\u27e9\r\n\r\n# Prepare trial wavefunction\r\ncircuit molecular_ansatz(h1, h2) {\r\n RY(theta1)[h1]\r\n RY(theta2)[h2] \r\n CNOT[h1, h2]\r\n RY(theta3)[h2]\r\n}\r\n\r\n# Execute VQE\r\nvqe(molecular_hamiltonian, molecular_ansatz, \"COBYLA\")\r\n```\r\n\r\n**Bridge Integration**:\r\n```python\r\nfrom synapse_qubit_bridge import create_hybrid_interpreter\r\n\r\nbridge = create_hybrid_interpreter()\r\nresults = bridge.execute_hybrid(synapse_code, qubit_code)\r\n\r\n# Quantum-enhanced uncertain values\r\nquantum_bond_energy = bridge.quantum_enhance_uncertainty(\"bond_energy\", \"computational\")\r\n```\r\n\r\n## Language Architecture\r\n\r\n### Core Components\r\n\r\n1. **Qubit-Flow Lexer** (`qubit_flow_lexer.py`)\r\n - Quantum-specific tokens (H, X, Y, Z, CNOT, etc.)\r\n - Scientific notation for quantum states (|\u03c8\u27e9, \u27e8\u03c6|)\r\n - Complex number support (1+2i)\r\n\r\n2. **Qubit-Flow AST** (`qubit_flow_ast.py`)\r\n - Quantum circuit nodes\r\n - Gate operation nodes \r\n - Measurement and entanglement nodes\r\n - Quantum algorithm nodes\r\n\r\n3. **Qubit-Flow Parser** (`qubit_flow_parser.py`)\r\n - Circuit definition parsing\r\n - Quantum gate sequence parsing\r\n - Algorithm parameter parsing\r\n\r\n4. **Qubit-Flow Interpreter** (`qubit_flow_interpreter.py`)\r\n - Quantum state simulation\r\n - Gate operation execution\r\n - Measurement simulation\r\n - Algorithm implementations\r\n\r\n5. **Synapse-Qubit Bridge** (`synapse_qubit_bridge.py`)\r\n - Variable sharing between languages\r\n - Quantum-enhanced uncertain values\r\n - Parallel quantum reasoning\r\n - Measurement feedback loops\r\n\r\n## Quantum Operations Reference\r\n\r\n### Single-Qubit Gates\r\n```qubit-flow\r\nH[q0] # Hadamard gate\r\nX[q0] # Pauli-X (NOT gate)\r\nY[q0] # Pauli-Y gate \r\nZ[q0] # Pauli-Z gate\r\nRX(\u03c0/4)[q0] # X-rotation gate\r\nRY(\u03c0/2)[q0] # Y-rotation gate\r\nRZ(\u03c0/3)[q0] # Z-rotation gate\r\nPHASE(\u03c0/6)[q0] # Phase gate\r\n```\r\n\r\n### Multi-Qubit Gates\r\n```qubit-flow\r\nCNOT[control, target] # Controlled-NOT\r\nCZ[control, target] # Controlled-Z\r\nTOFFOLI[control1, control2, target] # Toffoli gate\r\n```\r\n\r\n### Measurements\r\n```qubit-flow\r\nmeasure q0 -> classical_bit # Single measurement\r\nmeasure q0, q1 -> c0, c1 # Multiple measurements \r\n```\r\n\r\n### Quantum Algorithms\r\n```qubit-flow\r\n# Grover's Algorithm\r\ngrovers(search_space_size, oracle_function, iterations)\r\n\r\n# Shor's Algorithm \r\nshors(number_to_factor)\r\n\r\n# Variational Quantum Eigensolver\r\nvqe(hamiltonian, ansatz_circuit, optimizer)\r\n\r\n# Quantum Approximate Optimization Algorithm\r\nqaoa(cost_hamiltonian, mixer_hamiltonian, layers)\r\n\r\n# Quantum Fourier Transform\r\nqft(qubit_list) \r\nqft(qubit_list) inverse # Inverse QFT\r\n```\r\n\r\n## Integration Patterns\r\n\r\n### Pattern 1: Quantum-Enhanced Hypothesis Testing\r\n```python\r\n# Use Synapse for hypothesis formation, Qubit-Flow for quantum verification\r\nbridge = create_hybrid_interpreter()\r\n\r\nsynapse_hypothesis = \"\"\"\r\nhypothesis quantum_advantage {\r\n assume: superposition_available\r\n predict: exponential_speedup \r\n validate: quantum_measurement\r\n}\r\n\"\"\"\r\n\r\nqubit_verification = \"\"\"\r\n# Implement quantum algorithm to test hypothesis\r\ngrovers(1024, search_oracle, optimal_iterations)\r\n\"\"\"\r\n\r\nresults = bridge.execute_hybrid(synapse_hypothesis, qubit_verification)\r\n```\r\n\r\n### Pattern 2: Uncertainty-Quantum State Mapping\r\n```python\r\n# Map classical uncertainty to quantum superposition\r\nbridge.quantum_enhance_uncertainty(\"measurement\", \"hadamard\")\r\n\r\n# Perform quantum operations and feed back to uncertainty\r\nmeasurement = bridge.quantum_measurement_feedback(\"q0\", \"Z\")\r\n```\r\n\r\n### Pattern 3: Parallel Quantum Reasoning\r\n```python\r\n# Run multiple quantum-enhanced reasoning branches\r\nreasoning_branches = [\r\n (\"path1\", synapse_code1, qubit_code1),\r\n (\"path2\", synapse_code2, qubit_code2), \r\n (\"path3\", synapse_code3, qubit_code3)\r\n]\r\n\r\nconsensus = bridge.parallel_quantum_reasoning(reasoning_branches)\r\n```\r\n\r\n## Testing and Examples\r\n\r\nRun the comprehensive test suite:\r\n```bash\r\npython test_qubit_flow.py\r\n```\r\n\r\n### Example Test Output\r\n```\r\n============================================================\r\nTEST: Basic Qubit Operations\r\n============================================================\r\n Created qubits: 3 operations\r\n qubit q0 = QuantumState(1 qubits): [1.+0.j 0.+0.j]\r\n qubit q1 = QuantumState(1 qubits): [0.+0.j 1.+0.j] \r\n qubit q2 = QuantumState(1 qubits): [0.70710678+0.j 0.70710678+0.j]\r\n \u2713 All qubits created successfully\r\n\r\n [PASSED] test_basic_qubit_operations\r\n```\r\n\r\n## Comparison: Synapse-Lang vs Qubit-Flow\r\n\r\n| Feature | Synapse-Lang | Qubit-Flow |\r\n|---------|--------------|------------|\r\n| **Primary Focus** | Scientific reasoning | Quantum computation |\r\n| **Uncertainty** | Built-in uncertainty propagation | Quantum superposition states |\r\n| **Parallelism** | Thought streams & hypothesis testing | Quantum circuit parallelism |\r\n| **Algorithms** | Scientific method, reasoning chains | Quantum algorithms (Shor's, Grover's) |\r\n| **Hardware** | Classical computation | Quantum hardware abstraction |\r\n| **Integration** | \u2705 Seamless bridge layer | \u2705 Seamless bridge layer |\r\n\r\n## Future Extensions\r\n\r\n- **Quantum Error Correction**: Built-in error mitigation strategies\r\n- **Hardware Backends**: IBM Quantum, Google Quantum AI, IonQ integration\r\n- **Advanced Algorithms**: QAOA, quantum machine learning, quantum chemistry\r\n- **Optimization**: Circuit compilation and optimization\r\n- **Visualization**: Quantum circuit diagrams and state visualization\r\n\r\n## Contributing\r\n\r\nQubit-Flow is designed as a complementary language to enhance Synapse-Lang's scientific reasoning with quantum computational power. The bridge architecture allows both languages to leverage their respective strengths while maintaining clean separation of concerns.\r\n\r\n---\r\n\r\n*Quantum computing meets scientific reasoning - where uncertainty principles become computational advantages.*\r\n",
"bugtrack_url": null,
"license": "Proprietary",
"summary": "Quantum circuit design and algorithm execution language - part of the Quantum Trinity",
"version": "1.0.0",
"project_urls": {
"Bug Tracker": "https://github.com/MichaelCrowe11/synapse-lang/issues",
"Documentation": "https://github.com/MichaelCrowe11/synapse-lang/blob/master/QUBIT_FLOW_README.md",
"Homepage": "https://synapse-lang.com",
"Repository": "https://github.com/MichaelCrowe11/synapse-lang"
},
"split_keywords": [
"quantum-computing",
" quantum-circuits",
" quantum-algorithms",
" programming-language",
" interpreter",
" qiskit",
" pennylane",
" cirq",
" quantum-gates",
" qubit-operations"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "76798091d05e3fd96eacbf6e50e91ea55c50637dc7213b57616e222564576cfa",
"md5": "b7d4063a44a224f4845df8add3616d06",
"sha256": "5abf6fbe45fda021a82e99f09ef930462a354b960730e8ee9a15e875f48a5e57"
},
"downloads": -1,
"filename": "synapse_qubit_flow-1.0.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "b7d4063a44a224f4845df8add3616d06",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.8",
"size": 17896,
"upload_time": "2025-09-09T03:17:02",
"upload_time_iso_8601": "2025-09-09T03:17:02.007247Z",
"url": "https://files.pythonhosted.org/packages/76/79/8091d05e3fd96eacbf6e50e91ea55c50637dc7213b57616e222564576cfa/synapse_qubit_flow-1.0.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "49d1793599e39ea81b74b4eff354c4e62c8c9645e584a121377a3d7a72bcd3ae",
"md5": "905d03f285cdc6aa537bce9e860d624c",
"sha256": "701193dc4427ec5e3b9951840c8a34e32f4c8411e6536d1cd57d9d0c20f60d9e"
},
"downloads": -1,
"filename": "synapse_qubit_flow-1.0.0.tar.gz",
"has_sig": false,
"md5_digest": "905d03f285cdc6aa537bce9e860d624c",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.8",
"size": 21241,
"upload_time": "2025-09-09T03:17:03",
"upload_time_iso_8601": "2025-09-09T03:17:03.633465Z",
"url": "https://files.pythonhosted.org/packages/49/d1/793599e39ea81b74b4eff354c4e62c8c9645e584a121377a3d7a72bcd3ae/synapse_qubit_flow-1.0.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-09-09 03:17:03",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "MichaelCrowe11",
"github_project": "synapse-lang",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"requirements": [
{
"name": "numpy",
"specs": [
[
">=",
"1.20.0"
]
]
},
{
"name": "scipy",
"specs": [
[
">=",
"1.7.0"
]
]
},
{
"name": "sympy",
"specs": [
[
">=",
"1.9"
]
]
},
{
"name": "matplotlib",
"specs": [
[
">=",
"3.4.0"
]
]
},
{
"name": "cryptography",
"specs": [
[
">=",
"3.4.8"
]
]
},
{
"name": "requests",
"specs": [
[
">=",
"2.26.0"
]
]
},
{
"name": "qiskit",
"specs": [
[
">=",
"0.34.0"
]
]
},
{
"name": "pennylane",
"specs": [
[
">=",
"0.20.0"
]
]
},
{
"name": "cirq",
"specs": [
[
">=",
"0.13.0"
]
]
},
{
"name": "networkx",
"specs": [
[
">=",
"2.6"
]
]
},
{
"name": "pandas",
"specs": [
[
">=",
"1.3.0"
]
]
},
{
"name": "pytest",
"specs": [
[
">=",
"6.2.0"
]
]
},
{
"name": "black",
"specs": [
[
">=",
"21.6b0"
]
]
},
{
"name": "mypy",
"specs": [
[
">=",
"0.910"
]
]
},
{
"name": "flake8",
"specs": [
[
">=",
"3.9.0"
]
]
},
{
"name": "numba",
"specs": [
[
">=",
"0.56.0"
]
]
},
{
"name": "colorama",
"specs": [
[
">=",
"0.4.4"
]
]
}
],
"lcname": "synapse-qubit-flow"
}
JSON
