Working_Circuits

 Sharma Lesson 12 provides an overview of what an actual quantum circuit

on-the-job does. The first example is the teleportation circuit, which I have looked at

before.

It is essential that there be classical computation involved to feed the circuit and 

evaluate the results. The above diagram sows three qubits and two classical bits. 

Measurement is a classical operation!!

                                                                       

This second diagram shows how the results, once measured, are used to decide on what to feed

the circuit next.

Next lesson will be an algorithm 😺

                                                                           *     *     *

The Debate

 I actually missed the American Presidential debate, slept through the whole thing.

I am no longer young, and like to crawl in be with a bowl of fruit salad and a game of

Scrabble some time after 8. Long story short, this is how I learned about it. I admit it:

found that account of things at times amusing, as well as sad:

                                                        *     *     *

Sharma 11 deals with a minor problem in quantum computing, but one that needs 

to be addressed witout fail: taking out the garbage. An oracle is a bit of classical

computing that is assigned to a quantum computer in the context of a larger problem.

In classical computing, te garbage from a computation ie intermediate steps, is removed

easily enough. Not so in the context of quantum computing. There has to be an

explicit element within a register. Below: the input is conserved, the garbage gets

nullified...

                                        

We should see tis in action when we deal with algorithms.

Precision

 In the case of non_pauli gates, the exponentials do not commute:

                                               

                                                              

Gemini's explanation:

srix (a key element in quantum computing) using non-Pauli gates. Let's break it down:

 

The Problem:

* You're trying to create a unitary matrix U that represents a quantum operation.

* Unitary matrices are essential in quantum computing because they preserve the probabilities of quantum states.

* Pauli gates are a fundamental set of gates in quantum computing, but you're looking at a method that doesn't rely solely on them.

The Solution:

* The core idea is to approximate the desired unitary matrix using a series of exponentials of non-Pauli gates.

* **Exponentiation:** In quantum mechanics, the exponential of a Hamiltonian (which describes the energy of a system) is used to evolve a quantum state over time.  Here, we're using exponentials of non-Pauli gates to create a desired evolution.

* **Slices:** The method divides the desired evolution into "slices" of smaller steps. The approximation gets better as the number of slices increases.

* **Approximation:** For each slice, the exponential of the non-Pauli gate is approximated as if the gate's effect were spread out over the slice.

* **Limit:** As the number of slices (n) approaches infinity, the approximation gets arbitrarily close to the actual unitary matrix U.

Why This Matters:

* **Flexibility:** This method allows you to build complex unitary matrices using a wider range of gates than just Pauli gates.

* **Efficiency:** While the approximation with a finite number of slices introduces some error, this error can be controlled by increasing the number of slices. This can be a more efficient way to implement certain quantum operations than using only Pauli gates.

Example:

Imagine you want to create a unitary matrix U that rotates a qubit by a certain angle.  You could break this rotation into many smaller rotations, each represented by an exponential of a non-Pauli gate. As you increase the number of these small rotations, you get closer and closer to the desired overall rotation.

**Important Note:** This method is a powerful tool, but it's essential to understand the limitations of the approximation and how to control the error.  

Let me know if you'd like me to elaborate on any specific part of this explanation! 

 

Phase

 Trying to see how phase differences influence things:

https://www.getmerlin.in/fr/share/chat/e1pdYNlMWfc

  Using the S-gate to navavigate between the x and y axis:                                                                               

                                                                                        

Creating stable clone qubits:

                                                                                  

Propagating a phase shift:

The Cliffords

 In quantum computing, the so-called Clifford gates are the hard workers, transforming

gates into other gates.

These are : the Hadamard, the phase S, and the CNOT. Only the Hadamard is hermitian.

The Hadamard as an outer product:

                                                             

The Hadamard snadwiching a Pauli gate. Here it transforms an X-gate into a z-gate;

 and a z-gate into an X-gate.

                                                                      

https://www.perplexity.ai/search/Quantum-computing-how-RNsm9Kd9QDuPZc2P5nRNsw

                                                                                 

                                                      

Error Correction

 Getting ahead of myself; a peek at error correction:

https://www.cl.cam.ac.uk/teaching/1920/QuantComp/Quantum_Computing_Lecture_13.pdf

