example/variational_quantum_circuit_simulator.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{String,1}:\n",
       " \"@\"                                                              \n",
       " \"@v#.#\"                                                          \n",
       " \"@stdlib\"                                                        \n",
       " \"/Users/guochu/Documents/QuantumSimulator/qi-variational-circuit\""
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "push!(LOAD_PATH, \"/Users/guochu/Documents/QuantumSimulator/qi-variational-circuit\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 1: Quantum State"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. create an initial quantum state of 2 qubits |00>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "StateVector{Complex{Float64}}(Complex{Float64}[1.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using VQC\n",
    "state = qstate([0,0])\n",
    "# all the amplitudes of the state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "output all the amplitudes/probabilities of the quantum state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Complex{Float64}[1.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im]\n",
      "[1.0, 0.0, 0.0, 0.0]\n"
     ]
    }
   ],
   "source": [
    "println(amplitudes(state))\n",
    "println(probabilities(state))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "another way of creating a 2-qubits quantum state which are all initialized to be 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{Complex{Float64},1}:\n",
       " 1.0 + 0.0im\n",
       " 0.0 + 0.0im\n",
       " 0.0 + 0.0im\n",
       " 0.0 + 0.0im"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state = qstate(2)\n",
    "amplitudes(state)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. create an initial quantum state of 2 qubits |01>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{Complex{Float64},1}:\n",
       " 6.123233995736766e-17 + 0.0im\n",
       "                   0.0 + 0.0im\n",
       "                   1.0 + 0.0im\n",
       "                   0.0 + 0.0im"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state = qstate([0,1])\n",
    "amplitudes(state)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "output one amplitude or probability of the quantum state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.123233995736766e-17 + 0.0im 0.0 + 0.0im 1.0 + 0.0im 0.0 + 0.0im\n",
      "3.749399456654644e-33 0.0 1.0 0.0\n"
     ]
    }
   ],
   "source": [
    "print(amplitude(state, [0,0]), ' ', amplitude(state, [1,0]), ' ', \n",
    "    amplitude(state, [0,1]), ' ', amplitude(state, [1,1]), '\\n')\n",
    "print(probability(state, [0,0]), ' ', probability(state, [1,0]), ' ', \n",
    "    probability(state, [0,1]), ' ', probability(state, [1,1]), '\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. create a random quantum state on 2 qubits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Complex{Float64}[0.280256704429689 - 0.041291942158190736im, 0.032671611912775615 - 0.6193132906014513im, 0.6598772062534668 - 0.09999067585627942im, -0.1799428076231886 - 0.23941447823397433im]\n",
      "[0.08024884486498543, 0.3846163861405768, 0.44543606259107577, 0.08969870640336203]\n"
     ]
    }
   ],
   "source": [
    "state = qrandn(2)\n",
    "println(amplitudes(state))\n",
    "println(probabilities(state))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 2: Quantum Circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. initialize an empty quantum circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "QCircuit(VQC.AbstractQuantumOperation[])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circuit = QCircuit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. various equivalent ways of adding gate operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "QCircuit(VQC.AbstractQuantumOperation[OneBodyGate{Array{Float64,2}}(1, [0.7071067811865475 0.7071067811865475; 0.7071067811865475 -0.7071067811865475]), TwoBodyGate{PermutedDimsArray{Float64,4,(1, 2, 3, 4),(1, 2, 3, 4),Array{Float64,4}}}((1, 3), [1.0 0.0; 0.0 0.0]\n",
      "\n",
      "[0.0 0.0; 0.0 1.0]\n",
      "\n",
      "[0.0 1.0; 0.0 0.0]\n",
      "\n",
      "[0.0 0.0; 1.0 0.0])])\n"
     ]
    }
   ],
   "source": [
    "push!(circuit, (1, H))\n",
    "push!(circuit, ((1,3), CNOT))\n",
    "println(circuit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{VQC.AbstractQuantumOperation,1}:\n",
       " OneBodyGate{Array{Float64,2}}(1, [0.7071067811865475 0.7071067811865475; 0.7071067811865475 -0.7071067811865475])                                                           \n",
       " TwoBodyGate{PermutedDimsArray{Float64,4,(1, 2, 3, 4),(1, 2, 3, 4),Array{Float64,4}}}((1, 3), [1.0 0.0; 0.0 0.0]\n",
       "\n",
       "[0.0 0.0; 0.0 1.0]\n",
       "\n",
       "[0.0 1.0; 0.0 0.0]\n",
       "\n",
       "[0.0 0.0; 1.0 0.0])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "empty!(circuit)\n",
    "push!(circuit, gate(1, H))\n",
    "push!(circuit, gate((1,3), CNOT))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{VQC.AbstractQuantumOperation,1}:\n",
       " OneBodyGate{Array{Float64,2}}(1, [0.7071067811865475 0.7071067811865475; 0.7071067811865475 -0.7071067811865475])                                                           \n",
       " TwoBodyGate{PermutedDimsArray{Float64,4,(1, 2, 3, 4),(1, 2, 3, 4),Array{Float64,4}}}((1, 3), [1.0 0.0; 0.0 0.0]\n",
       "\n",
       "[0.0 0.0; 0.0 1.0]\n",
       "\n",
       "[0.0 1.0; 0.0 0.0]\n",
       "\n",
       "[0.0 0.0; 1.0 0.0])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "empty!(circuit)\n",
    "push!(circuit, HGate(1))\n",
    "push!(circuit, CNOTGate((1,3)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 3: Generating an entangled Bell State"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## create a two qubit bell state $|\\psi> = |00> + |11>$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{VQC.AbstractQuantumOperation,1}:\n",
       " OneBodyGate{Array{Float64,2}}(1, [0.7071067811865475 0.7071067811865475; 0.7071067811865475 -0.7071067811865475])                                                           \n",
       " TwoBodyGate{PermutedDimsArray{Float64,4,(1, 2, 3, 4),(1, 2, 3, 4),Array{Float64,4}}}((1, 2), [1.0 0.0; 0.0 0.0]\n",
       "\n",
       "[0.0 0.0; 0.0 1.0]\n",
       "\n",
       "[0.0 1.0; 0.0 0.0]\n",
       "\n",
       "[0.0 0.0; 1.0 0.0])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "psi = qstate(2)\n",
    "circuit = QCircuit()\n",
    "push!(circuit, (1, H))\n",
    "push!(circuit, ((1, 2), CNOT))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Apply circuit (list of gate operations) to the quantum and get the probabilities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bell state amplitudes: [0.4999999999999999, 0.0, 0.0, 0.4999999999999999]\n"
     ]
    }
   ],
   "source": [
    "apply!(circuit, psi)\n",
    "probs = probabilities(psi)\n",
    "print(\"Bell state amplitudes: \", probs, '\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 4: Variational Quantum Circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training a variational quantum circuit to approximate a given quantum state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "circuit = QCircuit()\n",
    "for i in 1:3\n",
    "    push!(circuit, RxGate(i, Variable(randn())))\n",
    "end\n",
    "for i in 1:2\n",
    "    push!(circuit, ((i, i+1), CNOT))\n",
    "end\n",
    "for i in 1:3\n",
    "    push!(circuit, RxGate(i, Variable(randn())))\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "StateVector{Complex{Float64}}(Complex{Float64}[0.7071067811865475 + 0.0im, 2.6512257811776554e-33 + 0.0im, 2.6512257811776554e-33 + 0.0im, 4.3297802811774664e-17 + 0.0im, 2.6512257811776554e-33 + 0.0im, 4.3297802811774664e-17 + 0.0im, 4.3297802811774664e-17 + 0.0im, 0.7071067811865475 + 0.0im])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "target_state = (qstate([0,0,0]) + qstate([1,1,1])) / sqrt(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "StateVector{Complex{Float64}}(Complex{Float64}[1.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "initial_state = qstate([0,0,0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loss function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "loss (generic function with 1 method)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loss(c) = distance(target_state, c * initial_state)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss at step 50 is 1.1875602597476012\n",
      "loss at step 100 is 1.1390452988090838\n",
      "loss at step 150 is 1.0920179718106908\n",
      "loss at step 200 is 1.0417925536948558\n",
      "loss at step 250 is 0.991403636209665\n",
      "loss at step 300 is 0.9431180235245503\n",
      "loss at step 350 is 0.8992856150823629\n",
      "loss at step 400 is 0.8613465454891983\n",
      "loss at step 450 is 0.8303090091572403\n",
      "loss at step 500 is 0.8077744538969193\n",
      "loss at step 550 is 0.7942877038201726\n",
      "loss at step 600 is 0.7841526531155715\n",
      "loss at step 650 is 0.7761184545894025\n",
      "loss at step 700 is 0.7702711873470935\n",
      "loss at step 750 is 0.7666756306008242\n",
      "loss at step 800 is 0.7653725424312686\n",
      "loss at step 850 is 0.7653679563312266\n",
      "loss at step 900 is 0.7653679527398618\n",
      "loss at step 950 is 0.7653679493999985\n",
      "loss at step 1000 is 0.7653679462698303\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "6-element Array{Float64,1}:\n",
       "  0.0009290712200522417\n",
       " -1.0561460226167145   \n",
       "  0.11735306596445844  \n",
       "  1.056272776091561    \n",
       " -0.0007570020652410813\n",
       " -0.1182959398398524   "
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using Zygote\n",
    "using Flux.Optimise\n",
    "\n",
    "opt = ADAM()\n",
    "\n",
    "function train(epochs)\n",
    "    for i in 1:epochs\n",
    "        grad = collect_gradients(gradient(loss, circuit))\n",
    "        paras = parameters(circuit)\n",
    "        Optimise.update!(opt, paras, grad)\n",
    "        set_parameters!(paras, circuit)\n",
    "        if i % 50 == 0\n",
    "            println(\"loss at step $i is $(loss(circuit))\")\n",
    "        end\n",
    "    end\n",
    "    return parameters(circuit)\n",
    "end\n",
    "\n",
    "epochs = 1000\n",
    "\n",
    "train(epochs)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## adding more variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss at step 50 is 1.508626776310791\n",
      "loss at step 100 is 1.3627005793861764\n",
      "loss at step 150 is 1.1515018575853182\n",
      "loss at step 200 is 0.9390356894884042\n",
      "loss at step 250 is 0.7912528835460592\n",
      "loss at step 300 is 0.7653956645172905\n",
      "loss at step 350 is 0.7653956487222204\n",
      "loss at step 400 is 0.7653956329934526\n",
      "loss at step 450 is 0.765395617330323\n",
      "loss at step 500 is 0.7653956017321796\n",
      "loss at step 550 is 0.7653955861983807\n",
      "loss at step 600 is 0.7653955707282947\n",
      "loss at step 650 is 0.7653955553213008\n",
      "loss at step 700 is 0.7653955399767877\n",
      "loss at step 750 is 0.7653955246941538\n",
      "loss at step 800 is 0.7653955094728077\n",
      "loss at step 850 is 0.7653954943121668\n",
      "loss at step 900 is 0.7653954792116578\n",
      "loss at step 950 is 0.7653954641707161\n",
      "loss at step 1000 is 0.7653954491887861\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "21-element Array{Float64,1}:\n",
       " -0.14306938124512422\n",
       " -1.200144475081889  \n",
       " -0.14065145461753722\n",
       "  1.2682706745752568 \n",
       " -0.19075872274594913\n",
       " -0.3763004604218484 \n",
       " -0.38946647134721624\n",
       "  0.10912893073560372\n",
       "  0.6633049909071554 \n",
       "  0.786141600272806  \n",
       "  0.9338762894966465 \n",
       " -0.980406689469265  \n",
       " -0.10198713106800798\n",
       "  0.578377287342248  \n",
       " -1.498583716160732  \n",
       "  1.8745184569848026 \n",
       "  0.47436781681938545\n",
       " -0.6383850143760906 \n",
       " -0.8294115547725457 \n",
       "  0.7602968007203682 \n",
       " -0.9495189127450546 "
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "depth = 5\n",
    "for i in 1:depth\n",
    "    for i in 1:2\n",
    "        push!(circuit, ((i, i+1), CNOT))\n",
    "    end\n",
    "    for i in 1:3\n",
    "        push!(circuit, RxGate(i, Variable(randn())))\n",
    "    end\n",
    "end\n",
    "\n",
    "epochs = 1000\n",
    "train(epochs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### result is not so good, try adding RyGate?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss at step 50 is 1.4347758720114028\n",
      "loss at step 100 is 1.2937017731069602\n",
      "loss at step 150 is 1.1369398657099783\n",
      "loss at step 200 is 1.0676806666354193\n",
      "loss at step 250 is 1.0218777252135787\n",
      "loss at step 300 is 0.9732224861940836\n",
      "loss at step 350 is 0.9150041226164125\n",
      "loss at step 400 is 0.8499759030611835\n",
      "loss at step 450 is 0.7899633875570262\n",
      "loss at step 500 is 0.7219739924468006\n",
      "loss at step 550 is 0.6414624088008909\n",
      "loss at step 600 is 0.559808442689916\n",
      "loss at step 650 is 0.49487291795373795\n",
      "loss at step 700 is 0.44176864432098467\n",
      "loss at step 750 is 0.3925165533085941\n",
      "loss at step 800 is 0.34337837036811814\n",
      "loss at step 850 is 0.2940267228350811\n",
      "loss at step 900 is 0.24447833699032884\n",
      "loss at step 950 is 0.1947984368004426\n",
      "loss at step 1000 is 0.14500799045941062\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "24-element Array{Float64,1}:\n",
       "  0.3729295036397556   \n",
       " -1.0661422608765043   \n",
       " -0.36664461293744693  \n",
       "  1.2683303520291513   \n",
       " -0.07276048233885739  \n",
       " -0.6022936187417569   \n",
       " -0.5654660838256413   \n",
       "  0.24313114494098667  \n",
       "  0.43731183258724754  \n",
       "  0.7861435210686005   \n",
       "  1.0518745299037378   \n",
       " -1.2063998477891749   \n",
       "  0.4140117538168719   \n",
       "  0.7123795015476296   \n",
       " -1.7245768744806413   \n",
       "  1.8745781344387074   \n",
       "  0.5923660572264765   \n",
       " -0.8643781726959989   \n",
       " -1.0054111672509751   \n",
       "  0.8942990149257498   \n",
       " -1.1755120710649647   \n",
       " -0.1450308376142568   \n",
       " -0.7847541963042142   \n",
       " -0.0005033551416634648"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for i in 1:2\n",
    "    push!(circuit, ((i, i+1), CNOT))\n",
    "end\n",
    "for i in 1:3\n",
    "    push!(circuit, RyGate(i, Variable(randn())))\n",
    "end\n",
    "train(epochs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 5: Quantum Born Machine"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10-element Array{Array{Int64,1},1}:\n",
       " [0, 0, 0, 1, 0]\n",
       " [0, 1, 1, 1, 1]\n",
       " [0, 1, 0, 0, 1]\n",
       " [0, 0, 0, 0, 1]\n",
       " [1, 0, 0, 1, 1]\n",
       " [0, 1, 0, 0, 1]\n",
       " [0, 1, 1, 0, 0]\n",
       " [1, 1, 0, 0, 0]\n",
       " [1, 1, 1, 1, 1]\n",
       " [1, 0, 1, 1, 1]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = 5\n",
    "N = 10\n",
    "cdata = [rand(0:1, 5) for _ in 1:N]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "convert classical data into quanutm data, using $\\theta \\rightarrow [\\cos(\\theta), \\sin(\\theta)]$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10-element Array{StateVector{Complex{Float64}},1}:\n",
       " StateVector{Complex{Float64}}(Complex{Float64}[6.123233995736766e-17 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 1.0 + 0.0im, 0.0 + 0.0im  …  0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im])                                                                                                                                                                                                                                                                                                                                         \n",
       " StateVector{Complex{Float64}}(Complex{Float64}[1.405799628556214e-65 + 0.0im, 0.0 + 0.0im, 2.2958450216584675e-49 + 0.0im, 0.0 + 0.0im, 2.2958450216584675e-49 + 0.0im, 0.0 + 0.0im, 3.749399456654644e-33 + 0.0im, 0.0 + 0.0im, 2.2958450216584675e-49 + 0.0im, 0.0 + 0.0im  …  6.123233995736766e-17 + 0.0im, 0.0 + 0.0im, 3.749399456654644e-33 + 0.0im, 0.0 + 0.0im, 6.123233995736766e-17 + 0.0im, 0.0 + 0.0im, 6.123233995736766e-17 + 0.0im, 0.0 + 0.0im, 1.0 + 0.0im, 0.0 + 0.0im])                                                                                                                                                                                      \n",
       " StateVector{Complex{Float64}}(Complex{Float64}[3.749399456654644e-33 + 0.0im, 0.0 + 0.0im, 6.123233995736766e-17 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im  …  0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im])                                                                                                                                                                                                                                                                                                                       \n",
       " StateVector{Complex{Float64}}(Complex{Float64}[6.123233995736766e-17 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im  …  0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im])                                                                                                                                                                                                                                                                                                                                         \n",
       " StateVector{Complex{Float64}}(Complex{Float64}[2.2958450216584675e-49 + 0.0im, 3.749399456654644e-33 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 3.749399456654644e-33 + 0.0im, 6.123233995736766e-17 + 0.0im  …  0.0 + 0.0im, 0.0 + 0.0im, 6.123233995736766e-17 + 0.0im, 1.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im])                                                                                                                                                                                                                                                                \n",
       " StateVector{Complex{Float64}}(Complex{Float64}[3.749399456654644e-33 + 0.0im, 0.0 + 0.0im, 6.123233995736766e-17 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im  …  0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im])                                                                                                                                                                                                                                                                                                                       \n",
       " StateVector{Complex{Float64}}(Complex{Float64}[3.749399456654644e-33 + 0.0im, 0.0 + 0.0im, 6.123233995736766e-17 + 0.0im, 0.0 + 0.0im, 6.123233995736766e-17 + 0.0im, 0.0 + 0.0im, 1.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im  …  0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im])                                                                                                                                                                                                                                                                                                     \n",
       " StateVector{Complex{Float64}}(Complex{Float64}[3.749399456654644e-33 + 0.0im, 6.123233995736766e-17 + 0.0im, 6.123233995736766e-17 + 0.0im, 1.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im  …  0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im])                                                                                                                                                                                                                                                                                                     \n",
       " StateVector{Complex{Float64}}(Complex{Float64}[8.608040076769528e-82 + 0.0im, 1.405799628556214e-65 + 0.0im, 1.405799628556214e-65 + 0.0im, 2.2958450216584675e-49 + 0.0im, 1.405799628556214e-65 + 0.0im, 2.2958450216584675e-49 + 0.0im, 2.2958450216584675e-49 + 0.0im, 3.749399456654644e-33 + 0.0im, 1.405799628556214e-65 + 0.0im, 2.2958450216584675e-49 + 0.0im  …  3.749399456654644e-33 + 0.0im, 6.123233995736766e-17 + 0.0im, 2.2958450216584675e-49 + 0.0im, 3.749399456654644e-33 + 0.0im, 3.749399456654644e-33 + 0.0im, 6.123233995736766e-17 + 0.0im, 3.749399456654644e-33 + 0.0im, 6.123233995736766e-17 + 0.0im, 6.123233995736766e-17 + 0.0im, 1.0 + 0.0im])\n",
       " StateVector{Complex{Float64}}(Complex{Float64}[1.405799628556214e-65 + 0.0im, 2.2958450216584675e-49 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 2.2958450216584675e-49 + 0.0im, 3.749399456654644e-33 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 2.2958450216584675e-49 + 0.0im, 3.749399456654644e-33 + 0.0im  …  0.0 + 0.0im, 0.0 + 0.0im, 3.749399456654644e-33 + 0.0im, 6.123233995736766e-17 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im, 6.123233995736766e-17 + 0.0im, 1.0 + 0.0im, 0.0 + 0.0im, 0.0 + 0.0im])                                                                                                                                                                                      "
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = [qstate(item) for item in cdata]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "initial_state = qstate(L)\n",
    "loss_born(x) = begin\n",
    "    r = 0.\n",
    "    for i in 1:length(data)\n",
    "        r += distance(data[i], x * initial_state)\n",
    "    end\n",
    "    return r/length(data)\n",
    "end\n",
    "\n",
    "circuit = QCircuit()\n",
    "for i in 1:L\n",
    "    push!(circuit, RyGate(i, Variable(randn())))\n",
    "end\n",
    "depth = 3\n",
    "for _ in 1:depth\n",
    "    for i in 1:(L-1)\n",
    "        push!(circuit, ((i, i+1), CNOT))\n",
    "    end\n",
    "    for i in 1:L\n",
    "       push!(circuit, RyGate(i, Variable(randn())))\n",
    "    end\n",
    "end\n",
    "for _ in 1:depth\n",
    "    for i in 1:(L-1)\n",
    "        push!(circuit, ((i, i+1), CNOT))\n",
    "    end\n",
    "    for i in 1:L\n",
    "       push!(circuit, RxGate(i, Variable(randn())))\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss at step 50 is 1.3191281443898768\n",
      "loss at step 100 is 1.2724209684861145\n",
      "loss at step 150 is 1.2463868641743536\n",
      "loss at step 200 is 1.233069024620034\n",
      "loss at step 250 is 1.22398897274511\n",
      "loss at step 300 is 1.2164957271165906\n",
      "loss at step 350 is 1.2102472597338516\n",
      "loss at step 400 is 1.2047755858208316\n",
      "loss at step 450 is 1.1965294996690672\n",
      "loss at step 500 is 1.1843859265272514\n",
      "loss at step 550 is 1.1714279800243994\n",
      "loss at step 600 is 1.1617314430915875\n",
      "loss at step 650 is 1.1565095862934611\n",
      "loss at step 700 is 1.1528133432111165\n",
      "loss at step 750 is 1.1501007724674193\n",
      "loss at step 800 is 1.1485373932017988\n",
      "loss at step 850 is 1.1472393142512125\n",
      "loss at step 900 is 1.1459882919829858\n",
      "loss at step 950 is 1.1447276787789904\n",
      "loss at step 1000 is 1.1433102931635102\n",
      "loss at step 1050 is 1.1415427608371265\n",
      "loss at step 1100 is 1.1393605497876336\n",
      "loss at step 1150 is 1.1369464597364771\n"
     ]
    }
   ],
   "source": [
    "opt = ADAM()\n",
    "\n",
    "function train_born(epochs)\n",
    "    for i in 1:epochs\n",
    "        grad = collect_gradients(gradient(loss_born, circuit))\n",
    "        paras = parameters(circuit)\n",
    "        Optimise.update!(opt, paras, grad)\n",
    "        set_parameters!(paras, circuit)\n",
    "        if i % 50 == 0\n",
    "            println(\"loss at step $i is $(loss_born(circuit))\")\n",
    "        end\n",
    "    end\n",
    "    return parameters(circuit)\n",
    "end\n",
    "\n",
    "train_born(1000)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.2.0",
   "language": "julia",
   "name": "julia-1.2"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.2.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}