How-to: Quantum Arithmetic #1229

gmlejarza · 2024-10-04T10:54:28Z

Title: How to use Quantum Arithmetic Operators [sc-74430]

Summary: We show how to load a function into a quantum computer using Pennylane arithmetic operators.

If you are writing a demonstration, please answer these questions to facilitate the marketing process.

GOALS — Why are we working on this now?

Promote and make people understand how to use quantum arithmetic operators in Pennylane.

AUDIENCE — Who is this for?

Researchers working in quantum algorithms, beginners starting in quantum computing.

KEYWORDS — What words should be included in the marketing post?

Quantum Arithmetic, Loading functions into quantum computers, Addition, Multiplication,

Which of the following types of documentation is most similar to your file?
(more details here)

How-to

github-actions · 2024-10-04T10:54:40Z

👋 Hey, looks like you've updated some demos!

🐘 Don't forget to update the dateOfLastModification in the associated metadata files so your changes are reflected in Glass Onion (search and recommendations).

Please hide this comment once the field(s) are updated. Thanks!

demonstrations/tutorial_how_to_use_arithmetic_operators.py

github-actions · 2024-10-04T13:01:27Z

Thank you for opening this pull request.

You can find the built site at this link.

Deployment Info:

Pull Request ID: 1229
Deployment SHA: 006891c369d91f41cb2939cf8dc7fbc3ee8927ec
(The Deployment SHA refers to the latest commit hash the docs were built from)

Note: It may take several minutes for updates to this pull request to be reflected on the deployed site.

KetpuntoG

Great job @gmlejarza 🚀
I made a push to try to simplify the code as much as possible as it could be “intimidating” at first. In general everything is fine and to improve it I would try to be much more direct trying to keep this how-to short
On the other hand, if you have a thumbnail suggestion, I will request it on Monday 🎨

demonstrations/tutorial_how_to_use_arithmetic_operators.py

ixfoduap

Left suggestions 😈

ixfoduap · 2024-10-08T20:17:15Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+Classical computers handle arithmetic operations like addition, subtraction, multiplication, and exponentiation with ease. 
+For instance, you can multiply two numbers on your phone in milliseconds!
+
+Quantum computers, however, aren't as efficient at basic arithmetic. So why do we need quantum arithmetic?
+While it's not "better" for basic operations, it's essential in more complex quantum algorithms. For example:


Too negative and not really true! Quantum hardware currently has a hard time with arithmetic, but in principle a quantum computer can do this with ease. I suggest instead motivating quantum arithmetic by saying that we don't plan to use quantum computers as calculators, but arithmetic is an important building block

ixfoduap · 2024-10-08T20:17:23Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+Quantum computers, however, aren't as efficient at basic arithmetic. So why do we need quantum arithmetic?
+While it's not "better" for basic operations, it's essential in more complex quantum algorithms. For example:
+
+1. In Shor's algorithm quantum arithmetic is crucial for performing modular exponentiation. 


ixfoduap · 2024-10-08T20:17:29Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+
+2. Grover's algorithm might need to use quantum arithmetic to construct oracles, as shown in [#demo_qft_arith]_.
+
+3. Loading functions into quantum computers, which often requires several quantum arithmetic operations.


demonstrations/tutorial_how_to_use_arithmetic_operators.py

ixfoduap · 2024-10-08T20:26:00Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+We can load the target function into the quantum computer using different quantum arithmetic operations. 
+We will break down into pieces. We'll do a step by step load of the function :math:`f(x, y)`.


This is repetitive compared to the previous sentences

ixfoduap · 2024-10-09T14:55:18Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+    # |x> --->  |3x>
+    qml.Multiplier(3, wires["x"], work_wires=wires["work_wires"])
+
+    # |3x>|y>|0> ---> |3x>|y>|3xy>


You haven't really explained why this is needed. It may also not be super clear to all readers that the uncomputation is done using the adjoint. For example, it may be a good opportunity to mention that we can use adders and multipliers to effectively subtract and divide.

In fact I'm curious, would the multiplier work if we multiply by 1/3? Multiply by sqrt{2}? It's not clear what are the allowed values for such scalars. Seems like only integers make sense

