Table of Contents

1. Introduction
2. Importance of Licensing in Quantum Software
3. Common Open-Source Licenses in Quantum Projects
4. MIT License: Simplicity and Freedom
5. Apache 2.0: Modern, Enterprise-Friendly Licensing
6. BSD 3-Clause and 2-Clause Licenses
7. GNU GPL and LGPL: Copyleft Implications
8. Creative Commons and Documentation Licensing
9. Dual Licensing Models in Quantum Ecosystems
10. Commercial vs Academic Use Cases
11. License Compatibility in Hybrid Quantum Projects
12. Implications for Cloud Quantum SDKs
13. Attribution and Citation Requirements
14. Contribution Agreements and CLA Use
15. License Best Practices for Quantum Startups
16. Licensing Pitfalls to Avoid
17. Selecting a License for Your Quantum Project
18. Adding a LICENSE File and Notice
19. Handling Third-Party Dependencies
20. Conclusion

1. Introduction

Licensing is a critical but often overlooked part of building, distributing, and collaborating on quantum software. It governs how code can be used, modified, and shared.

2. Importance of Licensing in Quantum Software

• Protects intellectual property (IP)
• Clarifies reuse and redistribution terms
• Encourages trust and community engagement

3. Common Open-Source Licenses in Quantum Projects

• Qiskit: Apache 2.0
• PennyLane: Apache 2.0
• Cirq: Apache 2.0
• QuTiP: BSD
• Strawberry Fields: Apache 2.0

4. MIT License: Simplicity and Freedom

• Very permissive
• Minimal conditions
• Ideal for small tools and demos

5. Apache 2.0: Modern, Enterprise-Friendly Licensing

• Explicit patent rights
• Strong legal protection
• Used by most major quantum SDKs

6. BSD 3-Clause and 2-Clause Licenses

• Academic origin
• More permissive than GPL
• Minimal legal overhead

7. GNU GPL and LGPL: Copyleft Implications

• Requires derived works to use same license
• Less common in quantum, but used in scientific toolkits

8. Creative Commons and Documentation Licensing

• CC-BY or CC-BY-SA for docs, books, tutorials
• Not suited for software code

9. Dual Licensing Models in Quantum Ecosystems

• Open-source + commercial license
• Example: use open-source for research, paid for enterprise support

10. Commercial vs Academic Use Cases

• Many licenses allow academic use freely
• Commercial integrations may need license review

11. License Compatibility in Hybrid Quantum Projects

• Ensure code combining Qiskit + Cirq + PennyLane doesn’t conflict
• Prefer permissive licenses to maximize compatibility

12. Implications for Cloud Quantum SDKs

• SDKs are open-source, but cloud APIs may have usage restrictions
• Always separate API tokens and follow provider ToS

13. Attribution and Citation Requirements

• Apache 2.0 and BSD recommend including license and attribution
• Scientific papers may also request citation of software

14. Contribution Agreements and CLA Use

• Contributor License Agreement (CLA): defines IP rights
• Used by larger projects like Qiskit to protect codebase integrity

15. License Best Practices for Quantum Startups

• Start with permissive license (MIT or Apache)
• Add clear NOTICE and LICENSE files
• Plan for dual license if offering SaaS or enterprise tiers

16. Licensing Pitfalls to Avoid

• Mixing incompatible licenses (e.g., GPL with proprietary code)
• Forgetting to include license headers
• Using code snippets without attribution

17. Selecting a License for Your Quantum Project

• Use tools like https://choosealicense.com
• Consider use cases: research, teaching, commercial

18. Adding a LICENSE File and Notice

• Use GitHub templates
• Include license header in each file if required

19. Handling Third-Party Dependencies

• Audit dependencies with pip-licenses or license-checker
• Document licenses in README or setup scripts

20. Conclusion

Licensing is foundational to collaboration and sustainability in quantum software. By choosing the right license, honoring compatibility, and maintaining clarity, quantum developers and organizations can foster trust and accelerate global innovation.

Table of Contents

