~gdanix/Trabajo_Computacion_Cuantica

3f823b65437be6a36981bed8fdb563608e457e70 — Daniel Trujillo Viedma 7 months ago dabced5 master
Final version
A Alice.png => Alice.png +0 -0
A Bob.png => Bob.png +0 -0
A Int1.dia => Int1.dia +0 -0
A Int1.png => Int1.png +0 -0
A Int2.dia => Int2.dia +0 -0
A Int2.png => Int2.png +0 -0
A Int3.dia => Int3.dia +0 -0
A Int3.png => Int3.png +0 -0
A Int4.dia => Int4.dia +0 -0
A Int4.png => Int4.png +0 -0
A Int5.dia => Int5.dia +0 -0
A Int5.png => Int5.png +0 -0
A Persona.dia => Persona.dia +0 -0
R Trabajo.org => Planning.org +0 -0
A Presentación.org => Presentación.org +592 -0
@@ 0,0 1,592 @@
#+TITLE: Teleportación de Estados Cuánticos
#+AUTHOR: Daniela Ferreiro, Adrián Enríquez y Daniel Trujillo
#+LANGUAGE: es
#+OPTIONS: H:2 toc:t num:t
#+LATEX_CLASS: beamer
#+LATEX_CLASS_OPTIONS: [presentation]
#+LaTeX_HEADER: \usepackage{braket, mathtools, amsfonts, bbold}
#+LaTeX_HEADER: \usepackage[AUTO]{babel}
#+BEAMER_THEME: Ilmenau
#+COLUMNS: %45ITEM %10BEAMER_ENV(Env) %10BEAMER_ACT(Act) %4BEAMER_COL(Col)

* Introducción
    
** Introducción
   
*** Algoritmo de teleportación
    
    Transmitir el estado cuántico de una partícula a otra no conectadas causalmente

*** Requisitos

    * Canal de comunicación clásico
    * 1 circuito cuántico para Alice, otro para Bob
    * Compartir partículas cuánticas entrelazadas

** Descripción intuitiva

*** A block
    :PROPERTIES:
    :BEAMER_COL: 0.6
    :END:
    * Alice y Bob comparten 2 partículas entrelazadas

*** An image
    :PROPERTIES:
    :BEAMER_COL: 0.4
    :END:
    #+ATTR_LaTeX: :width 60px
    [[./Int1.png]]

** Descripción intuitiva

*** A block
    :PROPERTIES:
    :BEAMER_COL: 0.6
    :END:
    * Alice y Bob comparten 2 partículas entrelazadas
    * Alice recibe una partícula de estado desconocido

*** An image
    :PROPERTIES:
    :BEAMER_COL: 0.4
    :END:
    #+ATTR_LaTeX: :width 60px
    [[./Int2.png]]

** Descripción intuitiva

*** A block
    :PROPERTIES:
    :BEAMER_COL: 0.6
    :END:
    * Alice y Bob comparten 2 partículas entrelazadas
    * Alice recibe una partícula de estado desconocido
    * Alice opera con sus partículas

*** An image
    :PROPERTIES:
    :BEAMER_COL: 0.4
    :END:
    #+ATTR_LaTeX: :width 60px
    [[./Int3.png]]

** Descripción intuitiva

*** A block
    :PROPERTIES:
    :BEAMER_COL: 0.6
    :END:
    * Alice y Bob comparten 2 partículas entrelazadas
    * Alice recibe una partícula de estado desconocido
    * Alice opera con sus partículas
    * Alice mide sus partículas en la base $\ket{0}$, $\ket{1}$, y envía a Bob los resultados

*** An image
    :PROPERTIES:
    :BEAMER_COL: 0.4
    :END:
    #+ATTR_LaTeX: :width 60px
    [[./Int4.png]]

** Descripción intuitiva

*** A block
    :PROPERTIES:
    :BEAMER_COL: 0.6
    :END:
    * Alice y Bob comparten 2 partículas entrelazadas
    * Alice recibe una partícula de estado desconocido
    * Alice opera con sus partículas
    * Alice mide sus partículas en la base $\ket{0}$, $\ket{1}$, y envía a Bob los resultados
    * Bob realiza una operación de corrección

*** An image
    :PROPERTIES:
    :BEAMER_COL: 0.4
    :END:
    #+ATTR_LaTeX: :width 60px
    [[./Int5.png]]


** Pares EPR
\rightline{\tiny [Marage et al., 1999]}
*** 192x
    * Desarrollo de la formulación matemática
    * Teoría de Variables Ocultas 

*** 193x
    * EPR: Paradoja, entrelazamiento
    * Schrödinger, von Neumann

*** 1964
    Test de Bell

** Pares EPR

*** Término /Entrelazamiento/
    [[./scholar.png]]

* Descripción formal

** Circuito

   [[./circuito.png]]
   
** Eficiencia

   * El algoritmo solo tiene un estado cuántico (desconocido) de entrada
   * El circuito no varía con la entrada
   * El número de puertas es el mismo, finito
   * Trivialmente eficiente
   
** Formulación matemática
\vspace{-5px}
\rightline{\tiny [Nielsen et al., 2002], [Bennet et al., 1993]}
*** Inicialización: estado de Bell
    $\ket{\phi{}^{(+)}} = \ket{\beta_{00}} = \frac{1}{\sqrt{2}}(\ket{0_{A}} \ket{0_{B}} + \ket{1_{A}}\ket{1_{B}})$

