quanta-lang 0.1.0__tar.gz

quanta_lang-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Quanta Language Contributors
+
+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.

quanta_lang-0.1.0/PKG-INFO

@@ -0,0 +1,195 @@
+Metadata-Version: 2.4
+Name: quanta-lang
+Version: 0.1.0
+Summary: Quanta: A high-level language that compiles to OpenQASM 3
+Author-email: Quanta Language Contributors <quanta@example.com>
+License: MIT License
+        
+        Copyright (c) 2024 Quanta Language Contributors
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/quanta-lang/quanta
+Project-URL: Documentation, https://github.com/quanta-lang/quanta/docs
+Project-URL: Repository, https://github.com/quanta-lang/quanta
+Project-URL: Issues, https://github.com/quanta-lang/quanta/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Compilers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: qiskit>=1.0
+Requires-Dist: qiskit-qasm3-import>=0.6.0
+Requires-Dist: lark>=1.1.9
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Dynamic: license-file
+
+# Quanta Language
+
+**Quanta** is a high-level, Python-like language that compiles to OpenQASM 3. It provides a clean, readable syntax for quantum circuit development while maintaining full compatibility with OpenQASM 3 and Qiskit.
+
+## Features
+
+- 🐍 **Python-like syntax** - Familiar and readable
+- ⚛️ **Function-style gates** - Gates as function calls: `H(q[0])`, `CNot(q[0], q[1])`
+- 🔒 **Static analysis** - Compile-time safety checks
+- 🎯 **OpenQASM 3 output** - Direct compilation to standard QASM
+- 🚀 **Qiskit integration** - Seamless execution with Qiskit backends
+
+## Installation
+
+```bash
+pip install quanta-lang
+```
+
+## Quick Start
+
+### As a Library
+
+```python
+from quanta import compile, run
+
+# Compile Quanta source to OpenQASM 3
+source = """
+qubit[2] q
+bit[2] c
+
+gate Bell(a, b) {
+    H(a)
+    CNot(a, b)
+}
+
+Bell(q[0], q[1])
+measure_all(q, c)
+"""
+
+qasm = compile(source)
+print(qasm)
+
+# Run and get results
+result = run(source, shots=1024)
+print(result)
+```
+
+### CLI Usage
+
+```bash
+# Compile to QASM
+quanta compile example.qta -o output.qasm
+
+# Run circuit
+quanta run example.qta --shots 1024
+
+# Check syntax
+quanta check example.qta
+```
+
+## Example
+
+### Quanta Source (`bell.qta`)
+
+```quanta
+// Bell state example
+qubit[2] q
+bit[2] c
+
+gate Bell(a, b) {
+    H(a)
+    CNot(a, b)
+}
+
+Bell(q[0], q[1])
+
+measure_all(q, c)
+print(c)
+```
+
+### Generated OpenQASM 3
+
+```qasm
+OPENQASM 3;
+include "stdgates.inc";
+
+qubit[2] q;
+bit[2] c;
+
+h q[0];
+cx q[0], q[1];
+
+measure q[0] -> c[0];
+measure q[1] -> c[1];
+```
+
+## Language Features
+
+- **Types**: `int`, `float`, `bool`, `str`, `list`, `dict`, `qubit`, `bit`
+- **Gate Macros**: `gate` keyword for compile-time circuit composition
+- **Modifiers**: `ctrl` and `inv` (dagger) modifiers for gates
+- **Functions**: Compile-time inlined for quantum operations
+- **Control Flow**: `for` loops (unrolled), `if/else` (classical only)
+- **Gate Set**: `H`, `X`, `CNot`, `CZ`, `Swap`, `RZ`, `Measure`, and more
+- **Standard Library**: `print()`, `len()`, `measure_all()`, `reset()`, `assert()`, `range()`
+
+## Language Features
+
+- **Types**: `int`, `float`, `bool`, `str`, `list`, `dict`, `qubit`, `bit`
+- **Functions**: Compile-time inlined for quantum operations
+- **Control Flow**: `for` loops (unrolled), `if/else` (classical only)
+- **Gate Set**: `H`, `X`, `CNot`, `CZ`, `Swap`, `RZ`, `Measure`, and more
+- **Standard Library**: `print()`, `len()`, `measure_all()`, `reset()`, `assert()`
+
+## Documentation
+
+- [Language Specification](docs/language.md)
+- [Compiler Pipeline](docs/compiler.md)
+- [Roadmap](docs/roadmap.md)
+
+## Development
+
+```bash
+# Install in development mode
+pip install -e .[dev]
+
+# Run tests
+pytest
+
+# Format code
+black src tests
+ruff check src tests
+```
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request.

