Does anyone have experience building multiqubit quantum channels? I can make a simple one with a single Krauss operator, but am having trouble defining a multiqubit channel with multiple Krauss operators. In this example, I'm applying a stochastic XX operator on qubits 1&2 and the identity on qubits 3&4.

This works:

channel = 
 QuantumChannel[
  Sqrt[0.5] QuantumTensorProduct[QuantumOperator["X", {1, 2}], 
    QuantumOperator["I", {3, 4}]]]

Now if I want to apply XX or YY with equal probability on qubits 1&2, I fail.

This doesn't work:

channel = 
 QuantumChannel[{Sqrt[0.5]
     QuantumTensorProduct[QuantumOperator["X", {1, 2}], 
     QuantumOperator["I", {3, 4}]], 
   Sqrt[0.5]
     QuantumTensorProduct[QuantumOperator["Y", {1, 2}], 
     QuantumOperator["I", {3, 4}]]}]

I get this error message:

Thread::tdlen: Objects of unequal length in {4}->{1,2,3,4} cannot be combined.

Thanks in advance for any help.

https://community.wolfram.com/groups/-/m/t/2846060 IBM-quantum service connect

Similarly Paclet depository

Wolfram Cloud ( v 1.28)

Qiskit is Py-based, so there should not be any issue. Q3, it depends, if same names for functions, yes, there will be issues

QuantumTensorProduct[Table[QuantumState[{1, Exp[2 Pi I x/2^k]}], {k, Log2[n]}]]/Sqrt[n]

The short answer is: don't display the summary box for that tensor product, it crashes while trying to compute the entropy for it, so just put a semicolon after it u1=QuantumTensorProduct[s1,t1];.

The main culprit is the time-constrained MatrixLog bug, just try TimeConstrained[MatrixLog[RandomReal[1, {1024, 1024}]], 1], and it will crash your kernel. We need to constrain it for the summary box. Otherwise, it would take too long to render. But the "Entropy" property can be computed if you are willing to wait. The bug was already reported and should be fixed in 13.2.

Thanks to Mads and Nicholay (and whoever else contributed) to solving the problem in the previous post. It was magic. One day I had a problem with the four named states "BasisState", "Register","Graph", and "BlochVector", and the next day I re-installed a (presumably changed) version of WQF, and voila! everything worked as expected. Thank you. Here is the evidence.

Thanks -- I figured theses were special states (BasisState, Register, Graph, and BlochVector) for which more information was required. I just couldn't find any thing in the documentation about it (it might be there, I just couldn't find it!). So thanks for letting me know how it's supposed to work!

This is a new question, but related to the homework problems from the recent WQF course in October. I hope this is the right place to ask. It has to do with the four named states BasisState, Register, Graph, and BlochVector. Due to the fact that their density matrices contain text, it makes determination of certain properties either nonexistent or counterintuitive. I wonder if you could enlighten me -- I'm sure there's a simple explanation but I can't figure it out. Pleases see attached notebook snippet. Thanks, Mike

The solution to the homework problem to show the equivalence between a power of a Pauli gate and a suitable corresponding rotation generates an error (at least the one shown in the Operators and measurements notebook (from the talk)). Namely,.

(equivalence assertion is as follows:) QuantumOperator["X"]^t == Exp[I Pi/2 t] QuantumOperator[{"R", [Pi] t, "X"}] // Simplify

(followed by very long error message:) I am not sure how to fix this. It is the Quantum Operator[{"R", pi t, "X"}] on the right that causes the problem. Here is the first part of the error message

QuantumState::failprop: property NormalizedDensityMatrix failed with Failure[[WarningSign] Message: SparseArray[Specified elements: 2 Dimensions: {2,2}

]/Tr[SparseArray[Specified elements: 2 Dimensions: {2,2}

]] produced a message on evaluation. Tag: ConfirmationFailed

]

$RecursionLimit::reclim2: Recursion depth of 1024 exceeded during evaluation of WolframQuantumFrameworkPackageScope`QuantumOperatorQ[Unevaluated[E^Failure[[WarningSign] Message: MatrixQ[QuantumState[Mixed state Qudits: 1 Type: Matrix Dimension: 2 Picture: Schrödinger

]] did not return True. Tag: ConfirmationFailed

]]].

$RecursionLimit::reclim2: Recursion depth of 1024 exceeded during evaluation of WolframQuantumFrameworkPackageScope`QuantumMeasurementOperatorQ[Unevaluated[E^Failure[[WarningSign] Message: MatrixQ[QuantumState[Mixed state Qudits: 1 Type: Matrix Dimension: 2 Picture: Schrödinger

]] did not return True. Tag: ConfirmationFailed

]]].