*** Estado a teletransportar
    $\ket{\psi{}} = \alpha{}\ket{0} + \beta{}\ket{1}$

*** Sistema
    \vspace{-15px}
    \begin{align*}
    \ket{\psi{}_0} &= \ket{\psi{}} \otimes{} \ket{\beta_{00}} \\
    &= (\alpha \ket{0} + \beta \ket{1})(\frac{1}{\sqrt{2}}(\ket{0_{A}} \ket{0_{B}} + \ket{1_{A}} \ket{1_{B}})) \\
    &= \frac{1}{\sqrt{2}{}}(\alpha \ket{000} + \alpha \ket{011} + \beta \ket{100} + \beta \ket{111})
    \end{align*}

** Formulación matemática

*** Alice: primer paso, CNOT
    \begin{align*}
    \ket{\psi_1} 
    &= \Big(\mathcal{U} _\text{CNOT}
      \otimes \mathbb{1}
      \Big)\ket{\psi_0} \\ 
    &= \frac{1}{\sqrt{2}}\Big(
      \alpha \ket{000} + \alpha \ket{011} + \beta \ket{110} + \beta \ket{101}
      \Big)
    \end{align*}

** Formulación matemática    

*** Alice: segundo paso, Hadamard
    \vspace{-10px}
    \begin{small}
    \begin{align*}
    \ket{\psi_2} 
    &= \Big(H \otimes \mathbb{1} \otimes \mathbb{1}\Big)\ket{\psi_1} \\ 
    &= \frac{1}{\sqrt{2}}\Big(\alpha\;(\frac{\ket{0} + \ket{1}}{\sqrt{2}}) \otimes\ket{00} 
    + \alpha\;(\frac{\ket{0} + \ket{1}}{\sqrt{2}}) \otimes\ket{11} \\ 
    &\;\;\;\; + \beta\;(\frac{\ket{0} - \ket{1}}{\sqrt{2}}) \otimes\ket{10} 
    + \beta\;(\frac{\ket{0} - \ket{1}}{\sqrt{2}}) \otimes\ket{01}\Big) \\ 
    &= \frac{1}{2}\Big(\alpha \ket{000} + \alpha \ket{100} + \alpha \ket{011} + \alpha \ket{111} \\
    &\;\;\;\; + \beta \ket{010} - \beta \ket{110} + \beta \ket{001} - \beta \ket{101}\Big) \\
    &= \frac{1}{2}\Big(\ket{00}(\alpha\,\ket{0} + \beta\,\ket{1}) + \ket{01}(\alpha\,\ket{1} + \beta\,\ket{0})\\
    &\;\;\;\; + \ket{10} (\alpha\,\ket{0} - \beta\,\ket{1})  + \ket{11} (\alpha\,\ket{1} - \beta\, \ket{0})\Big) \\
    \end{align*}
    \end{small}

** Formulación matemática    

*** Alice: tercer paso, medir
    \vspace{-15px}
    \begin{small}
    \begin{align*}
      P(00)
    &= \bra{\psi_2}\; (\ket{0}\hspace{-4pt}\bra{0} \otimes \mathbb{1} ) \;\ket{\psi_2} \\
    &= \frac{1}{2}\Big(\bra{00} (\alpha\, \bra{0} + \beta\, \bra{1}) + \bra{01}(\alpha\,\bra{1} + \beta\,\bra{0}) \\
    &\;\;\;\;\;\;\;\;+ \bra{10} (\alpha\,\bra{0} - \beta\,\bra{1}) + \bra{11} (\alpha\,\bra{1} - \beta\, \bra{0})\Big) \\ 
    &\;\;\;\;\cdot(\ket{0}\hspace{-4pt}\bra{0} \otimes \mathbb{1}) \\
    &\;\;\;\;\cdot\frac{1}{2}\Big(\ket{00}(\alpha\,\ket{0} + \beta\,\ket{1}) + \ket{01}(\alpha\,\ket{1} + \beta\,\ket{0}) \\
    &\;\;\;\;\;\;\;\;+\ket{10} (\alpha\,\ket{0} - \beta\,\ket{1}) + \ket{11} (\alpha\,\ket{1} - \beta\, \ket{0})\Big) \\
    &= \frac{1}{4}\Big[\Big(\braket{00|0}\hspace{-4pt}\braket{0|00} \otimes (\alpha\, \bra{0} + \beta\, \bra{1}) \mathbb{1}(\alpha\,\ket{0} + \beta\,\ket{1})\Big)\Big] \\
    &= \frac{1}{4}
    \end{align*}
    \end{small}


** Formulación matemática    

*** Alice: tercer paso, medir
    \begin{align*}
    \ket{\psi_3^{00}} &= \frac{1/2}{\sqrt{1/4}}\Big(\ket{0}\hspace{-4pt}\bra{0}\otimes \mathbb{1}\Big)\ket{\psi_2} \\ 
    &= \ket{00}(\alpha\,\ket{0} + \beta\,\ket{1}) 
    \end{align*}
    

** Formulación matemática    

*** Alice: tercer paso, medir
    $$P(01)= \frac{1}{4}$$
    \begin{align*}
    \ket{\psi_3^{01}} &= \frac{1/2}{\sqrt{1/4}}\Big(\ket{0}\hspace{-4pt}\bra{0}\otimes \mathbb{1}\Big)\ket{\psi_2} \\ 
    &= \ket{01}(\alpha\,\ket{1} + \beta\,\ket{0}) 
    \end{align*}