1. Introduction
2. Why Documentation Matters in Quantum Software
3. Types of Documentation in Quantum Projects
4. Getting Started Guides and Quickstarts
5. API Documentation and Autogenerated References
6. Tutorials and Example Notebooks
7. Inline Comments and Developer Notes
8. User-Centric vs Research-Centric Docs
9. Tools for Writing and Hosting Documentation
10. Writing Style for Quantum Docs
11. Markdown, reStructuredText, and Jupyter Docs
12. Keeping Docs Up to Date
13. Establishing Contribution Guidelines
14. Community Code of Conduct
15. Issue and PR Templates
16. Supporting New Contributors
17. Building Inclusive Communities
18. Moderation and Review Etiquette
19. Encouraging Feedback and External Resources
20. Conclusion

1. Introduction

Good documentation and clear community guidelines are foundational to maintaining a sustainable, inclusive, and collaborative open-source quantum software ecosystem.

2. Why Documentation Matters in Quantum Software

• Lowers the barrier to entry for new contributors
• Helps non-physicists participate in quantum computing
• Increases adoption and retention of users and collaborators

3. Types of Documentation in Quantum Projects

• End-user documentation
• Contributor/developer documentation
• API references
• Scientific rationale and design docs

4. Getting Started Guides and Quickstarts

Provide clear, minimal reproducible paths to:

• Install dependencies
• Run a sample quantum circuit
• Understand project structure

5. API Documentation and Autogenerated References

Use tools like:

• Sphinx (with autodoc)
• MkDocs
• Docstrings in PEP257 or Google format

6. Tutorials and Example Notebooks

• Real-world examples (VQE, QAOA, teleportation)
• Notebooks that explain code and theory
• Output cells pre-run to aid discovery

7. Inline Comments and Developer Notes

• Explain intent, not just implementation
• Use docstrings to describe qubit layout, params
• Mark TODOs and FIXMEs with clear rationale

8. User-Centric vs Research-Centric Docs

Balance:

• Practical instructions for developers
• Mathematical background for researchers

9. Tools for Writing and Hosting Documentation

• Read the Docs
• GitHub Pages
• JupyterBook for interactive docs

10. Writing Style for Quantum Docs

• Keep tone concise and accessible
• Use consistent quantum terminology
• Avoid over-assuming physics background

11. Markdown, reStructuredText, and Jupyter Docs

• Markdown: general documentation
• rST: Sphinx projects
• Jupyter: tutorials and dynamic walkthroughs

12. Keeping Docs Up to Date

• Use CI to check doc builds
• Link docs to code versions via tags/branches
• Encourage doc PRs with feature PRs

13. Establishing Contribution Guidelines

Include:

• Forking and branching policy
• Code style guides
• How to write and run tests

14. Community Code of Conduct

• Set expectations for respectful interactions
• Define unacceptable behaviors and enforcement process
• Use Contributor Covenant template or adapt

15. Issue and PR Templates

• Help guide contributor submissions
• Ask for reproducibility steps
• Encourage minimal working examples (MWEs)

16. Supporting New Contributors

• Tag beginner issues
• Provide mentorship paths
• Recognize first-time PRs

17. Building Inclusive Communities

• Welcome diverse backgrounds (physics, CS, math)
• Provide translations or multilingual tutorials
• Use gender-neutral language in code and docs

18. Moderation and Review Etiquette

• Respond constructively
• Encourage consensus
• Rotate maintainers to avoid burnout

19. Encouraging Feedback and External Resources

• Link textbooks, lecture notes, YouTube tutorials
• Invite community suggestions
• Offer channels (Slack, Discord, Discourse)

20. Conclusion

Well-crafted documentation and clear community guidelines are essential pillars of successful quantum software projects. They enable collaboration, reduce onboarding friction, and foster a welcoming and diverse contributor base that can advance quantum computing together.

Table of Contents

