<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: EigenOrbit</title>
    <description>The latest articles on DEV Community by EigenOrbit (@eigenorbit).</description>
    <link>https://dev.to/eigenorbit</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4235196%2F83c5cb69-d407-4351-8304-3c7b8f21ed3c.png</url>
      <title>DEV Community: EigenOrbit</title>
      <link>https://dev.to/eigenorbit</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/eigenorbit"/>
    <language>en</language>
    <item>
      <title>Fine-tuning a certified network without losing its robustness guarantee</title>
      <dc:creator>EigenOrbit</dc:creator>
      <pubDate>Tue, 17 Nov 2026 14:36:13 +0000</pubDate>
      <link>https://dev.to/eigenorbit/fine-tuning-a-certified-network-without-losing-its-robustness-guarantee-4a3j</link>
      <guid>https://dev.to/eigenorbit/fine-tuning-a-certified-network-without-losing-its-robustness-guarantee-4a3j</guid>
      <description>&lt;p&gt;A certified classifier comes with a proof for each input: inside a radius r around the image, no perturbation can change the predicted class. In medical imaging that radius has to cover what happens in a clinic every day, such as a second photo of the same patch of skin taken at a slightly different angle.&lt;/p&gt;

&lt;p&gt;The proof rests on the Lipschitz constant L of the network. The certificate divides the logit margin by L, so when fine-tuning doubles L, the radius at the same margin halves. Certified networks are trained on ImageNet while a clinic has a few thousand labelled images, so in practice you fine-tune, and in our experiments LoRA raised L by 1.9 to 2.5 times and full fine-tuning by 5 to 8.5 times.&lt;/p&gt;

&lt;h2&gt;
  
  
  A rotation keeps every singular value of the weights
&lt;/h2&gt;

&lt;p&gt;The butterfly adapter multiplies each frozen weight matrix by an orthogonal matrix, W′ = R(θ)·W. For orthogonal R, (RW)ᵀ(RW) = WᵀW, so W′ has the singular values of W and its spectral norm stays where it was, whatever training does to θ.&lt;/p&gt;

&lt;p&gt;R(θ) is a product of Givens rotations laid out as a butterfly: log₂ n levels, each of which pairs up the channels and rotates every pair by its own angle. A Givens rotation is orthogonal for any angle, so Adam trains the angles directly with no projection step or penalty term. Acting on unary states, the same rotation is a reconfigurable beam splitter (RBS) gate, which makes each adapter a quantum circuit of depth log₂ n. We simulate it on a GPU as an ordinary matrix.&lt;/p&gt;

&lt;p&gt;A 2048 wide layer holds about 4.2 million weights, and its butterfly has 11 264 angles.&lt;/p&gt;

&lt;h2&gt;
  
  
  Check the bound in 20 lines
&lt;/h2&gt;

&lt;p&gt;The layer ships in &lt;a href="https://eigenorbit.com/kit/?utm_source=devto&amp;amp;utm_medium=social&amp;amp;utm_campaign=2026-11-medical-paper&amp;amp;utm_content=post" rel="noopener noreferrer"&gt;eigenkit&lt;/a&gt;, our open-source library (&lt;a href="https://dev.to/eigenorbit/eigenkit-write-a-quantum-circuit-once-run-it-on-any-backend-38n4"&gt;intro post&lt;/a&gt;). The script runs on a CPU in a few seconds.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;pip install &lt;span class="nv"&gt;eigenkit&lt;/span&gt;&lt;span class="o"&gt;==&lt;/span&gt;1.2.2 torch
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;torch&lt;/span&gt;
&lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="n"&gt;eigenkit&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;orthogonal&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;torch&lt;/span&gt; &lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="nc"&gt;Orthogonal&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;rotate_weight&lt;/span&gt;

&lt;span class="n"&gt;torch&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;manual_seed&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;n&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;2048&lt;/span&gt;
&lt;span class="no"&gt;W&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;torch&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;randn&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;n&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;n&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="n"&gt;n&lt;/span&gt;&lt;span class="o"&gt;**&lt;/span&gt;&lt;span class="mf"&gt;0.5&lt;/span&gt;            &lt;span class="c1"&gt;# a frozen pretrained weight&lt;/span&gt;
&lt;span class="no"&gt;L0&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;torch&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;linalg&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;matrix_norm&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="no"&gt;W&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nb"&gt;ord&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;   &lt;span class="c1"&gt;# its spectral norm (Lipschitz bound)&lt;/span&gt;

&lt;span class="c1"&gt;# butterfly adapter: R(theta) @ W, R orthogonal for every theta&lt;/span&gt;
&lt;span class="no"&gt;R&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;Orthogonal&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;n&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;                          &lt;span class="c1"&gt;# butterfly layout of RBS / Givens gates&lt;/span&gt;
&lt;span class="k"&gt;with&lt;/span&gt; &lt;span class="n"&gt;torch&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;no_grad&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt; &lt;span class="k"&gt;in&lt;/span&gt; &lt;span class="no"&gt;R&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;parameters&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="n"&gt;p&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;normal_&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mf"&gt;1.0&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;                  &lt;span class="c1"&gt;# any angles at all&lt;/span&gt;
&lt;span class="nc"&gt;W_bfly&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;rotate_weight&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="no"&gt;R&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;matrix&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;W&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="c1"&gt;# LoRA, rank 4: W + B @ A, random factors standing in for trained ones&lt;/span&gt;
&lt;span class="no"&gt;A&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;torch&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;randn&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;4&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;n&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="mf"&gt;0.05&lt;/span&gt;
&lt;span class="no"&gt;B&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;torch&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;randn&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;n&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;4&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="mf"&gt;0.05&lt;/span&gt;
&lt;span class="nc"&gt;W_lora&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;W&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="no"&gt;B&lt;/span&gt; @ &lt;span class="no"&gt;A&lt;/span&gt;