$RecursionLimit::reclim2: Recursion depth of 1024 exceeded during evaluation of WolframQuantumFrameworkPackageScope`QuantumChannelQ[Unevaluated[E^Failure[[WarningSign] Message: MatrixQ[QuantumState[Mixed state Qudits: 1 Type: Matrix Dimension: 2 Picture: Schrödinger

]] did not return True. Tag: ConfirmationFailed

]]].

General::stop: Further output of $RecursionLimit::reclim2 will be suppressed during this calculation.

$IterationLimit::itlim: Iteration limit of 4096 exceeded.

$IterationLimit::itlim: Iteration limit of 4096 exceeded.

JordanDecomposition::eivn: Incorrect number 0 of eigenvectors for eigenvalue -2.9914910^15+3.7192510^15 I with multiplicity 1.

JordanDecomposition::eivn: Incorrect number 0 of eigenvectors for eigenvalue -2.9914910^15+3.7192510^15 I with multiplicity 1.

JordanDecomposition::eivn: Incorrect number 0 of eigenvectors for eigenvalue -2.9914910^15+3.7192510^15 I with multiplicity 1.

General::stop: Further output of JordanDecomposition::eivn will be suppressed during this calculation.

JordanDecomposition::eival: Unable to find all roots of the characteristic polynomial.

JordanDecomposition::eival: Unable to find all roots of the characteristic polynomial.

Mads that looks good .

Could we not have a step by step tutorial laying out exactly how to set up a connection to IBMQ using ones own API token from IBM Quantum experience. (the graphics require MaTeX and how to set that up )

Regarding the multiplexer that we discussed today. Here is what we wanted to show. Let's construct the following circuit using only operators one by one: First let's create the correct sequence for control-1 and control-0 qubits:

seq = Reverse[
  Values[<|0 -> {}, 1 -> {}, 
      GroupBy[Transpose[{#, {1, 2, 3}}], First -> Last]|>] & /@ 
   Tuples[{0, 1}, 3]]

which gives us:

{{{}, {1, 2, 3}}, {{3}, {1, 2}}, {{2}, {1, 3}}, {{2, 
   3}, {1}}, {{1}, {2, 3}}, {{1, 3}, {2}}, {{1, 2}, {3}}, {{1, 2, 
   3}, {}}}

Then the corresponding circuit can be created as follows:

qc = QuantumCircuitOperator[
  MapThread[{"C", #2, Sequence @@ #1} &, {Reverse[seq], {"H", "Y", 
     "Y", "Y", "Y", "Y", "H", "Y"}}]]

once can show that the operator circuit is equivalent to this operator:

QuantumOperator[{"Multiplexer", "H", "Y", "Y", "Y", "Y", "Y", "H", 
  "Y"}]

Test:

QuantumOperator[{"Multiplexer", "H", "Y", "Y", "Y", "Y", "Y", "H", 
"Y"}] == qc["CircuitOperator"]

Of course, note the difference in the number of qudits etc too

https://www.wolframcloud.com/obj/wolframquantumframework/Published/Operators%20and%20measurement%20-%20Live.nb

Today's live notebook

BTW, our framework works fine on cloud, too

I have successfully used Qiskit to run examples on the IBM Quantum computer, but I am also an applied math person, I need to understand what I am trying to achieve. You have shown us an amazing number of functions, but I am struggling to work out how and where to start. Any chance of a quick example, say the addition circuit using Toffoli at the end of " section 4.3 " of Qiskit textbook into to Wolfram code? After that I might have some chance with the quiz.

Attachments:

Print of Qiskit ...png

Nik is there a way to make this conversion from qiskit circuits to WQF easier . Does WQF have a similar inverse() function that would take a WQF circuit and invert it to represent the circuit in Qiskit style .

Qiskit will not let you reverse a measurement , you have to reverse the circuit without measurement then add the measurement .to the reversed circuit

Hi Doug

Re your reply "I currently spend most of my time transferring code from the new qiskit textbook into WQF", is this for personal use or will the examples turn up into the future in Wolfram language as examples? My interest is in the Travelling Salesperson Problem (TSP) which you know is in Qiskit, I have used Mathematica for more than twenty-five years and would like, if possible, to stick with the home team.

Doug, you can easily send queries to a quantum hardware from Wolfram notebook. See below examples

Decan, that’s not correct. See notebooks that I shared, showing how to send queries to a quantum hardware from a Wolfram notebook

Declan

I think we will be using qiskit to access real hardware . We are told we can access it through WQF but we are not given the resources to do it .

The three files are not going to achieve that goal . leaving out the Amazon bracket file and concentrate on the two IBM files .Looking at IBMQ we are given a link to

https://qiskit.org/documentation/partners/qiskitibmruntime/getting_started.html):

and then

token = Import["~/.qiskit/qiskit-ibm.json", "RawJSON"][
   "default-ibm-quantum", "token"];

I assume we install the qiskit-ibm-runtime in qiskit ands access a json file to generate a token . Who knows . So the rest of the IBMQ file makes no sense as I cannot run the first line .

So lets turn to the qiskitIBMQ file . Alls well until

qiskitCircuit["Graphics", "Scale" -> 1]

The "Graphics", needs Matex installing and help with this would be helpful

then down to the first timer we attempt to run on hardware

grover[[;; -2]]["Qiskit"][initState, "Provider" -> "IBMQ"]

which obviously will not run on my machine as I have not done the setup .

So what we need is a notebook with a clean setup from installing the qiskit-ibm-runtime in qiskit to creating a token ( using your own personal api-token in IBM-quantum-experience) , creating an ID and then running some QASMs:. Then create the code to run grover

grover = QuantumMeasurementOperator[Range[3]]@
  QuantumCircuitOperator[{"Grover", a && ! b && c}]
groverQiskit=grover["Qiskit"]["Decompose"]
initState=QuantumOperator["Z",{4}]@QuantumState[{"UniformSuperposition",4}];
grover[[;;-2]]["Qiskit"][initState,"Provider"->"IBMQ"]
cloudSimMeasurement=groverQiskit[initState,"Provider"->"IBMQ"]
deviceMeasurement=groverQiskit[initState,"Provider"->"IBMQ","Backend"->"ibmq_lima"]
BarChart[Merge[{exactMeasurement["Probabilities"],simMeasurement["Probabilities"],deviceMeasurement["Probabilities"]},Identity],ChartLabels->Automatic,
 ChartLegends->Placed[{"Exact","Simulation","QPU"},Below]]

Hopefully then the code will run

https://community.wolfram.com/groups/-/m/t/2491392

Take a look at this one too

no, 3 different states (a textbook example when discussing POVMs) create each one separately, then transform them into Pauli-Y basis

https://en.wikipedia.org/wiki/Werner_state yes, they are mixture of projectors try higher dimensions too and compare with

QuantumState[{"Werner",p,d}]

Hi Mike, on Mac, if you hover your mouse over the function, then click Command+Shift+T, the documentation page will pop up. Also, for some of functions (not all of them, eventually for all of them), we have added the option of seeing their most common template

I wouldn't call it a measurement, because you only extract a single specific probability. So it is just composing certain state projectors, or their corresponding operators, with a target state:

Tr[QuantumState["0"]["Operator"]@QuantumState["+", "X"]["Operator", {2}]@QuantumState["PhiPlus"]]

If you like nice notation, then after evaluating each piece inline individually and turning them into their TraditionalForm, it would look like this inside an Output cell:

Notice that I make a plus state in X basis and turn it into an operator that acts on the 2nd qubit: QuantumState["+", "X"]["Operator", {2}] (update the paclet to make it work).

If you want to do a measurement in computational and "X" basis and extract probabilities, you should act with QuantumMeasurementOperator on the state:

QuantumMeasurementOperator[{2, "X"}, {1, 2}][QuantumState["PhiPlus"]]["Probabilities"]

QuantumMeasurementOperator doesn't look very nice in TraditionalForm, but you can still display it:

These extra output bold kets are eigenvalues for your measurement (it's that vertical measurement wire that you see in circuit diagrams), it goes from 0 to D-1 by default. We will discuss it in more detail at the study group dedicated to measurement, stay tuned! ;)

I am sure that "EntangledQ" was part of QuantumState["Properties"] but it now it seems its missing

(found it QuantumEntangledQ )

It's Cmd+Shift+T for TraditionalForm, and Cmd+Shift+N for StandardForm.