1. Introduction
2. Why Code Reviews Are Crucial in Quantum Computing
3. Unique Aspects of Reviewing Quantum Code
4. Setting Up a Review Process for Quantum Teams
5. Reviewer Responsibilities and Mindset
6. Common Pitfalls in Quantum Codebases
7. Reviewing Quantum Circuits and Algorithms
8. Code Readability and Abstraction in Quantum Projects
9. Circuit Reuse and Modularity
10. Gate Count, Depth, and Efficiency Evaluation
11. Test Coverage and Simulator Validation
12. Reviewing Measurement Logic and Classical Control
13. Parameter Binding and Ansatz Structure Review
14. Comments, Documentation, and QASM Export
15. Style Guides for Qiskit, Cirq, and PennyLane
16. Reviewing Hybrid Classical-Quantum Interfaces
17. Identifying Hardware-Specific Assumptions
18. Security and Resource Usage Considerations
19. Constructive Feedback and Knowledge Sharing
20. Conclusion

1. Introduction

Quantum code reviews help developers maintain code quality, correctness, and performance in a domain where both classical and quantum logic coexist and errors are often non-obvious.

2. Why Code Reviews Are Crucial in Quantum Computing

• Catch subtle circuit errors early
• Ensure portability across backends
• Foster a learning culture and team collaboration
• Reduce technical debt in experimental code

3. Unique Aspects of Reviewing Quantum Code

• Involves linear algebra, quantum theory, and hardware constraints
• Probabilistic outputs may mask bugs
• State preparation and measurement logic often intertwined

4. Setting Up a Review Process for Quantum Teams

• Require at least 1-2 reviewers per pull request
• Use labels for circuit changes vs SDK tooling
• Maintain checklists tailored for quantum artifacts

5. Reviewer Responsibilities and Mindset

• Understand the quantum algorithm or model
• Check assumptions on qubit layout and noise
• Verify modularity and testability

6. Common Pitfalls in Quantum Codebases

• Unused parameters or qubits
• Redundant measurements
• Incorrect basis rotation before measurement

7. Reviewing Quantum Circuits and Algorithms

• Inspect parameter usage
• Check initial state preparation
• Validate gate sequence logic
• Ensure circuit returns expected entangled/mixed state

8. Code Readability and Abstraction in Quantum Projects

• Avoid hard-coded qubit indices
• Use factory functions for circuits
• Favor descriptive variable names over cryptic ones

9. Circuit Reuse and Modularity

• Encourage QuantumCircuit factories or builders
• Modularize ansatz, encoder, and measurement layers

10. Gate Count, Depth, and Efficiency Evaluation

• Ask: can depth be reduced?
• Compare to hardware coherence time
• Use transpiler tools to benchmark

11. Test Coverage and Simulator Validation

• Verify unit tests for deterministic outputs
• Use simulators to reproduce bug reports
• Prefer snapshot/statevector over sampling when possible

12. Reviewing Measurement Logic and Classical Control

• Check register mapping
• Validate mid-circuit measurement if used
• Ensure classical feedback follows SDK syntax

13. Parameter Binding and Ansatz Structure Review

• Ensure clean separation of trainable parameters
• Use symbolic names for clarity
• Validate against optimizer interface

14. Comments, Documentation, and QASM Export

• Inline comments for circuit purpose
• Include QASM export if reproducibility is key
• Auto-generate diagrams for large circuits

15. Style Guides for Qiskit, Cirq, and PennyLane

• PEP8 for Python
• Qiskit: camelCase for methods, snake_case for variables
• Cirq: ASCII circuit preview + docstrings
• PennyLane: qml.template() and decorator conventions

16. Reviewing Hybrid Classical-Quantum Interfaces

• Validate optimizer integration
• Ensure proper batching for parameter sweeps
• Use shared data flow across classical and quantum modules

17. Identifying Hardware-Specific Assumptions

• Flag hardcoded qubit layouts
• Warn against non-portable gate sets
• Encourage backend-agnostic transpilation

18. Security and Resource Usage Considerations

• Avoid infinite loops in optimizer callbacks
• Limit number of shots and job retries
• Do not expose API tokens in test scripts

19. Constructive Feedback and Knowledge Sharing

• Provide quantum learning links for reviewers
• Encourage PRs to include rationale
• Use review comments as mentorship opportunities

20. Conclusion

Quantum code reviews are essential for building trustworthy quantum software. By blending quantum knowledge with standard review practices, teams can ensure correctness, efficiency, and collaboration in an increasingly complex field.

Table of Contents