&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"butterfly angles:"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nb"&gt;sum&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;p&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;numel&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt; &lt;span class="k"&gt;in&lt;/span&gt; &lt;span class="no"&gt;R&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;parameters&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"LoRA params:     "&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;numel&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="no"&gt;B&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;numel&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"L/L0 butterfly:  "&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="s2"&gt;"{(torch.linalg.matrix_norm(W_bfly, ord=2) / L0).item():.3f}"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"L/L0 LoRA:       "&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="s2"&gt;"{(torch.linalg.matrix_norm(W_lora, ord=2) / L0).item():.3f}"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;butterfly angles: 11264
LoRA params:      16384
L/L0 butterfly:   1.000
L/L0 LoRA:        2.764
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Any angles you draw give a ratio of 1 up to float32 rounding. The LoRA ratio depends on its factors: the random ones here only show the mechanism, and the trained LoRA adapters in the paper ended at 1.9 to 2.5.&lt;/p&gt;

&lt;h2&gt;
  
  
  Results on trichoscopy images from a clinic
&lt;/h2&gt;

&lt;p&gt;With dermatologists at the University of Trieste we adapted BRONet, a certified ImageNet network, to trichoscopic scalp images for two tasks: diagnosis of hair loss across 5 classes (3 581 images from 143 patients) and activity of alopecia areata (1 196 images from 57 patients). The adapter acts on the 8 dense layers of BRONet's MLP, and every method trains a new classification head.&lt;/p&gt;

&lt;p&gt;Diagnosis task, 717 test images:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;Butterfly&lt;/th&gt;
&lt;th&gt;LoRA&lt;/th&gt;
&lt;th&gt;Full fine-tuning&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Certified accuracy, ε = 36/255&lt;/td&gt;
&lt;td&gt;63.8%&lt;/td&gt;
&lt;td&gt;31.6%&lt;/td&gt;
&lt;td&gt;35.6%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Certified accuracy, ε = 108/255&lt;/td&gt;
&lt;td&gt;20.4%&lt;/td&gt;
&lt;td&gt;0%&lt;/td&gt;
&lt;td&gt;0%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Clean accuracy&lt;/td&gt;
&lt;td&gt;80.4%&lt;/td&gt;
&lt;td&gt;71.5%&lt;/td&gt;
&lt;td&gt;82.5%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;L / L₀ after adaptation&lt;/td&gt;
&lt;td&gt;1.00&lt;/td&gt;
&lt;td&gt;1.9 to 2.5&lt;/td&gt;
&lt;td&gt;5 to 8.5&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Trainable parameters&lt;/td&gt;
&lt;td&gt;about 100 000&lt;/td&gt;
&lt;td&gt;141 000&lt;/td&gt;
&lt;td&gt;33.6 million&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Training only the new head also keeps L unchanged and reached 55.2% certified accuracy, so the butterfly adds 8.6 points by adapting the features as well. On the alopecia areata activity task the butterfly certified 40.6% of images, against 21.3% for LoRA and 17.9% for full fine-tuning.&lt;/p&gt;

&lt;p&gt;We also attacked the adapted models with PGD and APGD-T. No attack found an adversarial example inside a certified radius, and the certified radius tracked the smallest successful attack on each image with a Spearman correlation of 0.97 to 0.99.&lt;/p&gt;

&lt;h2&gt;
  
  
  Paper and code
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Paper: &lt;a href="https://arxiv.org/abs/2611.18775" rel="noopener noreferrer"&gt;Quantum-inspired orthogonal adapters for certifiably robust medical image classification&lt;/a&gt;, arXiv:2611.18775&lt;/li&gt;
&lt;li&gt;Code that reproduces every table: &lt;a href="https://github.com/eigenorbit/quantum-inspired-fine-tuning" rel="noopener noreferrer"&gt;github.com/eigenorbit/quantum-inspired-fine-tuning&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;The orthogonal layers, the certificate and the losses: &lt;a href="https://github.com/eigenorbit/eigenkit" rel="noopener noreferrer"&gt;eigenkit on GitHub&lt;/a&gt;, module &lt;code&gt;eigenkit.orthogonal.torch&lt;/code&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;If you fine-tune a Lipschitz-constrained model on your own data, swapping LoRA for the butterfly takes two calls in the training loop: &lt;code&gt;Orthogonal(n)&lt;/code&gt; for each frozen layer and &lt;code&gt;rotate_weight(R.matrix(), W)&lt;/code&gt; in its forward pass.&lt;/p&gt;

</description>
      <category>python</category>
      <category>machinelearning</category>
      <category>quantum</category>
      <category>ai</category>
    </item>
    <item>
      <title>From a single qubit to a running algorithm: quantum computing in 3–5 minute lectures</title>
      <dc:creator>EigenOrbit</dc:creator>
      <pubDate>Fri, 13 Nov 2026 13:50:28 +0000</pubDate>
      <link>https://dev.to/eigenorbit/from-a-single-qubit-to-a-running-algorithm-quantum-computing-in-3-5-minute-lectures-5efm</link>
      <guid>https://dev.to/eigenorbit/from-a-single-qubit-to-a-running-algorithm-quantum-computing-in-3-5-minute-lectures-5efm</guid>
      <description>&lt;p&gt;Most quantum computing material is written for one of two readers: the physicist who already knows the math, or the newcomer who gets an analogy and never the math behind it. If you are a developer or an ML engineer who wants to work on real projects, neither one gets you there.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://eigenorbit.com/academy/" rel="noopener noreferrer"&gt;EigenOrbit Academy&lt;/a&gt; is a video course on quantum information processing, from a single qubit to your first running algorithm.&lt;/p&gt;