** Formulación matemática    

*** Alice: tercer paso, medir
    $$P(10)= \frac{1}{4}$$
    \begin{align*}
    \ket{\psi_3^{10}} &= \frac{1/2}{\sqrt{1/4}}\Big(\ket{0}\hspace{-4pt}\bra{0}\otimes \mathbb{1}\Big)\ket{\psi_2} \\ 
    &= \ket{10}(\alpha\,\ket{0} - \beta\,\ket{1}) 
    \end{align*}

** Formulación matemática    

*** Alice: tercer paso, medir
    $$P(11)= \frac{1}{4}$$
    \begin{align*}
    \ket{\psi_3^{01}} &= \frac{1/2}{\sqrt{1/4}}\Big(\ket{0}\hspace{-4pt}\bra{0}\otimes \mathbb{1}\Big)\ket{\psi_2} \\ 
    &= \ket{11}(\alpha\,\ket{1} - \beta\,\ket{0}) 
    \end{align*}
    
** ¿Comunicación instantánea?

*** El qubit de Bob
    Suponiendo que se quiere transmitir $\alpha{}\ket{0}+\beta{}\ket{1}$, la partícula de Bob puede tener uno de estos estados tras medir Alice:
    * $\alpha{}\ket{0}+\beta{}\ket{1}$
    * $\alpha{}\ket{1}+\beta{}\ket{0}$
    * $\alpha{}\ket{0}-\beta{}\ket{1}$
    * $\alpha{}\ket{1}-\beta{}\ket{0}$

*** Idea
    Bob tendrá el qubit correcto con probabilidad $\frac{1}{4}$. ¿Puede conocer casi instantáneamente información acerca del estado?

** ¿Comunicación instantánea?

*** Bob mide
    * Si Bob midiera antes de que la la información de Alice llegue a Bob, tendría:
    $$P(0) = \frac{1}{4}|\alpha|^2 + \frac{1}{4}|\beta|^2 + \frac{1}{4}|\alpha|^2 + \frac{1}{4}|\beta|^2 = \frac{1}{2}(|\alpha|^2 + |\beta|^2) = \frac{1}{2}$$
    $$P(1) = \frac{1}{4}|\beta|^2 + \frac{1}{4}|\alpha|^2 + \frac{1}{4}|\beta|^2 + \frac{1}{4}|\alpha|^2 = \frac{1}{2}(|\beta|^2 + |\alpha|^2) = \frac{1}{2}$$
    * Información aleatoria, independiente de $\alpha{}$ y $\beta{}$.
    
** Extensión a entrada de partículas entrelazadas

*** Estado inicial
    \begin{align*}
    \ket{\beta_{00}} &= \frac{1}{\sqrt{2}}(\ket{00} + \ket{11}) \\
    \ket{\beta_{01}} &= \frac{1}{\sqrt{2}}(\ket{01} + \ket{10}) \\
    \end{align*}
    \vspace{-30px}
    \begin{align*}
    \ket{\psi_0} &= \ket{\beta_{01}} \otimes \ket{\beta_{00}} \\ 
    &= \frac{1}{2}\Big(\ket{0100} + \ket{0111} - \ket{1000} - \ket{1011}\Big)
    \end{align*}

** Extensión a entrada de partículas entrelazadas

*** Alice: primer paso, CNOT
    \begin{align*}
    \ket{\psi_1} 
        &= \Big(
          \mathbb{1} 
          \otimes \mathcal{U} _\text{CNOT}
          \otimes \mathbb{1}
          \Big)\ket{\psi_0} \\ 
        &= \frac{1}{2}\Big(
          \ket{0110} + \ket{0101} - \ket{1000} - \ket{1011}
        \Big)
    \end{align*}

    
** Extensión a entrada de partículas entrelazadas

*** Alice: segundo paso, Hadamard
    \begin{align*}
    \ket{\psi_2} 
        &= \Big(
          \mathbb{1}
          \otimes H
          \otimes \mathbb{1}
          \otimes \mathbb{1}
          \Big)\ket{\psi_1} \\ 
        &= \frac{1}{2}\Big(
          \ket{0110} 
          + \ket{0101} 
          - \ket{1000} 
          - \ket{1011}
        \Big) \\ 
        &= \frac{1}{2}\Big(
          \ket{0} \otimes \frac{1}{\sqrt{2}}(
            \ket{0} - \ket{1}
          ) \otimes\ket{10} 
          + \ket{0} \otimes \frac{1}{\sqrt{2}}(
            \ket{0} - \ket{1}
          ) \otimes\ket{01} \\ 
          &\;\;\;\;- \ket{1} \otimes \frac{1}{\sqrt{2}}(
            \ket{0} + \ket{1}
          ) \otimes\ket{00} 
          - \ket{1} \otimes \frac{1}{\sqrt{2}}(
            \ket{0} + \ket{1}
          ) \otimes \ket{11}
        \Big) \\ 
        &= \frac{1}{2\sqrt{2}}\Big(
          \ket{0010} - \ket{0110} + \ket{0001} 
          - \ket{0101} \\ 
        &\;\;\;\; - \ket{1000} - \ket{1100} 
          - \ket{1011} - \ket{1111}
        \Big)
    \end{align*}

   
** Extensión a entrada de partículas entrelazadas

