From 9fe2910fc8c19887db1473df7c20b07c39db210a Mon Sep 17 00:00:00 2001 From: Didictateur Date: Tue, 24 Oct 2023 16:09:04 +0200 Subject: [PATCH] re-added docs --- docs/Gate.md | 172 +++++++++++++++++++++++++++++++++++++ docs/Matrix.md | 196 +++++++++++++++++++++++++++++++++++++++++++ docs/QuBit/IQuBit.md | 48 +++++++++++ docs/QuBit/MuBit.md | 63 ++++++++++++++ docs/QuBit/QuBit.md | 42 ++++++++++ 5 files changed, 521 insertions(+) create mode 100644 docs/Gate.md create mode 100644 docs/Matrix.md create mode 100644 docs/QuBit/IQuBit.md create mode 100644 docs/QuBit/MuBit.md create mode 100644 docs/QuBit/QuBit.md diff --git a/docs/Gate.md b/docs/Gate.md new file mode 100644 index 0000000..1b6d363 --- /dev/null +++ b/docs/Gate.md @@ -0,0 +1,172 @@ +# Gates + +Here is the list of all the main gates in quantum algorithm available in the library. In the following formulas, `i` represents the complex number. + +## H(q: QuBit) -> None +`Hadamard's gate`. + +- q: the qubit manipulated by the gate. This function is in-place. + +- matrix: +```math +\begin{pmatrix} +\frac {1} {\sqrt 2} & \frac {1} {\sqrt 2}\\ +\frac {1} {\sqrt 2} & -\frac {1} {\sqrt 2} +\end{pmatrix} +``` + +## X(q: QuBit) -> None +`Pauli-X gate` or `NOT gate`. Inplementes a rotation aroud the x-axis of $\pi$ radians. + +- q: the qubit manipulated by the gate. This function is in-place. + +- matrix: +```math +\begin{pmatrix} +0 & 1\\ +1 & 0 +\end{pmatrix} +``` + +## Y(q: QuBit) -> None +`Pauli-Y gate`. Inplementes a rotation aroud the y-axis of $\pi$ radians. + +- q: the qubit manipulated by the gate. This function is in-place. + +- matrix: +```math +\begin{pmatrix} +0 & -i\\ +i & 0 +\end{pmatrix} +``` + +## Z(q: QuBit) -> None +`Pauli-Z gate`. Inplementes a rotation aroud z-axis of $\pi$ radians. + +- q: the qubit manipulated by the gate. This function is in-place. + +- matrix: +```math +\begin{pmatrix} +1 & 0\\ +0 & -1 +\end{pmatrix} +``` + +## S(q: QuBit) -> None +`NOT gate`. Invert the state |0> and |1> of the QuiBit q. + +- q: the qubit manipulated by the gate. This function is in-place. + +- matrix: +```math +\begin{pmatrix} +1 & 0\\ +0 & i +\end{pmatrix} +``` + +## T(q: QuBit) -> None +`NOT gate`. Invert the state |0> and |1> of the QuiBit q. + +- q: the qubit manipulated by the gate. This function is in-place. + +- matrix: +```math +\begin{pmatrix} +1 & 0\\ +0 & e^{i\frac\pi4} +\end{pmatrix} +``` + +## Rx(q: QuBit, phi: float) -> None +`NOT gate`. Inplementes a rotation aroud x-axis of $\phi$ radians. + +- q: the qubit manipulated by the gate. This function is in-place. + +- matrix: +```math +\begin{pmatrix} +\cos(\frac\phi2) & -\sin(\frac\phi2)\\ +\sin(\frac\phi2) & \cos(\frac\phi2) +\end{pmatrix} +``` + +## Ry(q: QuBit, phi: float) -> None +`NOT gate`. Inplementes a rotation aroud y-axis of $\pi$ radians. + +- q: the qubit manipulated by the gate. This function is in-place. + +- matrix: +```math +\begin{pmatrix} +e^{-i\frac\phi2} & 0\\ +0 & e^{i\frac\phi2} +\end{pmatrix} +``` + +## R1(q: QuBit, phi: float) -> None +`NOT gate`. Invert the state |0> and |1> of the QuiBit q. + +- q: the qubit manipulated by the gate. This function is in-place. + +- matrix: +```math +\begin{pmatrix} +1 & 0\\ +0 & e^{i\frac\phi2} +\end{pmatrix} +``` + +## CNOT(q: MuBit, n1: int, n2: int) -> None +`X-controlled gate`. Invert the state |0> and |1> of the QuiBit in n2 if the state of the QuBit in n1 is 1. + +- q: the qubit manipulated by the gate. This function is in-place. +- n1: the first QuBit to manipualte. +- n2: the second QuBit to manipulate + +- matrix: +```math +\begin{pmatrix} +1 & 0 & 0 & 0\\ +0 & 1 & 0 & 0\\ +0 & 0 & 0 & 1\\ +0 & 0 & 1 & 0 +\end{pmatrix} +``` + +## SWAP(q: MuBit, n1: int, n2: int) -> None +`NOT gate`. Invert the state |0> and |1> of the QuiBit q. + +- q: the qubit manipulated by the gate. This function is in-place. +- n1: the first QuBit to manipualte. +- n2: the second QuBit to manipulate + +- matrix: +```math +\begin{pmatrix} +1 & 0 & 0 & 0\\ +0 & 0 & 1 & 0\\ +0 & 1 & 0 & 0\\ +0 & 0 & 0 & 1 +\end{pmatrix} +``` + +## Cu(q: MuBit, u: list[list[float]], n1: int, n2: int) -> None +`controlled-u gate`. Applies the gate u to the QuBit in n2 if the Qubit in n1 is 1. + +- q: the qubit manipulated by the gate. This function is in-place. +- the list respresentation of a matrix of the size 2 by 2. +- n1: the first QuBit to manipualte. +- n2: the second QuBit to manipulate + +- matrix: +```math +\begin{pmatrix} +1 & 0 & 0 & 0\\ +0 & 1 & 0 & 0\\ +0 & 0 & u_{00} & u_{01}\\ +0 & 0 & u_{10} & u_{11} +\end{pmatrix} +``` diff --git a/docs/Matrix.md b/docs/Matrix.md new file mode 100644 index 0000000..03a1d5d --- /dev/null +++ b/docs/Matrix.md @@ -0,0 +1,196 @@ +## Matrix + +Matrix(l: list[list[complexe]]) + +- l: representation of the matrix in a list + +### Attributes + +- ```__m: list[list[complexe]]``` + + the values contained in the matrix. + +- ```__size: tuple[int, int]``` + + the size of the matrix + +### Methode + +- ```__init__(l: list[list[complex]]=[]) -> None``` + + initiates the matrix + +- ```__mul__(__value: "Matrix") -> Matrix``` + + defines the natural multiplication as the Koeneger product for matrices + +- ```__apply(x: list[complex]) -> list[complex]``` + + takes a list to represent a vector in a colonne, and return the proctuct of the matrix by this vector + +- ```__str__() -> str``` + + returns a string representation of the matrix + + +### Staticmethods + +- ```I() -> Matrix``` + + returns the matrix + +```math +\begin{pmatrix} +1 & 0\\ +0 & 1 +\end{pmatrix} +``` + +- ```H() -> Matrix``` + + returns the matrix + +```math +\begin{pmatrix} +\frac {1} {\sqrt 2} & \frac {1} {\sqrt 2}\\ +\frac {1} {\sqrt 2} & -\frac{1} {\sqrt 2} +\end{pmatrix} +``` + +- ```X() -> Matrix``` + + returns the matrix + +```math +\begin{pmatrix} +0 & 1\\ +1 & 0 +\end{pmatrix} +``` + +- ```Y() -> Matrix``` + + returns the matrix + +```math +\begin{pmatrix} +0 & -i\\ +i & 0 +\end{pmatrix} +``` + +- ```Z() -> Matrix``` + + returns the matrix + +```math +\begin{pmatrix} +1 & 0\\ +0 & -1 +\end{pmatrix} +``` + +- ```S() -> Matrix``` + + returns the matrix + +```math +\begin{pmatrix} +1 & 0\\ +0 & i +\end{pmatrix} +``` + +- ```T() -> Matrix``` + + returns the matrix + +```math +\begin{pmatrix} +1 & 0\\ +0 & e^{i\frac {\pi} {4}} +\end{pmatrix} +``` + +- ```Rx(phi: float) -> Matrix``` + + returns the matrix + +```math +\begin{pmatrix} +\cos(\frac \phi 2) & -i\sin(\frac \phi 2)\\ +-i\sin(\frac \phi 2) & \cos(\frac \phi 2) +\end{pmatrix} +``` + +- ```Ry(phi: float) -> Matrix``` + + returns the matrix + +```math +\begin{pmatrix} +\cos(\frac \phi 2) & -\sin(\frac \phi 2)\\ +\sin(\frac \phi 2) & \cos(\frac \phi 2) +\end{pmatrix} +``` + +- ```Rz(phi: float) -> Matrix``` + + returns the matrix + +```math +\begin{pmatrix} +e^{-i\frac \phi 2} & 0\\ +0 & e^{i\frac \phi 2} +\end{pmatrix} +``` + +- ```R1(phi: float) -> Matrix``` + + returns the matrix + +```math +\begin{pmatrix} +1 & p\\ +0 & e^{i\phi} +\end{pmatrix} +``` + +- ```CNOT() -> Matrix``` + + returns the matrix + +```math +\begin{pmatrix} +1 & 0 & 0 & 0\\ +0 & 1 & 0 & 0\\ +0 & 0 & 0 & 1\\ +0 & 0 & 1 & 0 +\end{pmatrix} +``` + +- ```SWAP() -> Matrix``` + + returns the matrix + +```math +\begin{pmatrix} +1 & 0 & 0 & 0\\ +0 & 0 & 1 & 0\\ +0 & 1 & 0 & 0\\ +0 & 0 & 0 & 0 +\end{pmatrix} +``` + +- ```Cu(u: Matrix) -> Matrix``` + + returns the matrix + +```math +\begin{pmatrix} +1 & 0 & 0 & 0\\ +0 & 1 & 0 & 0\\ +0 & 0 & u_{00} & u_{01}\\ +0 & 0 & u_{10} & u_{11} +\end{pmatrix} +``` diff --git a/docs/QuBit/IQuBit.md b/docs/QuBit/IQuBit.md new file mode 100644 index 0000000..41304db --- /dev/null +++ b/docs/QuBit/IQuBit.md @@ -0,0 +1,48 @@ +## IQuBit + +IQuBit(n: int, mb: MuBit) + +IQuBit(QuBit) + +- n: the position of the QuBit in the list of intricated QuBits +- mb: the MuBit which organises the intricated QuBit + +### Attributes + +- ```__n: int``` + + the position of the QuBit in the list of intricated QuBits + +- ```__Mubit: MuBit``` + the MuBit which organises the intricated QuBit + +- ```__intricated: bool``` + + tells if the QuBit is intricated or not + + +### Methode + +- ```__init__(n: int, mb: MuBit) -> None``` + + initiates the qubit + +- ```is_intricated() -> bool``` + + returns the value of __intricated + +- ```get_MuBit() -> MuBit``` + + returns the MuBit in wich the QuBit is intricated. + +- ```__str__() -> str``` + + returns a string representation of the list of __state + +- ```__apply(m: Matrix) -> None``` + + takes a Matrix and modifies the QuBit according the matrix + +- ```observe() -> list[int]``` + + forces the QuBit in a state, where the probabilities are given throught __state. Returns the new __state obtained. diff --git a/docs/QuBit/MuBit.md b/docs/QuBit/MuBit.md new file mode 100644 index 0000000..a22a68c --- /dev/null +++ b/docs/QuBit/MuBit.md @@ -0,0 +1,63 @@ +## MuBit + +MuBit(n: int) + +- n: number of intricated QuBits + +### Attributes + +- ```__n: int``` + + the number of intricated QuBits represented by this MuBit + +- ```__state: list[complexe]``` + + list of the values for the state |0...0>, |0...01>, |0...010>, |0...011> etc... + +### Methode + +- ```__init__(n: int=2) -> None``` + + initiates the mubit with n QuBits. + +- ```get_size() -> int``` + + return __n + +- ```__str__() -> str``` + + returns a string representation of the list of __state. Each state is named and draw in a new line. + +- ```__set(i: int, value: int)``` + + force the i-th QuBit of the MuBit to take the state value. Value must be 0 or 1. + +- ```__iter__() -> Iterator[IQuBit]``` + + creates an interator of __state. + +- ```__getitem__(item: int) -> IQubIt``` + + creates an intricated QuBit corresponding to the item-th QuBit. + +- ```__apply(m: Matrix) -> None``` + + takes a Matrix and modifies the QuBits according the matrix. + +- ```__mapply(m: Matrix, i: int) -> None``` + + takes a Matrix and modifies the i-th QuBit according the matrix. + +- ```__getProbs(i: int) -> float``` + + returns the probability to get the i-th QuBit in the state |0>. + +- ```observe() -> list[int]``` + + forces the QuBits in a state, where the probabilities are given throught __state. Returns the list of the state of each QuBit. + +### Staticmethods + +- ```intricateThem(*args: QuBit) -> MuBit``` + + returns a new QuBit, independent of the args, but corresponding to the intrication of all given QuBits \ No newline at end of file diff --git a/docs/QuBit/QuBit.md b/docs/QuBit/QuBit.md new file mode 100644 index 0000000..f972fae --- /dev/null +++ b/docs/QuBit/QuBit.md @@ -0,0 +1,42 @@ +## QuBit + +QuBit(alpha: complexe, beta: complexe) + +- alpha: complexe value for |0> +- beta: complexe value for |1> + +### Attributes + +- ```__state: list[complexe]``` + + list of the values for the state |0> and |1> + +- ```__intricated: bool``` + + tells if the qubit is intricated or not + +### Methode + +- ```__init__(alpha: complexe=1, beta: complexe=0) -> None``` + + initiates the qubit + +- ```is_intricated() -> bool``` + + returns the value of __intricated + +- ```get_MuBit() -> None``` + + returns the MuBit in wich the QuBit is intricated. If not intricated, rerurns None + +- ```__str__() -> str``` + + returns a string representation of the list of __state + +- ```__apply(m: Matrix) -> None``` + + takes a Matrix and modifies the QuBit according the matrix + +- ```observe() -> list[int]``` + + forces the QuBit in a state, where the probabilities are given throught __state. Returns the state obtained.