&lt;h2&gt;
  
  
  How a lecture is built
&lt;/h2&gt;

&lt;p&gt;Each lecture is 3 to 5 minutes long. Every concept follows the same order:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;an analogy,&lt;/li&gt;
&lt;li&gt;the math,&lt;/li&gt;
&lt;li&gt;where the analogy breaks down.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The third step is the one most courses skip, and it is where most misconceptions about quantum computing come from. After each lecture there are questions on what was just covered.&lt;/p&gt;

&lt;p&gt;The lectures are written and recorded by our own quantum specialists.&lt;/p&gt;

&lt;h2&gt;
  
  
  What the program covers
&lt;/h2&gt;

&lt;p&gt;The program has 12 modules. The first two:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Module&lt;/th&gt;
&lt;th&gt;Lectures&lt;/th&gt;
&lt;th&gt;Length&lt;/th&gt;
&lt;th&gt;Topics&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;1. Why quantum computing&lt;/td&gt;
&lt;td&gt;3&lt;/td&gt;
&lt;td&gt;~13 min&lt;/td&gt;
&lt;td&gt;Why organizations invest, what current hardware can and cannot do, which problems are worth trying&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2. Quantum computing foundations&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;~31 min&lt;/td&gt;
&lt;td&gt;Qubits, superposition, entanglement, measurement, gates&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The modules that follow cover:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;classical ML foundations, as preparation for the quantum versions;&lt;/li&gt;
&lt;li&gt;the software and hardware stack, including superconducting and trapped-ion qubits;&lt;/li&gt;
&lt;li&gt;core algorithms: Grover, QAOA, VQE, QSVM, HQNN, HHL;&lt;/li&gt;
&lt;li&gt;hybrid quantum-classical computing, with use cases in finance, energy, manufacturing, healthcare and materials science;&lt;/li&gt;
&lt;li&gt;a hands-on module and an end-to-end walkthrough.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The full program is published on the page, so you can see what is in it before you start.&lt;/p&gt;

&lt;h2&gt;
  
  
  Every quantum method next to a classical baseline
&lt;/h2&gt;

&lt;p&gt;Each quantum method in the course is compared against a classical baseline. The course says where quantum ML has been shown to work and where it has not.&lt;/p&gt;

&lt;p&gt;For ML readers, the course connects backpropagation to variational circuits, so QSVM, HQNN, VQE and QAOA build on what you already know.&lt;/p&gt;

&lt;h2&gt;
  
  
  The hands-on module
&lt;/h2&gt;

&lt;p&gt;In the hands-on module you describe your own problem. You get back a hybrid solution, benchmarked against a classical baseline, as code and a report.&lt;/p&gt;

&lt;h2&gt;
  
  
  Quizzes and certificate
&lt;/h2&gt;

&lt;p&gt;Every module ends with a graded quiz. After passing them you get a PDF certificate that records lectures completed, quiz accuracy and study time. It has a unique ID and a QR code for verification, and can be added to LinkedIn.&lt;/p&gt;

&lt;h2&gt;
  
  
  Who it is for
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;New to quantum.&lt;/strong&gt; No physics background needed.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;CS and ML students.&lt;/strong&gt; The algorithms used in quantum ML, with their limits stated.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Self-learners preparing for real projects.&lt;/strong&gt; The same terms and algorithms used in practice, and a final module that goes through the full workflow.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Researchers and instructors.&lt;/strong&gt; Source-checked explanations and reusable teaching material.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Access
&lt;/h2&gt;

&lt;p&gt;€99, one-time payment. This includes all current and future modules, quizzes, certificates and worked examples.&lt;/p&gt;

&lt;h2&gt;
  
  
  Links
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Academy: &lt;a href="https://eigenorbit.com/academy/" rel="noopener noreferrer"&gt;https://eigenorbit.com/academy/&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Start learning: &lt;a href="https://academy.eigenorbit.com" rel="noopener noreferrer"&gt;https://academy.eigenorbit.com&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Course preview: &lt;a href="https://youtu.be/ukX48_RgcS4" rel="noopener noreferrer"&gt;https://youtu.be/ukX48_RgcS4&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;eigenkit, our open-source library: &lt;a href="https://github.com/eigenorbit/eigenkit" rel="noopener noreferrer"&gt;https://github.com/eigenorbit/eigenkit&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Follow EigenOrbit to see new modules as they are added.&lt;/p&gt;

</description>
      <category>quantum</category>
      <category>machinelearning</category>
      <category>explainlikeimfive</category>
      <category>learning</category>
    </item>
    <item>
      <title>Which quantum backend should run your circuit? Speed, feasibility and cost in one table</title>
      <dc:creator>EigenOrbit</dc:creator>
      <pubDate>Fri, 13 Nov 2026 13:46:00 +0000</pubDate>
      <link>https://dev.to/eigenorbit/which-quantum-backend-should-run-your-circuit-speed-feasibility-and-cost-in-one-table-3jle</link>
      <guid>https://dev.to/eigenorbit/which-quantum-backend-should-run-your-circuit-speed-feasibility-and-cost-in-one-table-3jle</guid>
      <description>&lt;p&gt;Before a circuit goes anywhere, three questions come up. How long will it take on each simulator? Will it fit on a given device at all? What will it cost on each QPU?&lt;/p&gt;

&lt;p&gt;The answers sit in different places: simulator docs, device spec sheets, pricing pages that each count in their own units (per shot, per task, per second). Putting them side by side usually means a spreadsheet you rebuild every time a price or a device changes.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://benchmarks.eigenorbit.com" rel="noopener noreferrer"&gt;EigenOrbit Benchmarks&lt;/a&gt; puts them on one page. One workload, measured across eight simulators and priced across fourteen QPUs. Every number carries the source it came from.&lt;/p&gt;