*** Alice: tercer paso, medir
    * Como sucede siempre en este protocolo, al medir, cada posible salida es equiprobable, con probabilidad $\frac{1}{4}$
    * Por ejemplo, si Alice midiese 00:
    \begin{align*}
     \ket{\psi_3^{00}} 
        &= \frac{1/(2\sqrt{2})}{\sqrt{1/4}}\Big(
          \mathbb{1}
          \otimes \ket{0}\hspace{-4pt}\bra{0}
          \otimes \mathbb{1}
          \Big)\ket{\psi_2} \\ 
        &= \frac{1}{\sqrt{2}}\Big(
          \ket{0001} 
          - \ket{1000} 
        \Big) \\ 
        &= \ket{00}_{23}\otimes\ket{\beta_{01}}_{14}
    \end{align*}

** Extensión a entrada de partículas entrelazadas

*** Alice: tercer paso, medir
    Si Alice midiese otra salida, Bob tendría que aplicar una corrección. Por ejemplo, si Alice midiese 01:
    \begin{align*}
    \ket{\psi_3^{01}} 
        &= \frac{1/(2\sqrt{2})}{\sqrt{1/4}}\Big(
          \mathbb{1}
          \otimes \ket{0}\hspace{-4pt}\bra{1}
          \otimes \mathbb{1}
          \Big)\ket{\psi_2} \\ 
        &= \frac{1}{\sqrt{2}}\Big(
          \ket{0010} 
          - \ket{1011} 
        \Big) \\ 
    \end{align*}

** Extensión a entrada de partículas entrelazadas

*** Bob: cuarto paso, corregir
    Y Bob corregiría:
    \begin{align*}
    \ket{\psi_4^{01}} 
        &= \Big(\mathbb{1} \otimes \mathbb{1} \otimes \mathbb{1} \otimes X \Big)\ket{\psi_3^{01}} \\ 
        &= \frac{1}{\sqrt{2}}\Big(\ket{0011} - \ket{1010}\Big) \\
        &= \ket{01}_{23}\otimes\ket{\beta_{01}}_{14}
    \end{align*}

* En la práctica

** Implementación

*** Protocolo
    #+BEGIN_SRC haskell
-- | Example circuit of the protocol for
-- teleporting a given qubit.
protocol :: Qubit -> Circ ((Bit, Bit), Qubit)
protocol a = do
  (b1, b2) <- qc_init (False, False) >>= bell
  teleport ((a, b1), b2)
  #+END_SRC

*** Estados de Bell
    #+BEGIN_SRC haskell
-- | Circuit for building Bell states.
bell :: (Qubit, Qubit) -> Circ (Qubit, Qubit)
bell (x, y) = hadamard x >>= controlled_not y
    #+END_SRC

** Implementación

*** Teleportación
   #+BEGIN_SRC haskell
-- | Quantum state teleportation circuit.
teleport :: ((Qubit, Qubit), Qubit) -> 
  Circ ((Bit, Bit), Qubit)  
teleport ((a, b1), b2) = do
  -- Alice operates with her qubits
  controlled_not_at b1 a
  hadamard_at a
  -- She measures them and
  -- sends the results to Bob
  (m1, m2) <- measure (a, b1)
   #+END_SRC

** Implementación
   
*** Teleportación (cont.)
   #+BEGIN_SRC haskell
  -- Bob operates with his qubit according
  -- to the received information
  gate_X_at b2 `controlled` m2
  gate_Z_at b2 `controlled` m1
  -- Bob's qubit should now be in the state
  --  that the first one of Alice was
  pure ((m1, m2), b2)
   #+END_SRC

** Implementación

*** Repositorio
    #+BEGIN_SRC sh
    https://github.com/adrianen-ucm/teleport-demo
    #+END_SRC

*** Dependencias
    * Quipper: 0.9.0.0
    * GHC: 8.8.4
    
*** Utilidades: Simulación, distribuciones de probabilidad
    #+BEGIN_SRC sh
    cabal run [probability|simulation] [0|1|+|-]
    #+END_SRC

*** Dibujar circuito
    #+BEGIN_SRC sh
    cabal run -v0 pdf > circuit.pdf
    #+END_SRC      
    
** Experimentación
\rightline{\tiny [Pirandola et al., 2015]}
*** Primera verificación experimental
    \rightline{\tiny [Bouwmeester et al., 1997]}
    * D. Bouwmeester, J. W. Pan, K. Mattle et al.
    * Innsbruck, Austria
    * Polarización de fotones, 25% Bell-eficiencia

*** Larga distancia
    \rightline{\tiny [Ma et al., 2012]}
    * X. S. Ma, T. Herbst, T. Scheidl et al.
    * Canarias, España
    * Polarización de fotones, 50% Bell-eficiencia

** Experimentación
\rightline{\tiny [Pirandola et al., 2015]}
*** Resonancia magnética nuclear
    \rightline{\tiny [Nielsen et al., 1998]}
    * M. A. Nielsen, E. Knill, R. Laflamme
    * USA
    * Espines nucleares, distancias intra-núcleo

*** Iones atrapados
    \rightline{\tiny [Barret et al., 2004]}
    * M. D. Barrett, J. Chiaverini et al.
    * USA
    * Experimento completo, distancias de micrómetros

** Experimentación

    #+ATTR_LaTeX: :width 250px
    [[./holanda2.jpg]]

** Experimentación
   