As suggested, I added an explanation about how the subtraction and division can be achieved by using the adjoint. Regarding the possibility of multiplying by non-integer numbers, the documentation of each operator specifies that the constant used for addition/multiplication is an integer: https://docs.pennylane.ai/en/stable/code/api/pennylane.Adder.html , https://docs.pennylane.ai/en/stable/code/api/pennylane.Multiplier.html

ixfoduap · 2024-10-09T14:58:31Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+print(circuit(x=1,y=4))
+
+######################################################################
+# The result doesn't seem right, as we expect to get :math:`f(x=1, y=4) = 33`. Can you guess why?


No, showing incorrect results is not good in a demo! Much better to clarify from the beginning that all arithmetic is done modulo the largest number that can be supported given the number of qubits. Then you have an example that works, and THEN you can quickly change inputs to showcase overflow, tying back to the how this was mentioned before.

In fact getting 1 instead of 33 is not wrong, it's what we want and expect. We just have to remember that this is all modular arithmetic (hence why it's good to clarify from the beginning)

Good point! I clarified from the beginning that all arithmetic is modular. Then, changed the order to show first the "expected" result (33) and then reduce the number of wires to showcase the overflow and remember that quantum arithmetic is modular.

demonstrations/tutorial_how_to_use_arithmetic_operators.py

ixfoduap · 2024-10-09T18:52:07Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+
+   return qml.sample(wires = wires["output"])
+
+print(circuit_with_Poly(x=1,y=4))


By the way, I'm thinking it may be nice to code up a simple function to convert binary into integers so we can print out the numerical value directly alongside the bitstring description. If I remember correctly, numpy or scipy have these already

Also, is there a way to visualize the circuits that doesn't just show OutPoly or something? It would be great to see how they are decomposed into basic operations

Unfortunately, there's no such built-in function that automatically converts a list representing a binary number into its decimal form. However, I've coded a custom function to print out the numerical value alongside the bitstring.

Regarding visualization, I included a printout of the Adder circuit, showing that the addition uses a QFT to switch the basis and then applies rotations to perform the addition in the Fourier basis. I think, this operator is the most pedagogical to showcase, since it serves as a building block to build the others. I also referred the reader to this demo, where the decomposition is further explained: https://pennylane.ai/qml/demos/tutorial_qft_arithmetics/

ixfoduap · 2024-10-09T18:53:45Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+# Conclusion
+# ------------------------------------------
+# Understanding and implementing quantum arithmetic is a key step toward unlocking the full potential
+# of quantum computing. While it may not replace classical efficiency for simple tasks, its role in complex algorithms 


Remove the second sentence

Co-authored-by: ixfoduap <[email protected]>

KetpuntoG

This is taking shape 💪
Here are some comments

KetpuntoG · 2024-10-16T12:58:13Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+Inplace operators, like the Adder and Multiplier, directly modify the original quantum state by updating a 
+specific register's state. In contrast, Outplace operators, such as the OutAdder and OutMultiplier, 
+combine multiple states and store the result in a new register, leaving the original states unchanged.
+


an image showing a sketch of an inplace and outplace operator could look good here :)

KetpuntoG · 2024-10-16T12:59:42Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+In quantum computing, all arithmetic operations are modular. This means the result of any operation is reduced 
+modulo :math:`2^n`, where :math:`n` is the number of qubits in the register. This is because quantum states can only 
+represent numbers up to :math:`2^n`, so it's important to keep this in mind when working with quantum arithmetic.


perhaps it would be better to say that it reduces to a module m. And for simplicity in this how-to we will take m = 2^n, the value that the template assumes by default

Okay, I see that you comment on it later. I think it can be rephrased a bit for clarity

KetpuntoG · 2024-10-16T13:01:35Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+
+There are two addition operators in PennyLane: the :class:`~.pennylane.Adder` and the :class:`~.pennylane.OutAdder`.
+
+The :class:`~.pennylane.Adder` performs an **Inplace** operation, adding a constant value :math:`k` to the state of the wires :math:`|w \rangle`. It is defined as:


I would clarify $k \in \mathbb{Z}$ or k integer

KetpuntoG · 2024-10-16T13:03:33Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+
+######################################################################
+# Now, we write a circuit to prepare the state :math:`|x \rangle|y \rangle|0 \rangle`, since it will be needed for the Outplace 
+# operation, where we initialize specific values to :math:`x` and :math:`y`.


It may be convenient to say that we will use basic states in the example but you could introduce any quantum state

KetpuntoG · 2024-10-16T13:09:05Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+# Now we can implement an example for the :class:`~.pennylane.Adder`. We will add the constant term :math:`4` to the ``wires["x"]`` register:
+
+@qml.qnode(dev)
+def circuit():
+
+    # |0> --->  |0+4>
+    qml.Adder(4, wires["x"])    
+


This example does not convince me because it gives the feeling that it must be linked to the above but it is something totally different

I included a line explaining and added the initialization of prepare_initial_state to link it with what it's above

KetpuntoG · 2024-10-16T13:13:23Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+# Nice! 
+# 
+# After going through these educational examples, you might be curious if it's possible to 
+# use these operations for subtraction or division in a quantum computer. The answer is yes!


"modular division", to avoid confusion

KetpuntoG · 2024-10-16T13:14:01Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+# This is possible through the :func:`~.pennylane.adjoint` operation, which allows us to reverse a multiplication or addition operation, hence enabling
+# subtraction and division. We will see this in action in the following section.
+#
+# Loading a polynomial into a quantum computer


Let's not use the work "Load", maybe "apply?

If you agree, take a look at the text that appears in more occasions

Why you don't like "load"? I'm not particularly against "apply", but it looks to me that what we are doing is more "loading" a polynomial into a quantum state, more than applying the polynomial anywhere. Anyway, let me know your thoughts and I'm happy to discuss

Definitely not loading! This is a circuit that applies a polynomial transformation to input registers. "Loading" has the connotation of loading data

KetpuntoG · 2024-10-16T13:17:07Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+    # |3x>|y>|0> ---> |3x>|y>|3xy>
+    qml.OutMultiplier(wires["x"], wires["y"], wires["output"])
+
+    # We return the x-register to its original value using the adjoint operation


I've been told that it is not clear why we do this. I would emphasize in the text or here that by the definition of U, the inputs |x> and |y> are not modified.

demonstrations/tutorial_how_to_use_arithmetic_operators.py

KetpuntoG · 2024-10-16T13:19:18Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+# At this point, it's interesting to consider what would happen if we had chosen a smaller number of wires for the output.
+# For instance, if we had selected one less wire for the output, we would have obtained the result :math:`33 \mod 2^5 = 1`.
+
+wires = qml.registers({"x": 4, "y": 4, "output": 5, "work_wires": 4})


We can remove work_wires 😎

KetpuntoG · 2024-10-16T14:19:38Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+wires = qml.registers({"x": 4, "y":4, "output":6,"work_wires": 4})
+@qml.qnode(dev)
+def circuit_with_Poly(x,y):
+
+   prepare_initial_state(x, y)
+   qml.OutPoly(f, registers_wires=[wires["x"], wires["y"], wires["output"]])


Based on new interface

Suggested change

wires = qml.registers({"x": 4, "y":4, "output":6,"work_wires": 4})

@qml.qnode(dev)

def circuit_with_Poly(x,y):

prepare_initial_state(x, y)

qml.OutPoly(f, registers_wires=[wires["x"], wires["y"], wires["output"]])

wires = qml.registers({"x": 4, "y":4, "output":6,"work_wires": 4})

@qml.qnode(dev)

def circuit_with_Poly(x,y):

prepare_initial_state(x, y)

qml.OutPoly(

f,

x_wires = wires["x"],

y_wires = wires["y"],

output_wires = wires["output"])

KetpuntoG

Easy and simple 💪 It's looking good

KetpuntoG · 2024-10-23T13:58:44Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+How-to use Quantum Arithmetic Operators
+=======================================
+
+Classical computers handle arithmetic operations like addition, subtraction, multiplication, and exponentiation with ease. 