&lt;h2&gt;
  
  
  Speed: measured, on eight simulators
&lt;/h2&gt;

&lt;p&gt;The simulator numbers are runs of the same circuit through &lt;a href="https://github.com/eigenorbit/eigenkit" rel="noopener noreferrer"&gt;eigenkit&lt;/a&gt;, which executes one codebase on every backend. Same circuit, same parameters, so the difference you see is the simulator.&lt;/p&gt;

&lt;p&gt;This matters more than it sounds. In our &lt;a href="https://arxiv.org/abs/2611.02979" rel="noopener noreferrer"&gt;paper comparing 12 backends&lt;/a&gt;, no single simulator was consistently fastest: the ranking changed with circuit size, structure and batching. A table for your own circuit shape is more useful than a general leaderboard.&lt;/p&gt;

&lt;h2&gt;
  
  
  Feasibility: will it run there at all
&lt;/h2&gt;

&lt;p&gt;Before cost, a device has to accept the circuit. The page shows, per QPU, whether the workload fits: qubit count, connectivity and supported gates.&lt;/p&gt;

&lt;p&gt;On hardware, the paper found that the better processor for a given algorithm depends on how closely the circuit's topology matches the device's physical connectivity. A device with more qubits is not automatically the better choice.&lt;/p&gt;

&lt;h2&gt;
  
  
  Cost: priced on fourteen QPUs
&lt;/h2&gt;

&lt;p&gt;Each provider prices differently. The page converts all of them into the price of running this workload, so the fourteen QPUs can be compared directly. Each price links to the provider's own pricing page it was taken from.&lt;/p&gt;

&lt;h2&gt;
  
  
  Every number has a source
&lt;/h2&gt;

&lt;p&gt;Measured runtimes point to the run that produced them. Prices and device specs point to the provider page they were taken from, with the date. If a number looks wrong, you can check it in one click.&lt;/p&gt;

&lt;h2&gt;
  
  
  From the table to a real run
&lt;/h2&gt;

&lt;p&gt;Once you have picked a device, the same circuit runs there through &lt;a href="https://router.eigenorbit.com" rel="noopener noreferrer"&gt;EigenOrbit Router&lt;/a&gt;: one key for all supported vendors, a cost estimate before the job starts, and a prepaid balance so a job you cannot afford does not start. The walkthrough is in the &lt;a href="https://dev.to/eigenorbit/one-python-codebase-every-quantum-computer-running-the-same-circuit-on-ionq-iqm-and-ibm-1775"&gt;previous post&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;If you are still deciding whether quantum fits your problem in the first place, &lt;a href="https://adviser.eigenorbit.com" rel="noopener noreferrer"&gt;Adviser&lt;/a&gt; starts one step earlier.&lt;/p&gt;

&lt;h2&gt;
  
  
  Links
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Benchmarks: &lt;a href="https://benchmarks.eigenorbit.com" rel="noopener noreferrer"&gt;https://benchmarks.eigenorbit.com&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Video: &lt;a href="https://youtu.be/Q4m3YGPK_Wo" rel="noopener noreferrer"&gt;https://youtu.be/Q4m3YGPK_Wo&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;eigenkit on GitHub: &lt;a href="https://github.com/eigenorbit/eigenkit" rel="noopener noreferrer"&gt;https://github.com/eigenorbit/eigenkit&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Paper: &lt;a href="https://arxiv.org/abs/2611.02979" rel="noopener noreferrer"&gt;https://arxiv.org/abs/2611.02979&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Router: &lt;a href="https://router.eigenorbit.com" rel="noopener noreferrer"&gt;https://router.eigenorbit.com&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Follow EigenOrbit to see new devices and workloads as they are added.&lt;/p&gt;

</description>
      <category>performance</category>
      <category>python</category>
      <category>kagglechallenge</category>
      <category>quantum</category>
    </item>
    <item>
      <title>One Python codebase, every quantum computer: running the same circuit on IonQ, IQM and IBM</title>
      <dc:creator>EigenOrbit</dc:creator>
      <pubDate>Mon, 09 Nov 2026 13:58:27 +0000</pubDate>
      <link>https://dev.to/eigenorbit/one-python-codebase-every-quantum-computer-running-the-same-circuit-on-ionq-iqm-and-ibm-1775</link>
      <guid>https://dev.to/eigenorbit/one-python-codebase-every-quantum-computer-running-the-same-circuit-on-ionq-iqm-and-ibm-1775</guid>
      <description>&lt;p&gt;Most quantum code lives on a simulator. Moving it to real hardware is where the work starts: each provider has its own account, keys, billing and SDK objects, and comparing two quantum computers on your own circuit means setting up both. This post walks through a setup where the circuit is written once, the device is a string, and one API key with one prepaid balance works across many quantum providers: today IonQ, IQM, Rigetti, AQT and IBM, plus cloud simulators, with more providers planned.&lt;/p&gt;

&lt;p&gt;It uses two pieces: &lt;a href="https://github.com/eigenorbit/eigenkit" rel="noopener noreferrer"&gt;eigenkit&lt;/a&gt;, a Python library that describes a circuit once and runs it on many backends, and &lt;a href="https://router.eigenorbit.com" rel="noopener noreferrer"&gt;EigenOrbit Router&lt;/a&gt;, a hosted service that sends eigenkit jobs to the quantum providers for you. Both are ours, so read the rest with that in mind.&lt;/p&gt;

&lt;h2&gt;
  
  
  What usually stands between a circuit and a QPU