*** Red cuántica de UT-Delft
    :PROPERTIES:
    :BEAMER_env: block
    :BEAMER_col: 0.5
    :END:
    * Grupo de investigación QuTech
    * Pioneros en entrelazamiento cuántico a larga distancia
    * Desarrollo muy rápido de una red de comunicación cuántica que preserva entrelazamientos

*** Esquema
    :PROPERTIES:
    :BEAMER_col: 0.5
    :END:
    \rightline{\tiny [Pompili et al., 2021]}
    [[./holanda1.jpg]]

** Experimento propio

   [[./ibmqe/circuit-one-qubit.png]]

** Experimento propio

   [[./ibmqe/1-circuit-one-qubit.png]]

   [[./ibmqe/Pr-1-circuit-one-qubit.png]]

** Experimento propio

   [[./ibmqe/2-circuit-one-qubit.png]]

   [[./ibmqe/Pr-2-circuit-one-qubit.png]]

** Experimento propio

   [[./ibmqe/3-circuit-one-qubit.png]]

   [[./ibmqe/Pr-3-circuit-one-qubit.png]]

** Experimento propio

   [[./ibmqe/4-circuit-one-qubit.png]]

   [[./ibmqe/Pr-4-circuit-one-qubit.png]]


** Experimento propio

   [[./ibmqe/circuit-entangled-states.png]]

   [[./ibmqe/Pr-circuit-entangled-qubits.png]]

   

* Conclusiones

** Conclusiones

*** Simple (en teoría)
    Un algoritmo muy simple, que involucra muchos conceptos de la computación cuántica: entrelazamiento, superposición, puertas, circuitos, parte clásica, teorema de no-clonación...

*** Útil
    Sirve para, por ejemplo, transmitir partículas a grandes distancias, conectando líneas de transmisión más pequeñas para minimizar pérdida de partículas, y preservando entrelazamientos de la entrada.

*** Física experimental
    Constatación de los retos de la física experimental en este campo.
  
* Apéndice

** Apéndice: Referencias completas

*** [Marage et al., 1999]
    Marage, P., & Wallenborn, G. (1999). The Debate between Einstein and Bohr, or How to Interpret Quantum Mechanics. In The Solvay Councils and the Birth of Modern Physics (pp. 161-174). Birkhäuser, Basel.

*** [Pirandola et al., 2015]
    Pirandola, S., Eisert, J., Weedbrook, C., Furusawa, A., & Braunstein, S. L. (2015). Advances in quantum teleportation. Nature photonics, 9(10), 641-652.

** Apéndice: Referencias completas

*** [Bouwmeester et al., 1997]
    Bouwmeester, D., Pan, J. W., Mattle, K., Eibl, M., Weinfurter, H., & Zeilinger, A. (1997). Experimental quantum teleportation. Nature, 390(6660), 575-579.

*** [Ma et al., 2012]
    Ma, X. S., Herbst, T., Scheidl, T., Wang, D., Kropatschek, S., Naylor, W., Wittmann, B., Mech, A., Kofler, J., Anisimova, E., Makarov, V., Jennewein, T., Ursin, R., & Zeilinger, A. (2012). Quantum teleportation over 143 kilometres using active feed-forward. Nature, 489(7415), 269-273.

** Apéndice: Referencias completas

*** [Nielsen et al., 1998]
    Nielsen, M. A., Knill, E., & Laflamme, R. (1998). Complete quantum teleportation using nuclear magnetic resonance. Nature, 396(6706), 52-55.

*** [Barret et al., 2004]
    Barrett, M. D., Chiaverini, J., Schaetz, T., Britton, J., Itano, W. M., Jost, J. D., Knill, E., Langer, C., Leibfried, D., Ozeri, R., & Wineland, D. J. (2004). Deterministic quantum teleportation of atomic qubits. Nature, 429(6993), 737-739.

** Apéndice: Referencias completas

*** [Nielsen et al., 2002]
    Nielsen, M. A., & Chuang, I. (2002). Quantum computation and quantum information.

*** [Bennet et al., 1993]
    Bennett, C. H., Brassard, G., Crépeau, C., Jozsa, R., Peres, A., & Wootters, W. K. (1993). Teleporting an unknown quantum state via dual classical and Einstein-Podolsky-Rosen channels. Physical review letters, 70(13), 1895.

** Apéndice: Referencias completas

*** [Pompili et al., 2021]
    Pompili, M., Hermans, S. L., Baier, S., Beukers, H. K., Humphreys, P. C., Schouten, R. N., ... & Hanson, R. (2021). Realization of a multinode quantum network of remote solid-state qubits. Science, 372(6539), 259-264.