I like the intro 👍

KetpuntoG · 2024-10-23T14:00:24Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+operation is reduced modulo :math:mod, where the default is :math:mod=2^n, with :math:n being the number of 
+qubits in the register.Quantum states can represent numbers up to this limit, which is why PennyLane uses it 


Suggested change

operation is reduced modulo :math:mod, where the default is :math:mod=2^n, with :math:n being the number of

qubits in the register.Quantum states can represent numbers up to this limit, which is why PennyLane uses it

operation is reduced modulo :math:`\text{mod}`, where the default is :math:`\text{mod}=2^n`, with :math:`n` being the number of

qubits in the register. Quantum states can represent numbers up to this limit, which is why PennyLane uses it

I think it would be better to write “where the Pennylane default is” and delete the phrase, “which is why Pennylane. [...]”

KetpuntoG · 2024-10-23T14:07:22Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+qubits in the register.Quantum states can represent numbers up to this limit, which is why PennyLane uses it 
+as the default modulo for arithmetic operations. However, users can specify a custom value smaller than this 
+default. It's important to keep this modular behavior in mind when working with quantum arithmetic, as using 
+too few qubits in a quantum register could lead to overflow errors. We will come back to this point later.


it is probably not a good idea to speak of "error", as stated in another comment

I changed "errors" for "issues"

KetpuntoG · 2024-10-23T14:09:03Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+Next, we will explore how to define and implement addition and multiplication operators in PennyLane.
+
+Let's start by defining the Inplace and Outplace arithmetic addition operations. 


I found this section a bit long. I think these two sentences could be eliminated

KetpuntoG · 2024-10-23T14:13:08Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+Let's see how to implement these operators in Pennylane.
+
+The first thing to do is to define the `registers of wires <https://pennylane.ai/qml/demos/tutorial_how_to_use_registers/>`_


we could merge them:

"In order to implement it in PL, the first thing to do [...]"

or similar

KetpuntoG · 2024-10-23T14:38:55Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+# This is possible through the :func:`~.pennylane.adjoint` operation, which allows us to reverse a multiplication or addition operation, hence enabling
+# modular division and subtraction. We will see this in action in the following section.


The jump from this paragraph to the next was a bit disjointed. We talk about subtraction and division saying we are going to look at it now and then suddenly we move on to polynomials and positive terms. I would simply say something like:

“note that even though we just saw addition and multiplication, modular subtraction and division come as for free thanks to the adjoint operator.”

I would not reference that we are going to see it later (even if we are)

KetpuntoG · 2024-10-23T15:05:01Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+# In this functions, we showed how to undo the multiplication by using the adjoint operation, which in this case is useful to clean
+# the input registers ``wires["x"]`` and ``wires["y"]`` after the operation.


I think we can delete this sentence so as not to repeat ourselves

KetpuntoG · 2024-10-23T15:07:24Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+print(circuit(x=1,y=4), " which represents the number ", state_to_decimal(circuit(x=1,y=4)))
+
+######################################################################
+# Cool, we get the correct result 33!


Suggested change

# Cool, we get the correct result 33!

# Cool, we get the correct result :math:`f(1,4)=33`!

KetpuntoG · 2024-10-23T15:08:08Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+       x_wires = wires["x"],
+       y_wires = wires["y"],


Suggested change

x_wires = wires["x"],

y_wires = wires["y"],

input_registers= [wires["x"], wires["y"]],

new UI again 🙈

KetpuntoG · 2024-10-23T15:14:34Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+# adjoint function to undo certain multiplications and clean up the input registers after performing the operations.
+


Suggested change

# adjoint function to undo certain multiplications and clean up the input registers after performing the operations.

# adjoint function to undo certain multiplications and clean up the input registers after performing the operations since :math:`U` does not modify the input registers.

What do you think about clarifying this?

ixfoduap · 2024-10-25T13:44:29Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+=======================================
+
+Classical computers handle arithmetic operations like addition, subtraction, multiplication, and exponentiation with ease. 
+For instance, you can multiply two numbers on your phone in milliseconds!


Suggested change