&lt;/h2&gt;

&lt;p&gt;To run one circuit on quantum computers from two or three providers with your own credentials, you usually need:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;an account with each cloud or hardware provider, often with its own contract;&lt;/li&gt;
&lt;li&gt;cloud permissions, storage for results, the right region for each device and spending limits;&lt;/li&gt;
&lt;li&gt;a separate API key and SDK setup per provider;&lt;/li&gt;
&lt;li&gt;a way to know what a run costs before it lands on the bill.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;For a team with existing cloud contracts this is a one-time cost. For a student, a researcher trying a second device or a small team comparing providers, it is often where the experiment stops.&lt;/p&gt;

&lt;h2&gt;
  
  
  The circuit, written once
&lt;/h2&gt;

&lt;p&gt;eigenkit describes a circuit as data, separate from any SDK. Here is a small variational circuit with two qubits:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;numpy&lt;/span&gt; &lt;span class="k"&gt;as&lt;/span&gt; &lt;span class="n"&gt;np&lt;/span&gt;
&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;eigenkit&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;Circuit&lt;/span&gt;
&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;eigenkit.core.blocks&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;AngleEncoding&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;BasicVariational&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;assemble&lt;/span&gt;
&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;eigenkit.core.observables&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;all_z&lt;/span&gt;

&lt;span class="n"&gt;spec&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;assemble&lt;/span&gt;&lt;span class="p"&gt;([&lt;/span&gt;
    &lt;span class="nc"&gt;AngleEncoding&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;in_features&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;
    &lt;span class="nc"&gt;BasicVariational&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;depth&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;
&lt;span class="p"&gt;])&lt;/span&gt;
&lt;span class="n"&gt;weights&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;np&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;linspace&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="mf"&gt;0.9&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mf"&gt;1.1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;spec&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;n_weights&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;inputs&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;np&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;array&lt;/span&gt;&lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="mf"&gt;0.2&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mf"&gt;0.6&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;On a local simulator you pass a provider name:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;Circuit&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;spec&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nf"&gt;all_z&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="n"&gt;provider&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;numpy&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)(&lt;/span&gt;&lt;span class="n"&gt;weights&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;inputs&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  The device as a string
&lt;/h2&gt;

&lt;p&gt;With the &lt;code&gt;router&lt;/code&gt; extra, the same circuit runs on cloud simulators and QPUs through one key:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;pip &lt;span class="nb"&gt;install&lt;/span&gt; &lt;span class="s2"&gt;"eigenkit[router]"&lt;/span&gt;
&lt;span class="nb"&gt;export &lt;/span&gt;&lt;span class="nv"&gt;EIGENORBIT_ROUTER_API_KEY&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;eo_live_...
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;eigenorbit_router_client&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;RouterConfig&lt;/span&gt;

&lt;span class="c1"&gt;# Every device ID is listed in the public catalog
&lt;/span&gt;&lt;span class="n"&gt;devices&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;SV1 simulator&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;RouterConfig&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;device&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;braket/sv1&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;shots&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;1000&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;
    &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;IQM Garnet&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;    &lt;span class="nc"&gt;RouterConfig&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;device&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;braket/iqm_garnet&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;shots&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;100&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;
    &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;IBM Fez&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;       &lt;span class="nc"&gt;RouterConfig&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;device&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;ibm/ibm_fez&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;shots&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;4000&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;name&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;provider&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;devices&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;items&lt;/span&gt;&lt;span class="p"&gt;():&lt;/span&gt;
    &lt;span class="n"&gt;circuit&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;Circuit&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;spec&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nf"&gt;all_z&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="n"&gt;provider&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;provider&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nf"&gt;circuit&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;weights&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;inputs&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The loop is the whole comparison. The circuit, the observables and the post-processing stay the same, and the results have the same shape, dtype and bit order as a run with each provider's own credentials. We checked this on real runs on two cloud simulators and on QPUs from IQM and IBM. When a new provider is added to the router, it appears as one more device ID, and the code around it does not change.&lt;/p&gt;

&lt;p&gt;The key comes from the router web app: sign in, top up a prepaid USD balance and create a key. Jobs on IBM devices run on your own IBM Quantum account, which you connect once in the app; the router charges nothing for them, and IBM bills your account directly.&lt;/p&gt;

&lt;h2&gt;
  
  
  Knowing the price first
&lt;/h2&gt;

&lt;p&gt;Building a circuit on a paid device asks the router for an estimate and shows a &lt;code&gt;CostWarning&lt;/code&gt; with the price of one job, split into the provider's cost and the EigenOrbit fee, and your available balance. &lt;code&gt;circuit.dry_run_info()&lt;/code&gt; returns the same estimate as a dict (&lt;code&gt;estimate_usd_micro&lt;/code&gt;, &lt;code&gt;available_usd_micro&lt;/code&gt; and the gate counts of the circuit) without sending a job, which is handy in a notebook before a long batch.&lt;/p&gt;

&lt;p&gt;For QPUs priced per job and per shot, the estimate equals the final charge: 100 shots on IQM Garnet come to about $0.53. Cloud simulators are billed by run time, and a short simulator job costs well under a cent.&lt;/p&gt;

&lt;p&gt;The router reserves the estimate on the balance before it sends the job, so a job your balance cannot cover never starts. After the run it charges what the provider reported and returns the rest.&lt;/p&gt;

&lt;h2&gt;
  
  
  Waiting for a long queue
&lt;/h2&gt;

&lt;p&gt;A QPU queue can be long. Instead of a blocking call you can submit the job and keep working:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="n"&gt;handle&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;circuit&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;submit&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;weights&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;inputs&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;handle&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;job_id&lt;/span&gt;&lt;span class="p"&gt;(),&lt;/span&gt; &lt;span class="n"&gt;handle&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;status&lt;/span&gt;&lt;span class="p"&gt;())&lt;/span&gt;

