This document provides comprehensive documentation for all available nodes in Qiskit Studio. Each node represents a specialized quantum computing component that can be connected to create complex quantum workflows.
Purpose: Provides access to pre-built quantum circuit templates from Qiskit's circuit library.
- Circuit Types: Ansatz, PauliTwoDesign, TwoLocal, NLocal
- Configurable Parameters: Qubit count, repetitions, and rotation gates
- Automatic Code Generation: Generates Python/Qiskit code for selected circuits
- Parameterized Circuits: Supports variational quantum algorithms
- Select circuit type from dropdown
- Configure parameters (qubits, repetitions)
- The node automatically generates the corresponding Qiskit code
- Connect to execution or transpiler nodes
from qiskit.circuit.library import TwoLocal
# Create a TwoLocal circuit
circuit = TwoLocal(
num_qubits=4,
rotation_blocks=['ry', 'rz'],
entanglement_blocks='cz',
entanglement='linear',
reps=2
)- Input: Configuration parameters
- Output: Configured quantum circuit object
Purpose: Basic quantum circuit creation and configuration with streamlined interface.
- Circuit Types: Ansatz, PauliTwoDesign, TwoLocal, NLocal
- Compact Design: Blue-themed UI for easy identification
- Quick Setup: Minimal configuration for rapid prototyping
- Standard Integration: Compatible with all other nodes
Similar to Circuit Library Node but with simplified interface focusing on core functionality.
- Input: Circuit type and basic parameters
- Output: Quantum circuit object
Purpose: Represents individual quantum gates in circuit construction.
- Gate Types: H, X, Y, Z, CX, CCX, and more
- Color Coding:
- H (Hadamard): Blue
- X (Pauli-X): Red
- Y (Pauli-Y): Yellow
- Z (Pauli-Z): Purple
- CX (CNOT): Green
- CCX (Toffoli): Orange
- Visual Identification: Compact design for easy recognition
- Parameterized Gates: Support for rotation gates with parameters
- Drag gate nodes into the workspace
- Connect to circuit or other gate nodes
- Configure gate parameters if applicable
- Gates are automatically added to the circuit in order
- Input: Gate parameters (angles for rotation gates)
- Output: Gate operation to be added to circuit
Purpose: Allows insertion of custom Python code in quantum workflows.
- Code Editor: Large, resizable textarea with syntax highlighting
- AI Integration: AI-powered code generation and improvement
- Flexible Execution: Supports any Python code, not just quantum
- Context Awareness: Can access variables from connected nodes
- Error Handling: Displays execution errors and debugging information
- Write or paste Python code in the editor
- Use AI assistance for code generation and improvement
- Access variables from connected nodes
- Execute code and view results
- Code Generation: Generate quantum algorithms from descriptions
- Code Improvement: Optimize and enhance existing code
- Error Correction: Identify and fix common programming errors
- Documentation: Generate comments and documentation
- Input: Python code and variables from connected nodes
- Output: Execution results and modified variables
Purpose: Executes quantum circuits on quantum hardware or simulators.
- Simple Interface: Minimal configuration for quick execution
- Backend Agnostic: Works with any Qiskit-compatible backend
- Result Handling: Manages job submission and result retrieval
- Error Management: Handles execution errors gracefully
- Connect circuit nodes to the input
- Configure execution parameters if needed
- Execute the circuit
- View results or connect to visualization nodes
- Input: Quantum circuit to execute
- Output: Execution results or job reference
Purpose: Configures IBM Quantum Runtime execution with advanced error mitigation.
- Resilience Levels: Slider from 0-2 for error mitigation strength
- Error Mitigation Options:
- TREX (Twirled Readout Error eXtinction)
- ZNE (Zero Noise Extrapolation)
- PEC (Probabilistic Error Cancellation)
- PEA (Pauli Error Amplification)
- Gate Twirling
- Measurement Twirling
- Primitive Support: Both Estimator and Sampler primitives
- Advanced Configuration: Fine-tuned resilience settings
- Select resilience level using slider
- Configure specific error mitigation techniques
- Choose primitive type (Estimator/Sampler)
- Connect to circuit and execution nodes
- Mitigates readout errors through randomized measurements
- Effective for reducing measurement noise
- Extrapolates to zero noise limit
- Particularly useful for NISQ devices
- Cancels errors through probabilistic methods
- High accuracy but increased circuit overhead
- Input: Runtime configuration and resilience settings
- Output: Configured runtime options for quantum execution
Purpose: Configures quantum circuit transpilation for hardware optimization.
- Optimization Levels: Slider from 0-3
- Level 0: No optimization
- Level 1: Basic optimization
- Level 2: Medium optimization
- Level 3: Heavy optimization
- Layout Methods:
- Trivial, Dense, NoiseAdaptive, SabreLayout
- Routing Methods:
- Basic, LookaheadSwap, StochasticSwap, SabreSwap
- Translation Methods:
- Translator, BasisTranslator, UnitarySynthesis
- Scheduling Options: ASAP, ALAP scheduling
- Seed Control: Reproducible transpilation results
- Set optimization level with slider
- Configure layout, routing, and translation methods
- Set scheduling options if needed
- Connect to circuit nodes for transpilation
- No circuit optimization
- Only basic mapping to hardware
- Fastest compilation
- Basic gate cancellation
- Simple circuit optimizations
- Good balance of speed and optimization
- More aggressive optimization
- Commutative cancellation
- Better depth reduction
- Maximum optimization
- Extensive circuit analysis
- Best performance but slower compilation
- Input: Transpilation configuration parameters
- Output: Optimized quantum circuit for specific hardware
Purpose: Simplified transpiler configuration with AI-optimized passes.
- AI Optimization: Machine learning-enhanced transpilation
- Simplified Interface: Focus on essential options
- Intelligent Defaults: AI-selected optimal settings
- Performance Focused: Optimized for best results with minimal configuration
- Enable AI-optimized transpilation
- Let AI select optimal passes
- Review and adjust if needed
- Connect to circuit for transpilation
- Input: Basic transpiler parameters
- Output: AI-optimized transpiler configuration
Purpose: Provides access to individual transpiler optimization passes.
- Extensive Library: 33+ individual transpiler passes
- Categorized Passes:
- Optimization: CircuitOptimization, Optimize1qGates, CXCancellation
- Layout: DenseLayout, NoiseAdaptiveLayout, SabreLayout
- Routing: BasicSwap, LookaheadSwap, SabreSwap
- Analysis: ResourceEstimation, DepthAnalysis, WidthAnalysis
- Detailed Descriptions: Each pass includes explanation of functionality
- Custom Workflows: Build custom transpilation pipelines
- Optimize1qGates: Optimizes single-qubit gates
- CXCancellation: Cancels consecutive CX gates
- CommutationAnalysis: Analyzes gate commutation relationships
- ConsolidateBlocks: Combines blocks of gates
- TrivialLayout: Simple qubit mapping
- DenseLayout: Dense connectivity mapping
- NoiseAdaptiveLayout: Noise-aware qubit placement
- SabreLayout: SABRE algorithm for layout
- BasicSwap: Basic SWAP insertion
- LookaheadSwap: Lookahead SWAP routing
- StochasticSwap: Stochastic SWAP placement
- SabreSwap: SABRE routing algorithm
- Select specific transpiler pass from library
- Configure pass parameters
- Chain multiple passes for custom pipelines
- Connect to circuit for transpilation
- Input: Transpiler pass selection and parameters
- Output: Specific optimization pass configuration
Purpose: Handles quantum information objects and operators.
- Object Types:
- Hamiltonian: Quantum system energy operators
- Pauli: Pauli operator representations
- SparsePauliOp: Sparse Pauli operator format
- Operator: General quantum operators
- Automatic Generation: Creates quantum information objects from specifications
- Integration: Works with Qiskit's quantum_info module
- Format Support: Multiple quantum information formats
- Select quantum information type
- Specify operator parameters
- Generate quantum information object
- Connect to algorithms or analysis nodes
- Represents system energy
- Used in VQE and quantum simulation
- Supports molecular and spin Hamiltonians
- Fundamental quantum operators
- Basis for many quantum algorithms
- Efficient representation for quantum systems
- Memory-efficient Pauli operator storage
- Optimized for large quantum systems
- Compatible with Qiskit algorithms
- Input: Quantum information type and parameters
- Output: Quantum information objects (operators, states, etc.)
Purpose: Renders quantum computation results in various visual formats.
- Visualization Types:
- Histogram: Measurement result distributions
- Bloch Sphere: Qubit state visualization
- Circuit Diagram: Circuit structure display
- Raw Output: Unprocessed result data
- Dynamic Display: Updates based on connected results
- Interactive Elements: Zoom, pan, and explore visualizations
- Export Options: Save visualizations as images
- Shows measurement outcome probabilities
- Useful for analyzing quantum algorithm results
- Supports both classical and quantum register results
- 3D visualization of single-qubit states
- Shows quantum state evolution
- Interactive rotation and exploration
- Visual representation of quantum circuits
- Shows gate sequence and qubit connectivity
- Useful for circuit analysis and debugging
- Unprocessed quantum computation results
- Detailed job information and metadata
- Useful for debugging and analysis
- Select visualization type
- Connect to result-producing nodes
- Configure display options
- View and interact with visualizations
- Input: Quantum computation results
- Output: Visual representations of quantum data
Purpose: Maps molecular structures to quantum Hamiltonians for quantum chemistry applications.
- Molecular Input: PySCF-compatible molecular specifications
- Basis Set Support: Various quantum chemistry basis sets
- Hamiltonian Generation: Automatic quantum Hamiltonian creation
- AI Integration: AI-powered molecular structure optimization
- Template Systems: Common molecular examples (N₂, H₂O, etc.)
- Input molecular structure using PySCF syntax
- Specify basis set (6-31g, cc-pVDZ, etc.)
- Configure symmetry and other parameters
- Generate quantum Hamiltonian
- Connect to VQE or other quantum chemistry algorithms
# Example N₂ molecule
N 0.0 0.0 0.0
N 0.0 0.0 1.1- Atoms: All periodic table elements
- Basis Sets: Standard quantum chemistry basis sets
- Symmetry: Point group symmetry handling
- Optimization: Geometry optimization capabilities
- Input: Molecular structure and parameters
- Output: Quantum Hamiltonian for molecular system
- Data Flow: Nodes should be connected in logical data flow order
- Type Compatibility: Ensure output types match input requirements
- Error Handling: Improper connections will show error messages
- Performance: Minimize unnecessary connections for better performance
Circuit Library → Transpiler → Execution → Visualization
Chemistry Mapping → Python (VQE) → Runtime → Visualization
Circuit → Transpiler Pass → Transpiler → Execution
Python (AI) → Circuit Library → Transpiler AI → Runtime
- Start Simple: Begin with basic connections, add complexity gradually
- Test Incrementally: Test each connection as you build
- Use Visualization: Always connect visualization nodes to see results
- Document Workflows: Use Python nodes to add documentation
- Error Checking: Include error handling in custom Python code
- Problem: Nodes won't connect
- Solution: Check input/output type compatibility
- Problem: Code doesn't execute
- Solution: Check for syntax errors and missing imports
- Problem: Slow execution
- Solution: Optimize transpiler settings and reduce circuit complexity
- Problem: AI features not working
- Solution: Check API configuration and network connectivity
- Use Print Statements: Add debugging prints in Python nodes
- Check Console: Browser console shows detailed error messages
- Incremental Testing: Test individual nodes before complex workflows
- Review Generated Code: Examine auto-generated Python code for issues
While not directly supported, you can extend functionality through:
- Python Nodes: Implement custom logic
- API Integration: Connect to external services
- Data Processing: Custom data transformation pipelines
- Qiskit Optimization: Use with quantum optimization algorithms
- Qiskit Machine Learning: Integrate ML algorithms
- Third-party Libraries: Import additional Python libraries
- Circuit Depth: Minimize circuit depth for NISQ devices
- Gate Count: Reduce total gate count through optimization
- Parallelization: Use multiple execution nodes for parallel processing
- Caching: Cache expensive computations in Python nodes
For more advanced usage patterns and examples, see the usage guide.