quanta_lang-0.1.0/README.md

@@ -0,0 +1,141 @@
+# Quanta Language
+
+**Quanta** is a high-level, Python-like language that compiles to OpenQASM 3. It provides a clean, readable syntax for quantum circuit development while maintaining full compatibility with OpenQASM 3 and Qiskit.
+
+## Features
+
+- 🐍 **Python-like syntax** - Familiar and readable
+- ⚛️ **Function-style gates** - Gates as function calls: `H(q[0])`, `CNot(q[0], q[1])`
+- 🔒 **Static analysis** - Compile-time safety checks
+- 🎯 **OpenQASM 3 output** - Direct compilation to standard QASM
+- 🚀 **Qiskit integration** - Seamless execution with Qiskit backends
+
+## Installation
+
+```bash
+pip install quanta-lang
+```
+
+## Quick Start
+
+### As a Library
+
+```python
+from quanta import compile, run
+
+# Compile Quanta source to OpenQASM 3
+source = """
+qubit[2] q
+bit[2] c
+
+gate Bell(a, b) {
+    H(a)
+    CNot(a, b)
+}
+
+Bell(q[0], q[1])
+measure_all(q, c)
+"""
+
+qasm = compile(source)
+print(qasm)
+
+# Run and get results
+result = run(source, shots=1024)
+print(result)
+```
+
+### CLI Usage
+
+```bash
+# Compile to QASM
+quanta compile example.qta -o output.qasm
+
+# Run circuit
+quanta run example.qta --shots 1024
+
+# Check syntax
+quanta check example.qta
+```
+
+## Example
+
+### Quanta Source (`bell.qta`)
+
+```quanta
+// Bell state example
+qubit[2] q
+bit[2] c
+
+gate Bell(a, b) {
+    H(a)
+    CNot(a, b)
+}
+
+Bell(q[0], q[1])
+
+measure_all(q, c)
+print(c)
+```
+
+### Generated OpenQASM 3
+
+```qasm
+OPENQASM 3;
+include "stdgates.inc";
+
+qubit[2] q;
+bit[2] c;
+
+h q[0];
+cx q[0], q[1];
+
+measure q[0] -> c[0];
+measure q[1] -> c[1];
+```
+
+## Language Features
+
+- **Types**: `int`, `float`, `bool`, `str`, `list`, `dict`, `qubit`, `bit`
+- **Gate Macros**: `gate` keyword for compile-time circuit composition
+- **Modifiers**: `ctrl` and `inv` (dagger) modifiers for gates
+- **Functions**: Compile-time inlined for quantum operations
+- **Control Flow**: `for` loops (unrolled), `if/else` (classical only)
+- **Gate Set**: `H`, `X`, `CNot`, `CZ`, `Swap`, `RZ`, `Measure`, and more
+- **Standard Library**: `print()`, `len()`, `measure_all()`, `reset()`, `assert()`, `range()`
+
+## Language Features
+
+- **Types**: `int`, `float`, `bool`, `str`, `list`, `dict`, `qubit`, `bit`
+- **Functions**: Compile-time inlined for quantum operations
+- **Control Flow**: `for` loops (unrolled), `if/else` (classical only)
+- **Gate Set**: `H`, `X`, `CNot`, `CZ`, `Swap`, `RZ`, `Measure`, and more
+- **Standard Library**: `print()`, `len()`, `measure_all()`, `reset()`, `assert()`
+
+## Documentation
+
+- [Language Specification](docs/language.md)
+- [Compiler Pipeline](docs/compiler.md)
+- [Roadmap](docs/roadmap.md)
+
+## Development
+
+```bash
+# Install in development mode
+pip install -e .[dev]
+
+# Run tests
+pytest
+
+# Format code
+black src tests
+ruff check src tests
+```
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request.