&lt;span class="c1"&gt;# later in the same session
&lt;/span&gt;&lt;span class="n"&gt;values&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;handle&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;result&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;handle.status()&lt;/code&gt; is one non-blocking request, and &lt;code&gt;handle.result()&lt;/code&gt; waits for the job. The router watches the provider's queue itself, so the job keeps running if you close the notebook: its result stays on the Jobs page of the web app, which lists jobs from every provider with status, cost and result.&lt;/p&gt;

&lt;h2&gt;
  
  
  Small things that help in practice
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Spending limit per API key.&lt;/strong&gt; A key can go to a student or into CI with a fixed budget.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Retries without double charges.&lt;/strong&gt; The client retries dropped connections with the same idempotency key, so a flaky network never creates a second paid job.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Errors you can branch on.&lt;/strong&gt; Every failure is a &lt;code&gt;RouterError&lt;/code&gt; with a stable &lt;code&gt;code&lt;/code&gt; such as &lt;code&gt;insufficient_balance&lt;/code&gt;, &lt;code&gt;device_unavailable&lt;/code&gt; or &lt;code&gt;shots_invalid&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Provider-specific options where they matter.&lt;/strong&gt; For example, error suppression options on IBM devices go through &lt;code&gt;primitive_options&lt;/code&gt;, in the same shape as eigenkit's own IBM config.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A public device catalog.&lt;/strong&gt; &lt;a href="https://router.eigenorbit.com/devices" rel="noopener noreferrer"&gt;router.eigenorbit.com/devices&lt;/a&gt; shows every device ID, price, shot range and availability window without sign-in.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  When to use your own credentials instead
&lt;/h2&gt;

&lt;p&gt;If your organization already has a contract with a quantum cloud provider at negotiated prices, or you need hybrid jobs or reserved sessions, use eigenkit with your own credentials: the circuit code stays the same and only the provider changes. The router fits best when you want to try several devices without opening several accounts, give hardware access to students or a team with a budget, or keep the cost of each run visible before it happens.&lt;/p&gt;

&lt;h2&gt;
  
  
  Providers and devices
&lt;/h2&gt;

&lt;p&gt;The catalog changes as providers and devices are added, so check &lt;a href="https://router.eigenorbit.com/devices" rel="noopener noreferrer"&gt;router.eigenorbit.com/devices&lt;/a&gt; for the current list. In November 2026 it has:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Quantum provider&lt;/th&gt;
&lt;th&gt;Devices&lt;/th&gt;
&lt;th&gt;Qubit technology&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;IonQ&lt;/td&gt;
&lt;td&gt;Forte 1, Forte Enterprise 1&lt;/td&gt;
&lt;td&gt;Trapped ions&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;AQT&lt;/td&gt;
&lt;td&gt;IBEX Q1&lt;/td&gt;
&lt;td&gt;Trapped ions&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;IQM&lt;/td&gt;
&lt;td&gt;Garnet, Emerald&lt;/td&gt;
&lt;td&gt;Superconducting&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Rigetti&lt;/td&gt;
&lt;td&gt;Cepheus-1-108Q&lt;/td&gt;
&lt;td&gt;Superconducting&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;IBM (on your own IBM account)&lt;/td&gt;
&lt;td&gt;ibm_fez, ibm_kingston, ibm_marrakesh&lt;/td&gt;
&lt;td&gt;Superconducting&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Cloud simulators&lt;/td&gt;
&lt;td&gt;SV1, DM1&lt;/td&gt;
&lt;td&gt;State vector and density matrix&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;IonQ, AQT, IQM, Rigetti and the simulators are reached through Amazon Braket and paid from the EigenOrbit balance; IBM devices go through IBM Quantum.&lt;/p&gt;

&lt;p&gt;More providers and devices are coming soon. Follow EigenOrbit to see each one as it is added.&lt;/p&gt;

&lt;h2&gt;
  
  
  Links
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Router: &lt;a href="https://router.eigenorbit.com" rel="noopener noreferrer"&gt;router.eigenorbit.com&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Device catalog and prices: &lt;a href="https://router.eigenorbit.com/devices" rel="noopener noreferrer"&gt;router.eigenorbit.com/devices&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Router client: &lt;a href="https://pypi.org/project/eigenorbit-router-client/" rel="noopener noreferrer"&gt;PyPI&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;eigenkit: &lt;a href="https://github.com/eigenorbit/eigenkit" rel="noopener noreferrer"&gt;GitHub&lt;/a&gt;, &lt;a href="https://docs.kit.eigenorbit.com" rel="noopener noreferrer"&gt;docs&lt;/a&gt;, &lt;a href="https://pypi.org/project/eigenkit/" rel="noopener noreferrer"&gt;PyPI&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>quantum</category>
      <category>python</category>
      <category>tutorial</category>
      <category>api</category>
    </item>
    <item>
      <title>eigenkit: write a quantum circuit once, run it on any backend</title>
      <dc:creator>EigenOrbit</dc:creator>
      <pubDate>Mon, 09 Nov 2026 13:25:27 +0000</pubDate>
      <link>https://dev.to/eigenorbit/eigenkit-write-a-quantum-circuit-once-run-it-on-any-backend-38n4</link>
      <guid>https://dev.to/eigenorbit/eigenkit-write-a-quantum-circuit-once-run-it-on-any-backend-38n4</guid>
      <description>&lt;p&gt;Every quantum SDK has its own circuit objects. A model written for PennyLane has to be rewritten to run on Qiskit Aer, and rewritten again for an IBM or IQM device. Comparing backends on your own workload turns into integration work.&lt;/p&gt;