1. Introduction
2. What Is Qiskit Runtime?
3. Benefits of Qiskit Runtime for Real-Time Experiments
4. Architectural Overview
5. Supported Quantum Algorithms and Use Cases
6. Runtime Programs: Prebuilt and Custom
7. Setting Up Access to Qiskit Runtime
8. Qiskit Runtime Primitives: Estimator and Sampler
9. Creating a Real-Time Quantum Experiment Workflow
10. Example: Variational Circuit Using Estimator
11. Running Experiments on Dedicated IBM QPUs
12. Managing Sessions and Runtime Jobs
13. Monitoring Job Progress and Logs
14. Result Retrieval and Error Handling
15. Integrating Classical Feedback in Runtime
16. Runtime Performance and Cost Considerations
17. Writing Custom Qiskit Runtime Programs
18. Debugging and Testing Runtime Programs
19. Reproducibility and Metadata Logging
20. Conclusion

1. Introduction

Qiskit Runtime enables real-time quantum-classical hybrid experiments by reducing latency between quantum executions and classical computations. It empowers researchers to run more efficient and scalable algorithms on IBM quantum devices.

2. What Is Qiskit Runtime?

A container-based execution environment hosted on IBM Cloud that accelerates quantum workloads by running them close to the QPU and within a single session.

3. Benefits of Qiskit Runtime for Real-Time Experiments

• Up to 100x speedup vs traditional workflows
• Lower roundtrip latency
• State persistence across iterations
• Cost-efficient execution for large-scale variational algorithms

4. Architectural Overview

• Client: Python script using qiskit-ibm-runtime
• Runtime container: runs prebuilt or custom programs
• Backend: IBM QPU or simulator

5. Supported Quantum Algorithms and Use Cases

• VQE, QAOA, QNNs
• Ground state estimation
• Kernel estimation
• Variational optimization

6. Runtime Programs: Prebuilt and Custom

• Prebuilt: sampler, estimator, vqe, qaoa
• Custom: define your own loop logic and operations

7. Setting Up Access to Qiskit Runtime

from qiskit_ibm_runtime import QiskitRuntimeService
service = QiskitRuntimeService(channel="ibm_quantum", token="YOUR_TOKEN")

8. Qiskit Runtime Primitives: Estimator and Sampler

from qiskit_ibm_runtime import Estimator, Session
with Session(service=service, backend="ibmq_qasm2") as session:
    estimator = Estimator(session=session)
    job = estimator.run(circuit, observables)

9. Creating a Real-Time Quantum Experiment Workflow

• Define circuit and observable
• Set runtime options (shots, optimization level)
• Loop within session for parameter updates

10. Example: Variational Circuit Using Estimator

from qiskit.circuit import Parameter
theta = Parameter("θ")
circuit = QuantumCircuit(1)
circuit.rx(theta, 0)

11. Running Experiments on Dedicated IBM QPUs

Use Premium Plan for lower queue times and reserved access.

12. Managing Sessions and Runtime Jobs

• Sessions can contain multiple job executions
• Monitor with session.jobs and job.status()

13. Monitoring Job Progress and Logs

job = estimator.run(...)
job.result()
job.status()
job.logs()

14. Result Retrieval and Error Handling

• Retry failed jobs
• Handle network exceptions
• Use callback functions for streaming output

15. Integrating Classical Feedback in Runtime

Within a session, use:

• Intermediate classical calculations
• Optimizer feedback for parameter tuning

16. Runtime Performance and Cost Considerations

• Runtime execution incurs per-second billing
• Sessions reduce roundtrip API calls

17. Writing Custom Qiskit Runtime Programs

• Create main() entry with ProgramContext
• Package and deploy via IBM Quantum Dashboard

18. Debugging and Testing Runtime Programs

• Use local simulator for testing
• Log intermediate data
• Validate output consistency

19. Reproducibility and Metadata Logging

• Record session ID, backend, transpiled circuit hash
• Log optimizer state and iteration data

20. Conclusion

Qiskit Runtime revolutionizes real-time quantum experimentation by offering faster, more integrated, and scalable workflows. Whether you’re running variational algorithms or real-time kernel estimation, this environment makes quantum computing more practical and powerful.