quanta_lang-0.1.0/pyproject.toml

@@ -0,0 +1,60 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "quanta-lang"
+version = "0.1.0"
+description = "Quanta: A high-level language that compiles to OpenQASM 3"
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [
+  { name = "Quanta Language Contributors", email = "quanta@example.com" }
+]
+requires-python = ">=3.10"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Software Development :: Compilers",
+]
+
+dependencies = [
+  "qiskit>=1.0",
+  "qiskit-qasm3-import>=0.6.0",
+  "lark>=1.1.9",
+]
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=7.0",
+  "pytest-cov>=4.0",
+  "black>=23.0",
+  "ruff>=0.1.0",
+]
+
+[project.scripts]
+quanta = "quanta.cli.main:main"
+
+[project.urls]
+Homepage = "https://github.com/quanta-lang/quanta"
+Documentation = "https://github.com/quanta-lang/quanta/docs"
+Repository = "https://github.com/quanta-lang/quanta"
+Issues = "https://github.com/quanta-lang/quanta/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.black]
+line-length = 100
+target-version = ['py310']
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"

quanta_lang-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

quanta_lang-0.1.0/src/quanta/__init__.py

@@ -0,0 +1,8 @@
+"""
+Quanta Language - A high-level language that compiles to OpenQASM 3
+"""
+
+from .api import compile, run
+
+__version__ = "0.1.0"
+__all__ = ["compile", "run"]

quanta_lang-0.1.0/src/quanta/__main__.py

@@ -0,0 +1,8 @@
+"""
+Entry point for python -m quanta
+"""
+
+from .cli.main import main
+
+if __name__ == "__main__":
+    main()

quanta_lang-0.1.0/src/quanta/api.py