&lt;p&gt;We built &lt;strong&gt;eigenkit&lt;/strong&gt; to remove that step. It is an open-source Python library (Apache-2.0) that describes a circuit once, as data, and lets each backend compile that description into its own SDK. Moving to another simulator or a QPU means changing the &lt;code&gt;provider=&lt;/code&gt; argument.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;pip &lt;span class="nb"&gt;install &lt;/span&gt;eigenkit
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The core install is numpy, scipy and pydantic. PyTorch, scikit-learn and every quantum SDK are optional extras.&lt;/p&gt;

&lt;h2&gt;
  
  
  One circuit, four simulators
&lt;/h2&gt;

&lt;p&gt;A small IQP circuit: Hadamards, a ring of ZZ rotations, Hadamards again.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;eigenkit&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;Circuit&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;CircuitBuilder&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Z&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;iqp&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;n&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;edges&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;angles&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="n"&gt;qc&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;CircuitBuilder&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;n_qubits&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;n&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;q&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="nf"&gt;range&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;n&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="n"&gt;qc&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;h&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;q&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="nf"&gt;for &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;i&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;j&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="n"&gt;angle&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="nf"&gt;zip&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;edges&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;angles&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="n"&gt;qc&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;pauli_exponential&lt;/span&gt;&lt;span class="p"&gt;(((&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Z&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;i&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Z&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;j&lt;/span&gt;&lt;span class="p"&gt;)),&lt;/span&gt; &lt;span class="n"&gt;angle&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;q&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="nf"&gt;range&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;n&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="n"&gt;qc&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;h&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;q&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;qc&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;build&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;

&lt;span class="n"&gt;spec&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;iqp&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;4&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;)],&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mf"&gt;0.7&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mf"&gt;1.1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mf"&gt;0.4&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mf"&gt;1.9&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt;
&lt;span class="n"&gt;observables&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Z&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="nc"&gt;Z&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="nc"&gt;Z&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="nc"&gt;Z&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="nc"&gt;Z&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="nc"&gt;Z&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="nc"&gt;Z&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="nc"&gt;Z&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;)]&lt;/span&gt;

&lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;provider&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;numpy&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;pennylane&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;qiskit-aer&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;qulacs&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;]:&lt;/span&gt;
    &lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;provider&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;Circuit&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;spec&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;observables&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;observables&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;provider&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;provider&lt;/span&gt;&lt;span class="p"&gt;)([]))&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;





&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;numpy       [0.46548538 0.11841725 1.        ]
pennylane   [0.46548538 0.11841725 1.        ]
qiskit-aer  [0.46548538 0.11841725 1.        ]
qulacs      [0.46548538 0.11841725 1.        ]
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;numpy&lt;/code&gt; is the built-in simulator and needs nothing extra. The others come with &lt;code&gt;pip install "eigenkit[pennylane,qiskit,qulacs]"&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;The current list of simulators: numpy, PennyLane, Qiskit, Qiskit Aer (statevector and MPS), Qulacs, qsim, TensorCircuit, CUDA-Q and Amazon Braket.&lt;/p&gt;

&lt;h2&gt;
  
  
  The same code on hardware
&lt;/h2&gt;

&lt;p&gt;On a QPU the provider becomes a device config. The rest of the program stays the same:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;eigenkit&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;IQMConfig&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;QiskitRuntimeConfig&lt;/span&gt;

&lt;span class="n"&gt;devices&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;IBM Heron&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;QiskitRuntimeConfig&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;backend_name&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;ibm_kingston&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;shots&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;8192&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;primitive&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;sampler&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;
    &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;IQM Emerald&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;IQMConfig&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;quantum_computer&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;emerald&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;shots&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;8192&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;name&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;device&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;devices&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;items&lt;/span&gt;&lt;span class="p"&gt;():&lt;/span&gt;
    &lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;Circuit&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;spec&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;observables&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;observables&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;provider&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;device&lt;/span&gt;&lt;span class="p"&gt;)([]))&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Hardware access goes through IBM Qiskit Runtime, IQM Resonance and the QPUs on Amazon Braket. Photonic circuits run on Quandela's Perceval.&lt;/p&gt;

&lt;p&gt;Real hardware costs money, so the library guards against accidental spending. Compiling for a paid device raises a &lt;code&gt;CostWarning&lt;/code&gt;, and &lt;code&gt;dry_run_info()&lt;/code&gt; previews a job before it is submitted. Gradients on hardware are opt-in (&lt;code&gt;enable_gradients=True&lt;/code&gt;), since one backward pass runs at least two jobs per weight.&lt;/p&gt;

&lt;h2&gt;
  
  
  A circuit fits the classical stack
&lt;/h2&gt;

&lt;p&gt;Circuits can also be assembled from ready-made blocks. With the default interface a circuit is a numpy function, and the gradient is one call away:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;numpy&lt;/span&gt; &lt;span class="k"&gt;as&lt;/span&gt; &lt;span class="n"&gt;np&lt;/span&gt;
&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;eigenkit&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;Circuit&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Encoding&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Variational&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;all_z&lt;/span&gt;

&lt;span class="n"&gt;circuit&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;Circuit&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="n"&gt;blocks&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Encoding&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;in_features&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;4&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="nc"&gt;Variational&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;depth&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;)],&lt;/span&gt;
    &lt;span class="n"&gt;observables&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="nf"&gt;all_z&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;4&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="n"&gt;weights&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;np&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;zeros&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;circuit&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;spec&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;n_weights&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;x&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;np&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;random&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;uniform&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;np&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;pi&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;size&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;8&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;4&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;   &lt;span class="c1"&gt;# a batch of 8 samples