For instance, you can multiply two numbers on your phone in milliseconds!

For instance, you can multiply large numbers on your phone in milliseconds!

ixfoduap · 2024-10-25T13:45:03Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+Quantum computers can handle these operations too, but their true value lies beyond basic calculations. While we don't plan to use 
+quantum computers as calculators for everyday arithmetic, these operations play a crucial role in more advanced quantum algorithms, 
+serving as fundamental building blocks in their design and execution. For example:


Suggested change

Quantum computers can handle these operations too, but their true value lies beyond basic calculations. While we don't plan to use

quantum computers as calculators for everyday arithmetic, these operations play a crucial role in more advanced quantum algorithms,

serving as fundamental building blocks in their design and execution. For example:

Quantum computers can handle these operations too, but their true value lies beyond basic calculations. Quantum arithmetic plays a crucial role in more advanced quantum algorithms,

serving as fundamental building blocks in their design and execution. For example:

ixfoduap · 2024-10-25T13:45:41Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+
+2. Grover's algorithm might need to use quantum arithmetic to construct oracles, as shown in [#demo_qft_arith]_.
+
+3. Loading functions into quantum computers often requires several quantum arithmetic operations [#sanders]_.


Suggested change

3. Loading functions into quantum computers often requires several quantum arithmetic operations [#sanders]_.

3. Loading data or preparing initial states on a quantum computer often requires several quantum arithmetic operations [#sanders]_.

ixfoduap · 2024-10-25T13:46:19Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+InPlace and OutPlace arithmetic operations
+------------------------------------------
+Let's begin by defining the terms "Inplace" and "Outplace" in the context of arithmetic operators. 
+Inplace operators, like the Adder and Multiplier, directly modify the original quantum state by updating a 


Adder, Multiplier, OutAdder and OutMultiplier are now operations in PL, right? We should then add a link to them

ixfoduap · 2024-10-25T13:49:03Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+  :width: 90%
+
+In quantum computing, all arithmetic operations are inherently modular. This means that the result of any 
+operation is reduced modulo :math:`\text{mod}`, where the Pennylane default is :math:`\text{mod}=2^n`, 


"reduced module mod" is unclear. I suggest to :

Say operations are modular, and add a link to wikipedia on modular arithmetic

Give a simple example, like 32 +43 = 11 mod 64

Mention that default in PL is 2^n

ixfoduap · 2024-10-25T13:50:14Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+import pennylane as qml
+
+# we indicate the name of the registers and their number of qubits
+wires = qml.registers({"x": 4, "y":4, "output":6,"work_wires": 4})


Not clear why we need work wires. Please clarify

ixfoduap

Tutorial is in much better shape now, but still needs improvements. I think my suggestions should be easy to address

ixfoduap · 2024-10-25T20:57:30Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+
+######################################################################
+# Now, we write a circuit to prepare the state :math:`|x \rangle|y \rangle|0 \rangle`, since it will be needed for the Outplace 
+# operation, where we initialize specific values to :math:`x` and :math:`y`. Note that in this example we use basic states, but


Suggested change

# operation, where we initialize specific values to :math:`x` and :math:`y`. Note that in this example we use basic states, but

# operation, where we initialize specific values to :math:`x` and :math:`y`. Note that in this example we use computational basis states, but

ixfoduap · 2024-10-25T20:59:45Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+######################################################################
+# Next, for understandability, we will use an auxiliary function that will 
+# take 1 sample from the circuit and return the associated decimal number.
+# Note that we are sampling from the circuit instead of returning the quantum state to demonstrate 


Sentence starting with "Note that we are sampling" should be first, then followed by "Next,..."

The sentence about sampling is misleading. Of course the quantum circuit produce the target output in the output state, which means a measurement is deterministic. This has nothing to do with hardware applicability. What I understand is that sampling is a trick that helps to extract the state in the output register. So please explain this better

ixfoduap · 2024-10-25T20:59:55Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+
+######################################################################
+# Next, for understandability, we will use an auxiliary function that will 
+# take 1 sample from the circuit and return the associated decimal number.


Suggested change

# take 1 sample from the circuit and return the associated decimal number.

# take one sample from the circuit and return the associated decimal number.

ixfoduap · 2024-10-26T00:59:14Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+    return sum(bit * (2 ** idx) for idx, bit in enumerate(reversed(binary_array)))
+
+######################################################################
+# In this example we are setting :math:`x=1` and :math:`y=4` and checking the results are as expected.


Suggested change

# In this example we are setting :math:`x=1` and :math:`y=4` and checking the results are as expected.

# In this example we are setting :math:`x=1` and :math:`y=4` and checking that the results are as expected.

ixfoduap · 2024-10-26T01:00:26Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+# In this example we are setting :math:`x=1` and :math:`y=4` and checking the results are as expected.
+
+output = circuit(x=1,y=4)
+print("x register: ", output[0]," which represents the number ", state_to_decimal(output[0]))


Too long! I suggest [0001] --> 1, or something similarly compact

And too long because code blocks that are to long horizontally show up in the build with a scroll bar which is ugly and annoying

ixfoduap · 2024-10-26T01:23:44Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+# Cool, we get the correct result :math:`f(1,4)=33`!
+#
+# At this point, it's interesting to consider what would happen if we had chosen a smaller number of wires for the output.
+# For instance, if we had selected one less wire for the output, we would have obtained the result :math:`33 \mod 2^5 = 1`.


Suggested change

# For instance, if we had selected one less wire for the output, we would have obtained the result :math:`33 \mod 2^5 = 1`.

# For instance, if we had selected one less wire, we would have obtained the result :math:`33 \mod 2^5 = 1`.

ixfoduap · 2024-10-26T01:26:09Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+# In the last section, we showed how to use different arithmetic operations to load 
+# a function onto a quantum computer. But what if I told you there's an easier way to do all this using just one
+# PennyLane function that handles the arithmetic for you? I'm talking about :class:`~.pennylane.OutPoly`. 
+# This handy operator lets you load polynomials directly into quantum states, taking care of all the arithmetic in one go. 
+# Let's check out how to load a function like :math:`f(x, y)` using :class:`~.pennylane.OutPoly`.


Suggested change

# In the last section, we showed how to use different arithmetic operations to load

# a function onto a quantum computer. But what if I told you there's an easier way to do all this using just one

# PennyLane function that handles the arithmetic for you? I'm talking about :class:`~.pennylane.OutPoly`.

# This handy operator lets you load polynomials directly into quantum states, taking care of all the arithmetic in one go.

# Let's check out how to load a function like :math:`f(x, y)` using :class:`~.pennylane.OutPoly`.

# There is a more direct method to apply polynomial transformations in PennyLane:

# using :class:`~.pennylane.OutPoly`.

# This operator automatically takes care of all the arithmetic under the hood.

# Let's check out how to load a function like :math:`f(x, y)` using :class:`~.pennylane.OutPoly`.

ixfoduap · 2024-10-26T01:26:59Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+   return 4 + 3*x*y + 5*x + 3*y
+
+######################################################################
+# Now, we load it into a quantum circuit.


Suggested change

# Now, we load it into a quantum circuit.

# Now, we create a quantum circuit using :class:`~.pennylane.OutPoly`.

ixfoduap · 2024-10-26T01:27:46Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+# Eureka! We've just seen how much easier it can be to implement arithmetic operations in one step. 
+# Now, it's up to you to decide, depending on the problem you are tackling, whether to go for the versatility 


Suggested change

# Eureka! We've just seen how much easier it can be to implement arithmetic operations in one step.

# Now, it's up to you to decide, depending on the problem you are tackling, whether to go for the versatility

# You can decide, depending on the problem you are tackling, whether to go for the versatility

ixfoduap · 2024-10-26T01:28:49Z

demonstrations/tutorial_how_to_use_arithmetic_operators.py

+# of quantum computing. By leveraging tools like :class:`~.pennylane.OutPoly`, you can streamline the coding of your quantum algorithms. So, 
+# whether you choose to customize your arithmetic operations or take advantage of the built-in convenience offered by PennyLane 
+# operators, you are now equipped to tackle the exciting quantum challenges ahead.


Suggested change

# of quantum computing. By leveraging tools like :class:`~.pennylane.OutPoly`, you can streamline the coding of your quantum algorithms. So,

# whether you choose to customize your arithmetic operations or take advantage of the built-in convenience offered by PennyLane

# operators, you are now equipped to tackle the exciting quantum challenges ahead.

# of quantum computing. By leveraging quantum arithmetic operations in PennyLane, you can streamline

# the coding of your quantum algorithms. So,

# whether you choose to customize your arithmetic operations or take advantage of the built-in

# convenience offered by PennyLane

# operators, you are now equipped to tackle the exciting quantum challenges ahead.

first commit howto arithmetic

d29d6d7

gmlejarza requested a review from KetpuntoG October 4, 2024 10:54

KetpuntoG reviewed Oct 4, 2024

View reviewed changes

demonstrations/tutorial_how_to_use_arithmetic_operators.py Outdated Show resolved Hide resolved

Update demonstrations/tutorial_how_to_use_arithmetic_operators.py

6e89bb1

github-actions bot deployed to preview October 4, 2024 12:55 View deployment

cleaning code

eabb5e8

github-actions bot deployed to preview October 4, 2024 19:21 View deployment

KetpuntoG reviewed Oct 4, 2024

View reviewed changes

Apply suggestions from code review

d7c6117

github-actions bot deployed to preview October 4, 2024 22:03 View deployment

suggestions from code review

464cb64

github-actions bot deployed to preview October 7, 2024 07:17 View deployment

some suggestions

56fc617

github-actions bot deployed to preview October 7, 2024 16:21 View deployment

Update tutorial_how_to_use_arithmetic_operators.py

b8997a1

github-actions bot deployed to preview October 7, 2024 17:36 View deployment

style and rendering changes

5893c0b

github-actions bot deployed to preview October 7, 2024 19:23 View deployment

typo

ca722ae

github-actions bot deployed to preview October 7, 2024 20:01 View deployment

link for OutPoly

c3fdbbc

github-actions bot deployed to preview October 9, 2024 16:01 View deployment

ixfoduap requested changes Oct 9, 2024

View reviewed changes

gmlejarza changed the title ~~[WIP] How-to: Quantum Arithmetic~~ How-to: Quantum Arithmetic Oct 10, 2024

Immediate suggestions from code review

513a1a5

Co-authored-by: ixfoduap <[email protected]>

github-actions bot deployed to preview October 10, 2024 09:27 View deployment

adressing first suggestions from code review

c8725b9

github-actions bot deployed to preview October 10, 2024 11:13 View deployment

gmlejarza added 2 commits October 14, 2024 17:39

feedback from JM

0ca2526

typo code

ddb8b06

github-actions bot deployed to preview October 14, 2024 16:47 View deployment

adding plot of Adder

ddc8a90

github-actions bot deployed to preview October 15, 2024 10:26 View deployment

fix wires for Poly

937f8a7

github-actions bot deployed to preview October 15, 2024 12:43 View deployment

modulo explanation

8aad2e2

github-actions bot deployed to preview October 15, 2024 13:51 View deployment

KetpuntoG reviewed Oct 16, 2024

View reviewed changes

gmlejarza added 2 commits October 17, 2024 12:34

suggestions from code review

a5b4540

typo work_wires

d16d951

github-actions bot deployed to preview October 17, 2024 10:56 View deployment

gmlejarza added 2 commits October 17, 2024 17:03

fixing adder with prepare state

9b8f24f

typo circuit draw

0a176f8

github-actions bot deployed to preview October 17, 2024 15:41 View deployment

KetpuntoG reviewed Oct 23, 2024

View reviewed changes

suggestions from code review

006891c

github-actions bot deployed to preview October 24, 2024 09:43 View deployment

ixfoduap reviewed Oct 25, 2024

View reviewed changes

ixfoduap requested changes Oct 26, 2024

View reviewed changes


		2. Grover's algorithm might need to use quantum arithmetic to construct oracles, as shown in [#demo_qft_arith]_.

		3. Loading functions into quantum computers, which often requires several quantum arithmetic operations.

		We can load the target function into the quantum computer using different quantum arithmetic operations.
		We will break down into pieces. We'll do a step by step load of the function :math:`f(x, y)`.


		return qml.sample(wires = wires["output"])

		print(circuit_with_Poly(x=1,y=4))


		There are two addition operators in PennyLane: the :class:`~.pennylane.Adder` and the :class:`~.pennylane.OutAdder`.

		The :class:`~.pennylane.Adder` performs an Inplace operation, adding a constant value :math:`k` to the state of the wires :math:`\|w \rangle`. It is defined as:

		operation is reduced modulo :math:mod, where the default is :math:mod=2^n, with :math:n being the number of
		qubits in the register.Quantum states can represent numbers up to this limit, which is why PennyLane uses it

		Next, we will explore how to define and implement addition and multiplication operators in PennyLane.

		Let's start by defining the Inplace and Outplace arithmetic addition operations.

		Let's see how to implement these operators in Pennylane.

		The first thing to do is to define the `registers of wires <https://pennylane.ai/qml/demos/tutorial_how_to_use_registers/>`_

		# This is possible through the :func:`~.pennylane.adjoint` operation, which allows us to reverse a multiplication or addition operation, hence enabling
		# modular division and subtraction. We will see this in action in the following section.

		# In this functions, we showed how to undo the multiplication by using the adjoint operation, which in this case is useful to clean
		# the input registers ``wires["x"]`` and ``wires["y"]`` after the operation.

	# Cool, we get the correct result 33!
	# Cool, we get the correct result :math:`f(1,4)=33`!

	x_wires = wires["x"],
	y_wires = wires["y"],
	input_registers= [wires["x"], wires["y"]],

		# adjoint function to undo certain multiplications and clean up the input registers after performing the operations.

	For instance, you can multiply two numbers on your phone in milliseconds!
	For instance, you can multiply large numbers on your phone in milliseconds!

	3. Loading functions into quantum computers often requires several quantum arithmetic operations [#sanders]_.
	3. Loading data or preparing initial states on a quantum computer often requires several quantum arithmetic operations [#sanders]_.

	# operation, where we initialize specific values to :math:`x` and :math:`y`. Note that in this example we use basic states, but
	# operation, where we initialize specific values to :math:`x` and :math:`y`. Note that in this example we use computational basis states, but

	# take 1 sample from the circuit and return the associated decimal number.
	# take one sample from the circuit and return the associated decimal number.

	# In this example we are setting :math:`x=1` and :math:`y=4` and checking the results are as expected.
	# In this example we are setting :math:`x=1` and :math:`y=4` and checking that the results are as expected.

	# For instance, if we had selected one less wire for the output, we would have obtained the result :math:`33 \mod 2^5 = 1`.
	# For instance, if we had selected one less wire, we would have obtained the result :math:`33 \mod 2^5 = 1`.

	# Now, we load it into a quantum circuit.
	# Now, we create a quantum circuit using :class:`~.pennylane.OutPoly`.

		# Eureka! We've just seen how much easier it can be to implement arithmetic operations in one step.
		# Now, it's up to you to decide, depending on the problem you are tackling, whether to go for the versatility

How-to: Quantum Arithmetic #1229

Are you sure you want to change the base?

How-to: Quantum Arithmetic #1229

Conversation

gmlejarza commented Oct 4, 2024 • edited Loading

github-actions bot commented Oct 4, 2024

github-actions bot commented Oct 4, 2024 • edited Loading

KetpuntoG left a comment

Choose a reason for hiding this comment

ixfoduap left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

KetpuntoG left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

KetpuntoG left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

ixfoduap left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

gmlejarza commented Oct 4, 2024 •

edited

Loading

github-actions bot commented Oct 4, 2024 •

edited

Loading

	# Eureka! We've just seen how much easier it can be to implement arithmetic operations in one step.
	# Now, it's up to you to decide, depending on the problem you are tackling, whether to go for the versatility
	# You can decide, depending on the problem you are tackling, whether to go for the versatility