Everything is as expected:                                                                        

Qubit 1 has flipped:

Qubit 2 has flipped:

Qubit 3 has flipped:

                                                                                                   ... and so forth

Bottom line: the outcomes are different than expected when a flip has occured!!

Correcting this will require delving into Shor's code, to be seen later in this series.

Clifford Gates

                                                                    

                                                                            *     *     *

Turns out it makes no difference if the identity gated  is placebefore or after our 

chosen gates.

As well, the CNOT is Hermitian so that CNOT† is the same as CNOT.

                                                                   

https://www.perplexity.ai/search/Quantum-cmputing-why-DrwtTBVPT4K86Rsy8sYthA

Yaow

 Researchers in Japan have found a way to make teeth grow

back in adultood. 

Faire repousser les dents: un traitement révolutionnaire (msn.com)

                                                           *     *     *

Happy Fête Nationale to All!

Continuation

 Continuing...

Sill using my initial outer-product matrices:

                                                                         

                                                                                     

Conjugation:

Conjugation on a rotational gate (non-Hermitian). Allows one to change the axis 

of rotation:

                                                                        

                                                                                

Universality

 Still in Sharma 10.

Constructed some gates for myself:

                                                                   

Tested them 1...2 on off, excited, and superposition. The results:

One can also think in terms of moving between Pauli gates:

In effect, one can express any one qubit matrix in term of Pauli matrices.

We can also capture any multiqublit matrix as tensor products...

                                                                           

ConversationM

 Still at it!!

https://www.getmerlin.in/fr/share/chat/EM8WHWCbgx2

I was approaching the issue of projection gates all wrong. One does not add

standard gates to them; one adds them to standard gates. They serve to isolate

certain behaviors in the context of a larger algorithm. 

Below, I have created custom gates from these matrices, the first case: applied to

excited state. Second case, applied to a Hadamard superimposed situation.

                                                           

The people have spoken. Regardless what the music industry might be trying to promote,

the hit of summer 24 has been found. Below:

                                       

M_Learn

 Reading through Microsoft Learn on Linear Algebra for Quantum, last night.

Made it clear to me that a two-qubit measurement involves going to a Tensor

Product:

Linear Algebra for Quantum Computing - Azure Quantum | Microsoft Learn

                                                      *     *     *

It's summer in North America:

                                                           *     *     *

https://www.getmerlin.in/fr/share/chat/S_8YjtTfnak

From Meta:

Yes, that's correct! |0><0| and |1><1| are indeed projection operators in quantum computing.

|0><0| is the projection operator onto the state |0, and |1><1| is the projection operator onto the state |1.

In general, |φ><φ| is a projection operator onto the state |φ, where |φis an arbitrary quantum state.

Well done! You're showing off your quantum computing knowledge!

Here's a brief explanation of projection operators in quantum computing:

Projection operators are used to project a quantum state onto a specific basis state. They are denoted as |φ><φ|, where |φis the basis state. The projection operator |φ><φ| maps any quantum state to the component of that state along |φ.

In the case of qubits (two-level quantum systems), the projection operators |0><0| and |1><1| are particularly important, as they correspond to the two possible measurement outcomes of a qubit.

Let me know if you have more questions or if there's anything else I can help with!

Momentous

 

*     *     *

It's been a day: 32C next to a fan, and Eigenvectors.

https://www.mathsisfun.com/algebra/eigenvalue.html

Just solved problem 1 on the exercises:

                                                                         

Finding the eigenvalue:

                                                                        

                                                                                 

                                                                                

These are the two possible values of the eigenvalue.

For the eigen vector (with respect to x):

                                                                           

Hot_Day

 The math inSharma lesson 10 is not for the faint-hearted. A little help from Perplexity:

https://www.perplexity.ai/search/Quantum-computing-could-X5Z0Zfn_QnqiqX2gPrwN6g

                                                                   

*     *     *

Hermitian and unitary are different things:

A Unitary matrix has a determinant of 1.

A Hermitian matrix has a complex conjugate (or inverse) equal to the original matrix:

*     *     *

A helpful module: https://www.gopalancolleges.com/gcem/pdf/syllabus/physics/cse/module-3-quantum-computing-quantum-gates.pdf