&lt;/span&gt;&lt;span class="n"&gt;y&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;circuit&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;weights&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;                         &lt;span class="c1"&gt;# shape (8, 4)
&lt;/span&gt;&lt;span class="n"&gt;grad&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;circuit&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;jacobian&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;weights&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt;          &lt;span class="c1"&gt;# no torch needed
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;With &lt;code&gt;interface="torch"&lt;/code&gt; the same circuit becomes a &lt;code&gt;torch.nn.Module&lt;/code&gt; that owns its weights and trains inside a larger model with a standard optimizer. The ready-made models (hybrid networks, quantum kernels, reservoir computing) follow scikit-learn's &lt;code&gt;fit&lt;/code&gt; / &lt;code&gt;predict&lt;/code&gt;, so they work with &lt;code&gt;Pipeline&lt;/code&gt; and &lt;code&gt;GridSearchCV&lt;/code&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Checking the result against classical models
&lt;/h2&gt;

&lt;p&gt;A quantum model is only interesting next to a good classical baseline. &lt;code&gt;compare()&lt;/code&gt; trains quantum and classical models on the same data over several seeds and reports mean and spread:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;sklearn.svm&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;SVC&lt;/span&gt;
&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;sklearn.ensemble&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;RandomForestClassifier&lt;/span&gt;
&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;eigenkit&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;QSVC&lt;/span&gt;
&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;eigenkit.benchmark&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;compare&lt;/span&gt;

&lt;span class="n"&gt;result&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;compare&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;QSVC&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;QSVC&lt;/span&gt;&lt;span class="p"&gt;(),&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;SVC (RBF)&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;SVC&lt;/span&gt;&lt;span class="p"&gt;(),&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Random forest&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;RandomForestClassifier&lt;/span&gt;&lt;span class="p"&gt;()},&lt;/span&gt;
    &lt;span class="n"&gt;dataset&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;iris&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;n_seeds&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;5&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;table&lt;/span&gt;&lt;span class="p"&gt;())&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;On our run:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;┌───────────────┬───────────────┬───────────────┬──────────────────┬───────────────────┐
│ Model         │ Accuracy      │ F1            │ Fit time (s)     │ Predict time (s)  │
├───────────────┼───────────────┼───────────────┼──────────────────┼───────────────────┤
│ QSVC          │ 0.974 ± 0.039 │ 0.973 ± 0.040 │ 0.0022 ± 0.00039 │ 0.00075 ± 2e-05   │
│ SVC (RBF)     │ 0.965 ± 0.036 │ 0.965 ± 0.037 │ 0.0012 ± 9.3e-05 │ 0.00023 ± 3.2e-05 │
│ Random forest │ 0.957 ± 0.053 │ 0.956 ± 0.054 │ 0.095 ± 0.0091   │ 0.0049 ± 0.00017  │
└───────────────┴───────────────┴───────────────┴──────────────────┴───────────────────┘
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The quantum kernel has the highest mean accuracy. &lt;code&gt;result.significance_test("accuracy")&lt;/code&gt; runs a Wilcoxon test across seeds, and every pairwise p-value comes out at 0.5 or higher. On iris the three models are statistically tied, and the classical SVC predicts about three times faster. That is the kind of answer &lt;code&gt;compare()&lt;/code&gt; is there to give.&lt;/p&gt;

&lt;p&gt;The &lt;code&gt;qml&lt;/code&gt; and &lt;code&gt;benchmark&lt;/code&gt; extras are needed for this example. &lt;code&gt;eigenkit.datasets&lt;/code&gt; ships 12 datasets for classification, regression and time series.&lt;/p&gt;

&lt;h2&gt;
  
  
  What else is inside
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Optimization: QUBO / Ising, Max-Cut, QAOA.&lt;/li&gt;
&lt;li&gt;Chemistry: Jordan-Wigner and Bravyi-Kitaev mappings, UCCSD, VQE, molecular Hamiltonians through PySCF and OpenFermion.&lt;/li&gt;
&lt;li&gt;HHL, iterative amplitude estimation (IQAE) and portfolio risk (VaR / CVaR).&lt;/li&gt;
&lt;li&gt;Orthogonal networks of RBS gates for orthogonal fine-tuning and certified robustness.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Optimization and chemistry run on the core install. A four-node Max-Cut takes three lines:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;eigenkit.optimization&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;QAOA&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;max_cut&lt;/span&gt;

&lt;span class="n"&gt;res&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;QAOA&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;layers&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;provider&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;numpy&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;random_state&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;).&lt;/span&gt;&lt;span class="nf"&gt;solve&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;max_cut&lt;/span&gt;&lt;span class="p"&gt;([(&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;)]))&lt;/span&gt;
&lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;res&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;best_bitstring&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;res&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;best_energy&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;   &lt;span class="c1"&gt;# (1, 0, 1, 0) -4.0
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  Links
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;GitHub: &lt;a href="https://github.com/eigenorbit/eigenkit" rel="noopener noreferrer"&gt;github.com/eigenorbit/eigenkit&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Docs: &lt;a href="https://docs.kit.eigenorbit.com" rel="noopener noreferrer"&gt;docs.kit.eigenorbit.com&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Paper: &lt;a href="https://arxiv.org/abs/2611.02979" rel="noopener noreferrer"&gt;arXiv:2611.02979&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;PyPI: &lt;a href="https://pypi.org/project/eigenkit/" rel="noopener noreferrer"&gt;pypi.org/project/eigenkit&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Which backend or dataset should we test next? Tell us in the comments.&lt;/p&gt;

</description>
      <category>quantum</category>
      <category>python</category>
      <category>machinelearning</category>
      <category>opensource</category>
    </item>
  </channel>
</rss>
