Explain model applications and add concrete examples; apply requested names

README.md

@@ -9,11 +9,34 @@ tags:
 - lora
 - synthetic-data
 ---
+
 # QuantumCoder-9B
 
-A rank 16 Qwen3.5-9B adapter for translating fully specified synthetic quantum circuits into Qiskit, PennyLane or Cirq Python. The independently executed follow-up passes 288/288 held-out circuit/framework cases and 282/288 larger stress cases. The saved-weight helper reproduces all eight fixed validation generations exactly.
+Translate an explicit quantum-circuit specification into Python for Qiskit, Cirq or PennyLane. Give this Qwen3.5-9B adapter the framework, qubit count and ordered gate list; it returns source code that can be inspected and checked in the supplied isolated evaluator.
+
+The practical use is a quantum-programming teaching notebook or a framework-translation benchmark: the same circuit can be expressed in three APIs and compared against a reference statevector. The published adapter passes 288/288 held-out framework cases and 282/288 stress cases in its restricted executor. A deterministic renderer already solves the fully specified task; these results do not establish algorithm discovery or repair of arbitrary quantum programs.
+
+## Application example
+
+**Show one circuit in three frameworks.** Represent a circuit as `framework`, `qubits` and `operations`, request one framework at a time, and compare how its gates and wire ordering are expressed. For example, H on qubit 0 followed by CX(0,1) prepares a Bell state from the all-zero input. The longer example below uses the measured operation schema. Inspect generated text before passing it to the isolated evaluator; the inference helper itself executes no code.
+
+## Inference
+
+Download this repository and install `requirements-inference.txt` in a CUDA environment with enough memory for 9B weights (the checked configuration used an A100). From the downloaded repository:
 
-**A deterministic renderer already solves this structured task perfectly.** This is learned circuit-to-program translation, including framework APIs and little-endian state conventions. It is not quantum algorithm discovery, general quantum programming, full unitary verification or a result on real quantum hardware.
+```python
+from quantum import QuantumCoder
+coder = QuantumCoder()
+result = coder.generate([{
+    "framework": "cirq", "qubits": 2,
+    "operations": [["h", [0], 0.0], ["ry", [1], 0.31],
+                   ["rz", [0], 0.67], ["cx", [0, 1], 0.0],
+                   ["h", [1], 0.0], ["z", [0], 0.0]]
+}])[0]
+print(result["program"])
+```
+
+The helper returns fallible source text and never executes it. `operations` follows [gate,qubit_indices,angle_in_radians]; non-rotation angles are 0. The measured limits are 2–6 qubits and at most 24 gates. Prompts beyond 2,048 tokens are rejected rather than truncated. Generation matches the frozen greedy 768-token protocol in batches of eight.
 
 ## Results
 
@@ -37,24 +60,6 @@ Training uses 2–4 qubits, adjacent CNOTs and 6–13 gates. Stress uses 5–6 q
 
 Base [Qwen3.5-9B](https://huggingface.co/Qwen/Qwen3.5-9B), revision `c202236235762e1c871ad0ccb60c8ee5ba337b9a`. One fixed epoch from the base, 648 examples, rank 16/alpha 32 on q_proj/v_proj/in_proj_qkv, AdamW learning rate 2e−5, gradient accumulation 8, seed 20261101, max training sequence 2,048. No test checkpoint selection. Training code, original programs, model outputs and audits remain in this repository.
 
-## Inference
-
-Download this repository and install `requirements-inference.txt` in a CUDA environment with enough memory for 9B weights (the checked configuration used an A100). From the downloaded repository:
-
-```python
-from quantum import QuantumCoder
-coder = QuantumCoder()
-result = coder.generate([{
-    "framework": "cirq", "qubits": 2,
-    "operations": [["h", [0], 0.0], ["ry", [1], 0.31],
-                   ["rz", [0], 0.67], ["cx", [0, 1], 0.0],
-                   ["h", [1], 0.0], ["z", [0], 0.0]]
-}])[0]
-print(result["program"])
-```
-
-The helper returns fallible source text and never executes it. `operations` follows [gate,qubit_indices,angle_in_radians]; non-rotation angles are 0. The measured limits are 2–6 qubits and at most 24 gates. Prompts beyond 2,048 tokens are rejected rather than truncated. Generation matches the frozen greedy 768-token protocol in batches of eight.
-
 ## Reproduce execution
 
 Use an isolated Linux environment with Python 3.11, `libseccomp2` and `requirements-evaluation.txt`. The parent must run as root so workers can drop to UID/GID 65534. From a full repository snapshot, run `python reproduce_execution.py`. It first verifies the frozen sandbox/data hashes, isolation and every selected reference, then re-scores all 1,440 base/adapted programs and checks the published counts. This public reproducer was run successfully before release. Do not substitute direct host execution for the provided runner.