iQuHACK · nicolajack · Jan 31, 2026 · Jan 31, 2026 · Jan 31, 2026 · Jan 31, 2026
diff --git a/.gitignore b/.gitignore
@@ -0,0 +1,4 @@
+__pycache__
+venv
+challenge.pdf
+writeup/.texpadtmp
diff --git a/README.md b/README.md
@@ -0,0 +1,141 @@
+# iQuHack 2026: Superquantum Challenge
+
+**Team Name:** 67 Qubits
+**Team Members:** Adam Godel, Yebin Song, Nico Jackson, Travis Meyer, Timothy Wright  
+**Affiliation:** Boston University, Boston, MA
+
+---
+
+## Project Write-up & Presentation Slides
+
+Our complete technical writeup is available in the `writeup/` directory:
+
+- **PDF**: [`writeup/main.pdf`](writeup/main.pdf) - **Start here!** This is the compiled document with all our implementations, optimizations, and experimental results.
+
+- **Slides**: Access our slides [here!](https://docs.google.com/presentation/d/1q9z32plF9qOmsmKggezTibO6qC0Dm3mvM3ZvNwCfbd8/edit?usp=sharing)
+
+## Project Overview
+
+This repository contains our implementations of **12 unitary operators** using the **Clifford + T gate set**, where the T gate is the most computationally expensive gate to execute. Our goal was to optimize quantum circuits by:
+
+1. **Minimizing T-gate count** - Reducing the "quantumness" and computational cost
+2. **Minimizing approximation error** - Achieving high fidelity to target unitaries
+3. **Exploring the tradeoff** - Balancing these competing objectives
+
+---
+
+## Repository Structure
+
+### `unitary/` - Circuit Implementations
+
+Contains Python implementations for all 12 unitaries:
+
+- **`unitary1.py` through `unitary12.py`**: Individual implementations for each target unitary
+- **`optim.py`**: Main optimization framework for building and synthesizing circuits
+- **`utils.py`**: Utility functions for rotation gates (Rz, Ry, Rx)
+- **`test.py`**: Testing framework with expected unitary matrices and distance calculations
+- **`plot.py`**: Plotting utilities for T-count vs. distance analysis
+- **`plot7_mp.py`**: Plotting utilities for T-count vs. Fidelity in Unitary 7
+- **`plot10.py`**: Plotting utilities for T-count vs. distance analysis in Unitary 10
+- **`parser.py`**: Parsing utility for converting qasm to quantum gates
+
+### `qasm/` - QASM Circuit Files
+
+Contains OpenQASM 3.0 representations of all optimized circuits:
+
+```
+qasm/unitary1.qasm
+qasm/unitary2.qasm
+...
+qasm/unitary12.qasm
+```
+
+These files can be loaded into Qiskit or other quantum computing frameworks.
+
+### `plots/` - Visualization Results
+
+Contains generated plots showing the T-count vs. distance tradeoffs:
+
+- `unitary_2_distance_vs_tcount.png`
+- `unitary_3_distance_vs_tcount.png`
+- `unitary_4_distance_vs_tcount.png`
+- `unitary_6_distance_vs_tcount.png`
+- `unitary7_plot.png` (fidelity-based)
+- `unitary10_distance_vs_tcount.png`
+
+### `writeup/` - Technical Documentation
+
+The complete LaTeX writeup.
+
+---
+
+## How to Use
+
+### Prerequisites
+
+```bash
+pip install qiskit
+pip install gridsynth
+pip install rmsynth
+pip install numpy matplotlib scipy
+```
+
+### Running Individual Unitaries
+
+Each unitary can be executed independently:
+
+```bash
+cd unitary
+python3 unitary2.py   # Controlled-Ry(π/7) gate
+python3 unitary7.py   # State preparation
+python3 unitary11.py  # Four-qubit diagonal unitary
+```
+
+### Running Optimizations
+
+To optimize a specific unitary with custom parameters:
+
+```bash
+cd unitary
+python3 optim.py
+```
+
+Edit the file to select which unitary to optimize and adjust epsilon values.
+
+### Generating Plots
+
+To generate T-count vs. distance plots:
+
+```bash
+cd unitary
+python3 plot.py
+```
+
+Modify the `constructions_to_analyze` list in the `if __name__ == "__main__"` block to select which unitaries to plot.
+
+### Testing Implementations
+
+To verify circuit correctness:
+
+```bash
+cd unitary
+python3 test.py
+```
+
+This will load QASM files, compute circuit unitaries, and compare them against expected results.
+
+---
+
+## References
+
+- **Gridsynth**: Ross, N. J., & Selinger, P. (2014). Optimal ancilla-free Clifford+T approximation of z-rotations.
+- **Rmsynth**: Superquantum rmsynth package for phase polynomial optimization
+- **Qiskit**: IBM's open-source quantum computing framework
+
+## License
+
+This project was created for the iQuHack 2026 hackathon. See individual package licenses for gridsynth, rmsynth, and Qiskit.
+
+---
+
+**For questions or issues, please open an issue on GitHub or contact the team.**
diff --git a/challenge.pdf b/challenge.pdf
diff --git a/plots/unitary10_distance_vs_tcount.png b/plots/unitary10_distance_vs_tcount.png
diff --git a/plots/unitary7_plot.png b/plots/unitary7_plot.png
diff --git a/plots/unitary_11_distance_vs_tcount.png b/plots/unitary_11_distance_vs_tcount.png
diff --git a/plots/unitary_2_distance_vs_tcount.png b/plots/unitary_2_distance_vs_tcount.png
diff --git a/plots/unitary_3_distance_vs_tcount.png b/plots/unitary_3_distance_vs_tcount.png
diff --git a/plots/unitary_4_distance_vs_tcount.png b/plots/unitary_4_distance_vs_tcount.png
diff --git a/plots/unitary_5_distance_vs_tcount.png b/plots/unitary_5_distance_vs_tcount.png
diff --git a/plots/unitary_6_distance_vs_tcount.png b/plots/unitary_6_distance_vs_tcount.png
diff --git a/plots/unitary_8_distance_vs_tcount.png b/plots/unitary_8_distance_vs_tcount.png
diff --git a/plots/unitary_9_distance_vs_tcount.png b/plots/unitary_9_distance_vs_tcount.png
diff --git a/qasm/parser.py b/qasm/parser.py
@@ -0,0 +1,76 @@
+import re
+from pathlib import Path
+
+GATE = re.compile(r'gate\s+(\w+)\s+([A-Za-z_]\w*(?:\s*,\s*[A-Za-z_]\w*)*)\s*\{(.*?)\}', re.S)
+CALL = re.compile(r'^\s*(\w+)\s+([^;]+);\s*$')
+QDECL = re.compile(r'^\s*qubit\[(\d+)\]\s+q\s*;\s*$', re.M)
+
+def parse_ops(block):
+    return [ln.strip() for ln in block.splitlines() if ln.strip() and ln.strip().endswith(";")]
+
+def expand_line(line, env, gates, out):
+    m = CALL.match(line)
+    if not m: return
+    name, args = m.group(1), [a.strip() for a in m.group(2).split(",")]
+
+    # map args through env (so gate-local names become q[i], etc.)
+    args = [env.get(a, a) for a in args]
+
+    # builtin op -> emit
+    if name not in gates:
+        out.append(f"{name} {', '.join(args)};")
+        return
+
+    # custom gate -> inline with new env
+    formal_args, body_ops = gates[name]
+    new_env = dict(env)
+    for fa, aa in zip(formal_args, args):
+        new_env[fa] = aa
+    for op in body_ops:
+        expand_line(op, new_env, gates, out)
+
+def reformat(in_file):
+    p = Path(in_file)
+    s = p.read_text(encoding="utf-8")
+
+    # collect includes (keep them)
+    includes = "\n".join(re.findall(r'^\s*include\s+"[^"]+"\s*;\s*$', s, re.M))
+    if not includes:
+        includes = 'include "stdgates.inc";'
+
+    # parse gates
+    gates = {}
+    for name, argstr, body in GATE.findall(s):
+        gates[name] = ([a.strip() for a in argstr.split(",")], parse_ops(body))
+
+    # find main program start: after qubit[...] q;
+    qm = QDECL.search(s)
+    if not qm:
+        raise SystemExit("No 'qubit[n] q;' found.")
+    n = int(qm.group(1))
+    main = s[qm.end():]
+    main_ops = parse_ops(main)
+
+    # expand main ops
+    out_ops = []
+    for op in main_ops:
+        expand_line(op, {}, gates, out_ops)
+
+    # output name unitaryX.qasm next to input
+    m = re.search(r'unitary(\d+)\.qasm$', p.name)
+    X = m.group(1) if m else "0"
+    out_path = p.with_name(f"unitary{X}.qasm")
+
+    out_path.write_text(
+        "OPENQASM 3.0;\n"
+        f"{includes}\n"
+        f"qubit[{n}] q;\n"
+        + "\n".join(out_ops)
+        + "\n",
+        encoding="utf-8",
+    )
+    print(out_path)
+
+if __name__ == "__main__":
+    import sys
+    reformat(sys.argv[1])
diff --git a/qasm/unitary1.qasm b/qasm/unitary1.qasm
@@ -0,0 +1,6 @@
+OPENQASM 3.0;
+include "stdgates.inc";
+qubit[2] q;
+sdg q[0];
+cx q[1], q[0];
+s q[0];