A Presentación.pdf => Presentación.pdf +0 -0
A Qcircuit_measure-arrow.svg => Qcircuit_measure-arrow.svg +29 -0
@@ 0,0 1,29 @@
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns="http://www.w3.org/2000/svg" height="89.664pt" width="249.07pt" version="1.1" xmlns:cc="http://creativecommons.org/ns#" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 249.066 89.664" xmlns:dc="http://purl.org/dc/elements/1.1/">
 <desc>https://commons.wikimedia.org/wiki/File:Qcircuit_measure-arrow.svg</desc>
 <defs>
  <symbol id="glyph0-1" overflow="visible">
   <path d="m-18.031 19.828l0.297-0.047 0.296-0.156c7.282-5.078 13.454-11.562 18.235-19.031l0.15612-0.29712 0.04688-0.29688c-0.04688-0.59375-0.40625-0.95312-1-1l-0.29688 0.04688-0.29687 0.15624-0.20313 0.20313c-4.6875 7.3126-10.703 13.688-17.828 18.625l-0.203 0.203-0.156 0.297-0.047 0.297c0.047 0.594 0.406 0.953 1 1z"/>
  </symbol>
  <symbol id="glyph1-1" overflow="visible">
   <path d="m0-1l-0.29688 0.04688-0.29687 0.15624-0.20313 0.20313-0.15624 0.29687c-2.6407 7.0781-4.3281 14.594-4.3281 23.703 0 1.453-0.25 3.141 1.0468 3.344 0.5938-0.047 0.9532-0.406 1-1-0.0468-0.75-0.0468-1.594-0.0468-2.344 0-8.906 1.6406-16.234 4.2343-23.109l0.0469-0.297c-0.04688-0.59375-0.40625-0.95312-1-1z"/>
  </symbol>
 </defs>
 <path stroke-linejoin="round" d="m89.664 66.254c19.076-19.078 49.976-19.238 69.256-0.481" stroke="#000" stroke-linecap="round" stroke-miterlimit="10" stroke-width="1.99" fill="none"/>
 <path stroke-linejoin="round" d="m124.53 69.738 24.91-49.812" stroke="#000" stroke-linecap="round" stroke-miterlimit="10" stroke-width="1.99" fill="none"/>
 <g>
  <use xlink:href="#glyph0-1" height="89.664001" width="249.06599" y="19.927" x="149.438"/>
 </g>
 <g>
  <use xlink:href="#glyph1-1" height="89.664001" width="249.06599" y="19.927" x="149.438"/>
 </g>
 <g stroke-linejoin="round" stroke="#000" stroke-linecap="round" stroke-miterlimit="10" stroke-width="1.99" fill="none">
  <path d="m169.36 9.9609h-89.66"/>
  <path d="m79.703 9.9609v69.742"/>
  <path d="m79.703 79.703h89.66"/>
  <path d="m169.36 79.703v-69.742"/>
  <path d="m79.703 44.832h-69.738"/>
  <path d="m239.1 49.812h-69.738"/>
  <path d="m239.1 39.852h-69.738"/>
 </g>
<script xmlns=""/></svg>
\ No newline at end of file

A circuito.png => circuito.png +0 -0
A circuito.xcf => circuito.xcf +0 -0
A holanda1.jpg => holanda1.jpg +0 -0
A holanda2.jpg => holanda2.jpg +0 -0
A ibmqe/1-circuit-one-qubit.png => ibmqe/1-circuit-one-qubit.png +0 -0
A ibmqe/2-circuit-one-qubit.png => ibmqe/2-circuit-one-qubit.png +0 -0
A ibmqe/3-circuit-one-qubit.png => ibmqe/3-circuit-one-qubit.png +0 -0
A ibmqe/4-circuit-one-qubit.png => ibmqe/4-circuit-one-qubit.png +0 -0
A ibmqe/Pr-1-circuit-one-qubit.png => ibmqe/Pr-1-circuit-one-qubit.png +0 -0
A ibmqe/Pr-2-circuit-one-qubit.png => ibmqe/Pr-2-circuit-one-qubit.png +0 -0
A ibmqe/Pr-3-circuit-one-qubit.png => ibmqe/Pr-3-circuit-one-qubit.png +0 -0
A ibmqe/Pr-4-circuit-one-qubit.png => ibmqe/Pr-4-circuit-one-qubit.png +0 -0
A ibmqe/Pr-circuit-entangled-qubits.png => ibmqe/Pr-circuit-entangled-qubits.png +0 -0
A ibmqe/circuit-entangled-states.png => ibmqe/circuit-entangled-states.png +0 -0
A ibmqe/circuit-one-qubit.png => ibmqe/circuit-one-qubit.png +0 -0
A scholar.ods => scholar.ods +0 -0
A scholar.png => scholar.png +0 -0
A teleport-demo-main.zip => teleport-demo-main.zip +0 -0
A teleport-demo-main/.gitignore => teleport-demo-main/.gitignore +2 -0
@@ 0,0 1,2 @@
/dist-newstyle/
.DS_Store

A teleport-demo-main/README.md => teleport-demo-main/README.md +9 -0
@@ 0,0 1,9 @@
# Teleport demo

```sh
cabal run [probability|simulation] -- [0|1|+|-]
```

```sh
cabal run -v0 pdf > example.pdf
```

A teleport-demo-main/app/pdf.hs => teleport-demo-main/app/pdf.hs +7 -0
@@ 0,0 1,7 @@
module Main where

import           Quipper  (Format (PDF), print_simple)
import           Teleport (teleport)

main :: IO ()
main = print_simple PDF teleport

A teleport-demo-main/app/probability.hs => teleport-demo-main/app/probability.hs +31 -0
@@ 0,0 1,31 @@
module Main where

import           Data.Bifunctor                                 (Bifunctor (first))
import           Data.List                                      (nub)
import           Quipper                                        (qinit_of_char)
import           Quipper.Libraries.Simulation.QuantumSimulation (Vector (Vector),
                                                                 sim_generic)
import           System.Environment                             (getArgs)
import           Teleport                                       (protocol)

main :: IO ()
main = do
  c <- parse <$> getArgs
  let Vector ps = sim_generic (1 :: Double) $
        qinit_of_char c >>= protocol
  putStrLn $ "Alice: " <> show (select fst ps)