@@ -0,0 +1,40 @@
+"""
+Public API for Quanta compiler
+"""
+
+from typing import Dict, Any, Optional
+from .compiler import Compiler
+from .runtime.qiskit import run_circuit
+
+
+def compile(source: str) -> str:
+    """
+    Compile Quanta source code to OpenQASM 3.
+    
+    Args:
+        source: Quanta source code as a string
+        
+    Returns:
+        OpenQASM 3 code as a string
+        
+    Raises:
+        QuantaError: If compilation fails
+    """
+    compiler = Compiler()
+    return compiler.compile(source)
+
+
+def run(source: str, shots: int = 1024, backend: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Compile and run Quanta source code.
+    
+    Args:
+        source: Quanta source code as a string
+        shots: Number of measurement shots
+        backend: Qiskit backend name (default: 'qasm_simulator')
+        
+    Returns:
+        Dictionary with measurement results
+    """
+    qasm = compile(source)
+    return run_circuit(qasm, shots=shots, backend=backend)

quanta_lang-0.1.0/src/quanta/ast/__init__.py

@@ -0,0 +1,29 @@
+"""AST (Abstract Syntax Tree) module"""
+
+from .nodes import *
+
+__all__ = [
+    "Program",
+    "Stmt",
+    "Expr",
+    "VarDecl",
+    "ConstDecl",
+    "LetDecl",
+    "QuantumDecl",
+    "FuncDecl",
+    "GateDecl",
+    "ClassDecl",
+    "ForStmt",
+    "IfStmt",
+    "ReturnStmt",
+    "ExprStmt",
+    "CallExpr",
+    "IndexExpr",
+    "BinaryExpr",
+    "UnaryExpr",
+    "VarExpr",
+    "LiteralExpr",
+    "ListExpr",
+    "GroupExpr",
+    "AssignExpr",
+]

quanta_lang-0.1.0/src/quanta/ast/nodes.py

@@ -0,0 +1,192 @@
+"""
+AST node definitions for Quanta language
+"""
+
+from abc import ABC, abstractmethod
+from typing import List, Optional, Any
+
+
+class Node(ABC):
+    """Base class for all AST nodes"""
+    pass
+
+
+class Stmt(Node):
+    """Base class for statements"""
+    pass
+
+
+class Expr(Node):
+    """Base class for expressions"""
+    pass
+
+
+class Program(Node):
+    """Root node representing a complete program"""
+    
+    def __init__(self, statements: List[Stmt]):
+        self.statements = statements
+
+
+class VarDecl(Stmt):
+    """Variable declaration"""
+    
+    def __init__(self, name: str, type_hint: Optional[str], value: Optional[Expr]):
+        self.name = name
+        self.type_hint = type_hint
+        self.value = value
+
+
+class ConstDecl(Stmt):
+    """Constant declaration (compile-time literal)"""
+    
+    def __init__(self, name: str, value: Expr):
+        self.name = name
+        self.value = value
+
+
+class LetDecl(Stmt):
+    """Let declaration (immutable value)"""
+    
+    def __init__(self, name: str, value: Expr):
+        self.name = name
+        self.value = value
+
+
+class QuantumDecl(Stmt):
+    """Quantum register declaration (qubit/bit)"""
+    
+    def __init__(self, kind: str, size: Optional[int], name: str):
+        self.kind = kind  # "qubit" or "bit"
+        self.size = size
+        self.name = name
+
+
+class FuncDecl(Stmt):
+    """Function declaration"""
+    
+    def __init__(self, name: str, params: List[str], return_type: Optional[str], body: List[Stmt]):
+        self.name = name
+        self.params = params
+        self.return_type = return_type
+        self.body = body
+
+
+class GateDecl(Stmt):
+    """Gate macro declaration (compile-time circuit composition)"""
+    
+    def __init__(self, name: str, params: List[str], body: List[Stmt]):
+        self.name = name
+        self.params = params
+        self.body = body
+
+
+class ClassDecl(Stmt):
+    """Class declaration"""
+    
+    def __init__(self, name: str, members: List[Stmt]):
+        self.name = name
+        self.members = members
+
+
+class ForStmt(Stmt):
+    """For loop statement"""
+    
+    def __init__(self, iterator: str, iterable: Expr, body: List[Stmt]):
+        self.iterator = iterator
+        self.iterable = iterable
+        self.body = body
+
+
+class IfStmt(Stmt):
+    """If statement"""
+    
+    def __init__(self, condition: Expr, then_body: List[Stmt], else_body: List[Stmt]):
+        self.condition = condition
+        self.then_body = then_body
+        self.else_body = else_body
+
+
+class ReturnStmt(Stmt):
+    """Return statement"""
+    
+    def __init__(self, value: Optional[Expr]):
+        self.value = value
+
+
+class ExprStmt(Stmt):
+    """Expression statement"""
+    
+    def __init__(self, expr: Expr):
+        self.expr = expr
+
+
+class CallExpr(Expr):
+    """Function/gate call expression"""
+    
+    def __init__(self, callee: Expr, args: List[Expr], modifiers: Optional[List[str]] = None, ctrl_count: Optional[int] = None):
+        self.callee = callee
+        self.args = args
+        self.modifiers = modifiers or []  # List of "ctrl" and/or "inv"
+        self.ctrl_count = ctrl_count  # Number of control qubits for ctrl[n]
+
+
+class IndexExpr(Expr):
+    """Index expression (array/register access)"""
+    
+    def __init__(self, base: Expr, index: Expr):
+        self.base = base
+        self.index = index
+
+
+class BinaryExpr(Expr):
+    """Binary expression"""
+    
+    def __init__(self, left: Expr, op: str, right: Expr):
+        self.left = left
+        self.op = op
+        self.right = right
+
+
+class UnaryExpr(Expr):
+    """Unary expression"""
+    
+    def __init__(self, op: str, right: Expr):
+        self.op = op
+        self.right = right
+
+
+class VarExpr(Expr):
+    """Variable reference"""
+    
+    def __init__(self, name: str):
+        self.name = name
+
+
+class LiteralExpr(Expr):
+    """Literal expression (number, string, boolean)"""
+    
+    def __init__(self, value: Any):
+        self.value = value
+
+
+class ListExpr(Expr):
+    """List literal expression"""
+    
+    def __init__(self, elements: List[Expr]):
+        self.elements = elements
+
+
+class GroupExpr(Expr):
+    """Grouped expression (parentheses)"""
+    
+    def __init__(self, expr: Expr):
+        self.expr = expr
+
+
+class AssignExpr(Expr):
+    """Assignment expression"""
+    
+    def __init__(self, name: str, value: Expr):
+        self.name = name
+        self.value = value