--  putStrLn $ "Bob: " <> show (select snd ps)
  where
    select s = combine . map (first s)

combine :: Eq a => [(a, Double)] -> [(a, Double)]
combine ps = zip us $ map prob us
  where
    us = nub . map fst $ ps
    prob u = sum [ p | (e, p) <- ps, e == u]

parse :: [String] -> Char
parse [[c]]
  | c `elem` "01+-" = c
  | otherwise = error "Only 0, 1, + or - allowed"
parse _ = error "Expected a single 0, 1, + or - as argument"

A teleport-demo-main/app/probability.hs~ => teleport-demo-main/app/probability.hs~ +31 -0
@@ 0,0 1,31 @@
module Main where

import           Data.Bifunctor                                 (Bifunctor (first))
import           Data.List                                      (nub)
import           Quipper                                        (qinit_of_char)
import           Quipper.Libraries.Simulation.QuantumSimulation (Vector (Vector),
                                                                 sim_generic)
import           System.Environment                             (getArgs)
import           Teleport                                       (protocol)

main :: IO ()
main = do
  c <- parse <$> getArgs
  let Vector ps = sim_generic (0 :: Double) $
        qinit_of_char c >>= protocol
  putStrLn $ "Alice: " <> show (select fst ps)
  putStrLn $ "Bob: " <> show (select snd ps)
  where
    select s = combine . map (first s)

combine :: Eq a => [(a, Double)] -> [(a, Double)]
combine ps = zip us $ map prob us
  where
    us = nub . map fst $ ps
    prob u = sum [ p | (e, p) <- ps, e == u]

parse :: [String] -> Char
parse [[c]]
  | c `elem` "01+-" = c
  | otherwise = error "Only 0, 1, + or - allowed"
parse _ = error "Expected a single 0, 1, + or - as argument"

A teleport-demo-main/app/prueba.hs => teleport-demo-main/app/prueba.hs +31 -0
@@ 0,0 1,31 @@
module Main where

import           Quipper  (Format (PDF), print_simple)
import           Control.Monad ((>=>))
import           Quipper       (Circ, Qubit, Bit, comment, label, controlled, controlled_not,
                                controlled_not_at, gate_X, gate_Z, hadamard,
                                hadamard_at, qc_init, measure, qinit)


protocol :: Qubit -> Circ ((Bit, Bit), Qubit)
protocol a = do
  (b1, b2) <- qc_init (False, False) >>= bell
  teleport ((bit, bit), a)
 
bell :: (Qubit, Qubit) -> Circ (Qubit, Qubit)
bell (x, y) = hadamard x >>= controlled_not y

teleport :: ((Qubit, Qubit), Qubit) -> Circ ((Bit, Bit), Qubit)
teleport ((a, b1), b2) = do
  label (a, b1, b2) ("a", "𝜓1", "𝜓2")
  (b1', a') <- controlled_not b1 a 
  a'' <- hadamard a'
  comment "" -- Esto es para alinear las medidas, si se comenta, sale la de abajo desplazada a la izquierda. Pero el comment deja un hueco muy grande, así que como queráis
  (bit0, bit1) <- measure(a'', b1')
  b2''' <- gate_X b2 `controlled` bit1
  b2'''' <- gate_Z b2''' `controlled` bit0
  pure ((bit0, bit1), b2'''')


main :: IO ()
main = print_simple PDF teleport

A teleport-demo-main/app/prueba.hs~ => teleport-demo-main/app/prueba.hs~ +31 -0
@@ 0,0 1,31 @@
module Main where

import           Quipper  (Format (PDF), print_simple)
import           Control.Monad ((>=>))
import           Quipper       (Circ, Qubit, Bit, comment, label, controlled, controlled_not,
                                controlled_not_at, gate_X, gate_Z, hadamard,
                                hadamard_at, qc_init, measure, qinit)


protocol :: Qubit -> Circ ((Bit, Bit), Qubit)
protocol a = do
  (b1, b2) <- qc_init (False, False) >>= bell
  teleport ((a, b1), b2)
 
bell :: (Qubit, Qubit) -> Circ (Qubit, Qubit)
bell (x, y) = hadamard x >>= controlled_not y

teleport :: ((Qubit, Qubit), Qubit) -> Circ ((Bit, Bit), Qubit)
teleport ((a, b1), b2) = do
  label (a, b1, b2) ("a", "𝜓1", "𝜓2")
  (b1', a') <- controlled_not b1 a 
  a'' <- hadamard a'
  comment "" -- Esto es para alinear las medidas, si se comenta, sale la de abajo desplazada a la izquierda. Pero el comment deja un hueco muy grande, así que como queráis
  (bit0, bit1) <- measure(a'', b1')
  b2''' <- gate_X b2 `controlled` bit1
  b2'''' <- gate_Z b2''' `controlled` bit0
  pure ((bit0, bit1), b2'''')


main :: IO ()
main = print_simple PDF teleport

A teleport-demo-main/app/simulation.hs => teleport-demo-main/app/simulation.hs +20 -0
@@ 0,0 1,20 @@
module Main where

import           Quipper                                        (qinit_of_char)
import           Quipper.Libraries.Simulation.QuantumSimulation (run_generic_io)
import           System.Environment                             (getArgs)
import           Teleport                                       (protocol)

main :: IO ()
main = do
  c <- parse <$> getArgs
  (alice, bob) <- run_generic_io (0 :: Double) $ do
    qinit_of_char c >>= protocol
  putStrLn $ "Alice: " <> show alice
  putStrLn $ "Bob: " <> show bob

parse :: [String] -> Char
parse [[c]]
  | c `elem` "01+-" = c
  | otherwise = error "Only 0, 1, + or - allowed"
parse _ = error "Expected a single 0, 1, + or - as argument"

A teleport-demo-main/example.pdf => teleport-demo-main/example.pdf +0 -0
A teleport-demo-main/example.png => teleport-demo-main/example.png +0 -0
A teleport-demo-main/src/Teleport.hs => teleport-demo-main/src/Teleport.hs +27 -0
@@ 0,0 1,27 @@
module Teleport (protocol, bell, teleport) where

import           Quipper       (Circ, Qubit, Bit, controlled, controlled_not,
                                gate_X, gate_Z, hadamard, qc_init, measure,
                                comment, label, bit, cinit)


protocol :: Qubit -> Circ ((Bit, Bit), Qubit)
protocol a = do
  (b1, b2) <- cinit (False, False)
  
  return ((b1, b2), a)

 
bell :: (Qubit, Qubit) -> Circ (Qubit, Qubit)
bell (x, y) = hadamard x >>= controlled_not y

teleport :: ((Qubit, Qubit), Qubit) -> Circ ((Bit, Bit), Qubit)
teleport ((a, b1), b2) = do
  label (a, b1, b2) ("a", "𝜓1", "𝜓2")
  (b1', a') <- controlled_not b1 a 
  a'' <- hadamard a'
  comment "" -- Esto es para alinear las medidas, si se comenta, sale la de abajo desplazada a la izquierda. Pero el comment deja un hueco muy grande, así que como queráis
  (bit0, bit1) <- measure(a'', b1')
  b2''' <- gate_X b2 `controlled` bit1
  b2'''' <- gate_Z b2''' `controlled` bit0
  pure ((bit0, bit1), b2'''')

A teleport-demo-main/src/Teleport.hs~ => teleport-demo-main/src/Teleport.hs~ +24 -0
@@ 0,0 1,24 @@
module Teleport (protocol, bell, teleport) where

import           Quipper       (Circ, Qubit, Bit, controlled, controlled_not,
                                gate_X, gate_Z, hadamard, qc_init, measure,
                                comment, label)

protocol :: Qubit -> Circ ((Bit, Bit), Qubit)
protocol a = do
  (b1, b2) <- qc_init (False, False) >>= bell
  teleport ((a, b1), b2)
 
bell :: (Qubit, Qubit) -> Circ (Qubit, Qubit)
bell (x, y) = hadamard x >>= controlled_not y

teleport :: ((Qubit, Qubit), Qubit) -> Circ ((Bit, Bit), Qubit)
teleport ((a, b1), b2) = do
  label (a, b1, b2) ("a", "𝜓1", "𝜓2")
  (b1', a') <- controlled_not b1 a 
  a'' <- hadamard a'
  comment "" -- Esto es para alinear las medidas, si se comenta, sale la de abajo desplazada a la izquierda. Pero el comment deja un hueco muy grande, así que como queráis
  (bit0, bit1) <- measure(a'', b1')
  b2''' <- gate_X b2 `controlled` bit1
  b2'''' <- gate_Z b2''' `controlled` bit0
  pure ((bit0, bit1), b2'''')

A teleport-demo-main/teleport-demo.cabal => teleport-demo-main/teleport-demo.cabal +39 -0
@@ 0,0 1,39 @@
cabal-version:      2.4
name:               teleport-demo
version:            0.1.0.0

library
    exposed-modules:  Teleport 
    build-depends:    base ^>=4.13.0.0,
                      quipper-language
    hs-source-dirs:   src
    ghc-options:      -Wall
    default-language: Haskell2010

common exe 
    build-depends:    base ^>=4.13.0.0,
                      teleport-demo,
                      quipper-language,
                      quipper-libraries
    ghc-options:      -Wall
    default-language: Haskell2010

executable probability
    import:           exe
    hs-source-dirs:   app
    main-is:          probability.hs

executable simulation
    import:           exe
    hs-source-dirs:   app
    main-is:          simulation.hs

executable pdf
    import:           exe
    hs-source-dirs:   app
    main-is:          pdf.hs

executable prueba
    import:           exe
    hs-source-dirs:   app
    main-is:          prueba.hs

A teleport-demo-main/teleport-demo.cabal~ => teleport-demo-main/teleport-demo.cabal~ +34 -0
@@ 0,0 1,34 @@
cabal-version:      2.4
name:               teleport-demo
version:            0.1.0.0

library
    exposed-modules:  Teleport 
    build-depends:    base ^>=4.13.0.0,
                      quipper-language
    hs-source-dirs:   src
    ghc-options:      -Wall
    default-language: Haskell2010

common exe 
    build-depends:    base ^>=4.13.0.0,
                      teleport-demo,
                      quipper-language,
                      quipper-libraries
    ghc-options:      -Wall
    default-language: Haskell2010

executable probability
    import:           exe
    hs-source-dirs:   app
    main-is:          probability.hs

executable simulation
    import:           exe
    hs-source-dirs:   app
    main-is:          simulation.hs

executable pdf
    import:           exe
    hs-source-dirs:   app
    main-is:          pdf.hs