chsh-simulation-sequence.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "62de7381-08ee-40bc-9c6d-d7d184b4b39a",
   "metadata": {},
   "source": [
    "### CHSH Game Implementation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62bdc2ef-2ac6-4280-8b76-5be66b371f47",
   "metadata": {},
   "source": [
    "##### This code imports packages that will be used later on, allowing us to use SeQUeNCe's modules and capabilities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c0fff650-cfc8-4c13-ad38-e621d39f518f",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Import the Node and BSMNode classes, which we will use as the basis for our player's circuits and referees circuit, respectively\n",
    "from sequence.topology.node import Node, BSMNode\n",
    "\n",
    "#Import the Memory class, which we will use to hold our qubits\n",
    "from sequence.components.memory import Memory\n",
    "\n",
    "#Import the EntanglementGenerationA class, which we will use to entangle our player's qubits\n",
    "from sequence.entanglement_management.generation import EntanglementGenerationA\n",
    "\n",
    "#Import the Timeline class, which will allow our simulation to run\n",
    "from sequence.kernel.timeline import Timeline\n",
    "\n",
    "#Import the QuantumChannel and ClassicalChannel classes, which allow for communication between Alice and Bob and the referee\n",
    "from sequence.components.optical_channel import QuantumChannel, ClassicalChannel\n",
    "\n",
    "#Import the EntanglementProtocol class, which manages the processes of creating entanglement\n",
    "from sequence.entanglement_management.entanglement_protocol import EntanglementProtocol\n",
    "\n",
    "#Import the Message class, which enables communication on classical channels\n",
    "from sequence.message import Message\n",
    "\n",
    "#Import the Circuit class, which we will use to build custom circuits\n",
    "from sequence.components.circuit import Circuit, x_gate, y_gate, z_gate, s_gate, t_gate, validator\n",
    "\n",
    "#Import the Protocol class, which allows us to define custom actions for nodes\n",
    "from sequence.protocol import Protocol\n",
    "\n",
    "#Import the QuantumManager class\n",
    "from sequence.kernel import quantum_manager\n",
    "\n",
    "#Import the SeQuENCe Logger for Debugging\n",
    "import sequence.utils.log as log\n",
    "\n",
    "#Import relevant components from Qutip, a quantum system simulator that SeQUeNCe incorporates\n",
    "from qutip.qip.circuit import QubitCircuit, CircuitSimulator\n",
    "from qutip.qip.operations import gate_sequence_product\n",
    "from qutip import Qobj\n",
    "\n",
    "#Import other helpful python libraries\n",
    "import numpy as np\n",
    "from enum import Enum\n",
    "import random"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d617a80d-2509-4381-bab5-f42ab2be7f8c",
   "metadata": {},
   "source": [
    "##### This code defines hardware we need to run our simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "dfce4378-20ae-4626-aea2-9bdecfc1b550",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Define the custom gates that Bob will apply to his qubit\n",
    "def gate_0():\n",
    "    angle_0 = np.pi/8\n",
    "    mat = np.array([[np.cos(angle_0), np.sin(angle_0)], \n",
    "                    [np.sin(angle_0), -np.cos(angle_0)]])\n",
    "    return Qobj(mat, dims = [[2], [2]])\n",
    "\n",
    "def gate_1():\n",
    "    angle_1 = -np.pi/8\n",
    "    mat = np.array([[np.cos(angle_1), np.sin(angle_1)], \n",
    "                    [np.sin(angle_1), -np.cos(angle_1)]])\n",
    "    return Qobj(mat, dims = [[2], [2]])\n",
    "\n",
    "#Define a CustomCircuit class so we can calculate the unitary matrix of our circuits\n",
    "#The only difference from SeQUeNCe's built-in Circuit class is the addition of our custom gates\n",
    "class CustomCircuit(Circuit):\n",
    "    def __init__(self, size: int):\n",
    "        super().__init__(size)\n",
    "        \n",
    "    def get_unitary_matrix(self) -> np.ndarray:\n",
    "        if self._cache is None:\n",
    "            if len(self.gates) == 0:\n",
    "                self._cache = np.identity(2 ** self.size)\n",
    "                return self._cache\n",
    "\n",
    "            qc = QubitCircuit(self.size)\n",
    "            qc.user_gates = {\"X\": x_gate,\n",
    "                             \"Y\": y_gate,\n",
    "                             \"Z\": z_gate,\n",
    "                             \"S\": s_gate,\n",
    "                             \"T\": t_gate,\n",
    "                             \"0\": gate_0,\n",
    "                             \"1\": gate_1}\n",
    "            for gate in self.gates:\n",
    "                name, indices, arg = gate\n",
    "                if name == 'h':\n",
    "                    qc.add_gate('SNOT', indices[0])\n",
    "                elif name == 'x':\n",
    "                    qc.add_gate('X', indices[0])\n",
    "                elif name == 'y':\n",
    "                    qc.add_gate('Y', indices[0])\n",
    "                elif name == 'z':\n",
    "                    qc.add_gate('Z', indices[0])\n",
    "                elif name == 'cx':\n",
    "                    qc.add_gate('CNOT', controls=indices[0], targets=indices[1])\n",
    "                elif name == 'ccx':\n",
    "                    qc.add_gate('TOFFOLI', controls=indices[:2], targets=indices[2])\n",
    "                elif name == 'swap':\n",
    "                    qc.add_gate('SWAP', indices)\n",
    "                elif name == 't':\n",
    "                    qc.add_gate('T', indices[0])\n",
    "                elif name == 's':\n",
    "                    qc.add_gate('S', indices[0])\n",
    "                elif name == 'phase':\n",
    "                    qc.add_gate('PHASEGATE', indices[0], arg_value=arg)\n",
    "                elif name == '0_gate':\n",
    "                    qc.add_gate('0', indices[0])\n",
    "                elif name == '1_gate':\n",
    "                    qc.add_gate('1', indices[0])\n",
    "                else:\n",
    "                    raise NotImplementedError\n",
    "            self._cache = gate_sequence_product(qc.propagators()).full()\n",
    "\n",
    "        return self._cache\n",
    "\n",
    "#Define a manager to update protocols on the player's nodes\n",
    "class Manager:\n",
    "    def __init__(self, node, mem_name):\n",
    "        self.node = node\n",
    "        self.mem_name = mem_name\n",
    "        \n",
    "    def update(self, prot, mem, st):\n",
    "        if st == 'RAW':\n",
    "            mem.reset()\n",
    "    \n",
    "        if st == 'ENTANGLED':\n",
    "            if mem.expiration_event is not None:\n",
    "                mem.timeline.remove_event(mem.expiration_event)\n",
    "                mem.expiration_event = None\n",
    "\n",
    "    def add_entanglement_protocol(self, middle: str, other: str):\n",
    "        self.node.protocols = [EntanglementGenerationA(self.node, '%s.eg' % self.node.name, \n",
    "                                                       middle, other, self.node.components[self.mem_name])]\n",
    "        \n",
    "    def add_player_protocol(self, rec_name: str, rec_node: str):\n",
    "        PlayerProtocol(self.node, '%s.pp' % self.node.name, rec_name, rec_node)\n",
    "    \n",
    "    def add_alice_protocol(self):\n",
    "        AliceProtocol(self.node, '%s.ap' % self.node.name)\n",
    "        \n",
    "    def add_bob_protocol(self):\n",
    "        BobProtocol(self.node, '%s.bp' % self.node.name)\n",
    "\n",
    "#Define a custom PlayerNode class, with a manager instance variable\n",
    "class PlayerNode(Node):\n",
    "    def __init__(self, name: str, tl: Timeline, circ: CustomCircuit, reg: int, fid: int = 1, eff: int = 1, coh: float = -1):\n",
    "        super().__init__(name, tl)\n",
    "        \n",
    "        mem_name = '%s.mem' % name\n",
    "        mem = Memory(mem_name, tl, fidelity = fid, frequency = 0,\n",
    "                    efficiency = eff, coherence_time = coh, wavelength = 500)\n",
    "        mem.owner = self\n",
    "        mem.add_receiver(self)\n",
    "        self.add_component(mem)\n",
    "        self.resource_manager = Manager(self, mem_name)\n",
    "        self.shared_circ = circ\n",
    "        assert reg < circ.size, \"register can't be bigger than the number of qubits\"\n",
    "        self.reg = reg\n",
    "                \n",
    "    def init(self):\n",
    "        mem = self.get_components_by_type('Memory')[0]\n",
    "        mem.reset()\n",
    "        \n",
    "    def receive_msg(self, src: str, msg: 'Message'):\n",
    "        self.protocols[0].received_message(src, msg)\n",
    "    \n",
    "    def get(self, photon, **kwargs):\n",
    "        self.send_qubit(kwargs['dst'], photon)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9a662b2-3352-46ed-bfa3-11bb09824897",
   "metadata": {},
   "source": [
    "##### This code defines custom protocols we need to run our simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "cbe80d95-4b84-410a-a8f4-b4b7a83c5299",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Define a method to pair entanglement protocols between the two players\n",
    "def pair_protocol(node1: Node, node2: Node):\n",
    "    p1 = node1.protocols[0]\n",
    "    p2 = node2.protocols[0]\n",
    "    n1_mem_name = node1.get_components_by_type('Memory')[0].name\n",
    "    n2_mem_name = node2.get_components_by_type('Memory')[0].name\n",
    "    p1.set_others(p2.name, node2.name, [n2_mem_name])\n",
    "    p2.set_others(p1.name, node1.name, [n1_mem_name])\n",
    "    \n",
    "#Define a function to add and pair entanglement protocols on both player's nodes\n",
    "def generate_entanglement(node1: Node, node2: Node, entangler: Node):\n",
    "    node1.resource_manager.add_entanglement_protocol(entangler.name, node2.name)\n",
    "    node2.resource_manager.add_entanglement_protocol(entangler.name, node1.name)\n",
    "    pair_protocol(node1, node2)\n",
    "\n",
    "#Define custom enumerators to enable sending custom messages with SeQUeNCe's message package\n",
    "class MsgType(Enum):\n",
    "    ZERO = 0\n",
    "    ONE = 1\n",
    "    READY = 2\n",
    "    \n",
    "class Player(Enum):\n",
    "    ALICE = 0\n",
    "    BOB = 1\n",
    "\n",
    "#Define a function to get the node a name refers to (for convenience)\n",
    "def getNodeFromName(name: str, nodes: list[Node]):\n",
    "    for node in nodes:\n",
    "        if node.name == name:\n",
    "            return node\n",
    "    \n",
    "    print(\"Node not found. Returning NoneType\")\n",
    "    return None\n",
    "\n",
    "#Define custom protocols that define all three participants' behavior when the game starts\n",
    "class RefereeProtocol(Protocol):\n",
    "    def __init__(self, owner: Node, name: str, tl: Timeline, players: list[Node], eff: int = 1, debug: bool = False, ge: bool = False):\n",
    "        super().__init__(owner, name)\n",
    "        owner.protocols.append(self)\n",
    "        self.tl = tl\n",
    "        self.players = players\n",
    "        self.inputs = []\n",
    "        self.msgs_rec = 0\n",
    "        self.keys = []\n",
    "        self.result = None\n",
    "        self.eff = eff\n",
    "        self.debug = debug\n",
    "        self.guar_ent = ge\n",
    "        \n",
    "    def init(self):\n",
    "        pass\n",
    "    \n",
    "    #Define a function to generate a random input (0 or 1) and send it to a player\n",
    "    def sendBit(self, player_prot: str, player_node: str):\n",
    "        bit = random.randint(0, 1)\n",
    "        self.inputs.append(bit)\n",
    "        msg = Message(MsgType(bit), player_prot)\n",
    "        self.owner.send_message(player_node, msg)\n",
    "    \n",
    "    #Define a function to handle player's responses\n",
    "    def received_message(self, src: str, msg: Message):      \n",
    "        self.msgs_rec += 1\n",
    "        \n",
    "        src_node = getNodeFromName(src, self.players)\n",
    "        key = src_node.get_components_by_type('Memory')[0].qstate_key\n",
    "        self.keys.append(key)\n",
    "        circ = src_node.shared_circ\n",
    "        \n",
    "        #If both players have responded, the referee runs their circuit and measures their qubits\n",
    "        if (self.msgs_rec == 2):   \n",
    "            if (self.guar_ent):\n",
    "                assert src_node.get_components_by_type('Memory')[0].entangled_memory['node_id'] != None, 'Entanglement generation failed'\n",
    "            \n",
    "            circ.measure(0)\n",
    "            circ.measure(1)\n",
    "            res = self.tl.quantum_manager.run_circuit(circ, self.keys, random.random())\n",
    "            self.adjudicate_round(self.inputs, res)\n",
    "            \n",
    "    #Define a function to check if player responses met their win condition, return a win if so\n",
    "    def adjudicate_round(self, inp: list[int], res: dict[int, int]):       \n",
    "        #Simulate noise in detector measurement\n",
    "        if (random.random() > self.eff):           \n",
    "            if self.debug:\n",
    "                print('Alice\\'s qubit, which was', res[0], ', was measured as 0.')    \n",
    "            res[0] = 0\n",
    "            \n",
    "        if (random.random() > self.eff):\n",
    "            if self.debug:\n",
    "                print('Bob\\'s qubit, which was', res[1], ', was measured as 0.')  \n",
    "            res[1] = 0\n",
    "        \n",
    "        a_inp = inp[0]\n",
    "        b_inp = inp[1]\n",
    "        a_res = res[0]\n",
    "        b_res = res[1]\n",
    "        \n",
    "        if ((a_res + b_res) % 2 == a_inp * b_inp):\n",
    "            if self.debug:\n",
    "                print('WIN! Inputs:', inp, 'Outputs:', res)\n",
    "            self.result = True\n",
    "        else:\n",
    "            if self.debug:\n",
    "                print('LOSS. Inputs:', inp, 'Outputs:', res)\n",
    "            self.result = False\n",
    "                \n",
    "    #Define a getter function for other classes to get the result\n",
    "    def get_result(self):\n",
    "        assert self.result is not None, 'Result was NoneType. Has the game finished?'\n",
    "        return self.result\n",
    "    \n",
    "class PlayerProtocol(Protocol):\n",
    "    def __init__(self, own: Node, name: str, rec_name: str, rec_node: str):\n",
    "        super().__init__(own, name)\n",
    "        self.rec_name = rec_name\n",
    "        self.rec_node = rec_node\n",
    "        own.protocols.append(self)\n",
    "    \n",
    "    def init(self):\n",
    "        pass\n",
    "    \n",
    "    #Define a method to get an input from the referee, add the appropriate gates to the circuit,\n",
    "    #Then signal to the referee that the player is ready\n",
    "    def received_message(self, src: str, msg: Message):\n",
    "        self.owner.protocols[1].applyGate(msg)\n",
    "        return_msg = Message(MsgType(2), self.rec_name)\n",
    "        self.owner.send_message(self.rec_node, return_msg)\n",
    "        \n",
    "class AliceProtocol(Protocol):\n",
    "    def __init__(self, own: Node, name: str):\n",
    "        super().__init__(own, name)\n",
    "        own.protocols.append(self)\n",
    "        \n",
    "    def init(self):\n",
    "        pass\n",
    "        \n",
    "    #Define a function that decides whether to apply a gate based on Alice's strategy\n",
    "    def applyGate(self, in_bit: Message):\n",
    "        #Apply Hadamard gate if input = 1, otherwise do nothing\n",
    "        if (in_bit.msg_type == MsgType.ONE):\n",
    "            self.owner.shared_circ.gates.append(['h', [self.owner.reg], None])\n",
    "                \n",
    "    def received_message(self, src: str, msg: Message):\n",
    "        pass\n",
    "        \n",
    "class BobProtocol(Protocol):    \n",
    "    def __init__(self, own: Node, name: str):\n",
    "        super().__init__(own, name)\n",
    "        own.protocols.append(self)\n",
    "        \n",
    "    def init(self):\n",
    "        pass\n",
    "            \n",
    "    #Define a function that decides which gate to apply based on Bob's strategy\n",
    "    def applyGate(self, in_bit: Message):\n",
    "        #Apply the unitary gate that corresponds to the input       \n",
    "        if (in_bit.msg_type == MsgType.ONE):\n",
    "            self.owner.shared_circ.gates.append(['1_gate', [self.owner.reg], None])\n",
    "        else:\n",
    "            self.owner.shared_circ.gates.append(['0_gate', [self.owner.reg], None])\n",
    "                    \n",
    "    def received_message(self, src: str, msg: Message):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7e6f4e4-8068-450d-b2b7-ec92ab04765e",
   "metadata": {},
   "source": [
    "##### This code creates a Game class to manage the creation and simulation of individual games"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "79ea5700-9453-4bf6-8efb-f3140683cdf0",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Game:\n",
    "    def __init__(self, debug: bool = False, fid: int = 1, eff: int = 1, coh: float = -1, guarantee_entanglement: bool = True):\n",
    "        self.games = 100\n",
    "        self.wins = 0\n",
    "        self.debug = debug\n",
    "        self.fidelity = fid\n",
    "        self.efficiency = eff\n",
    "        self.coherence = coh # -1 by default means infinite coherence time (perfect coherence)\n",
    "        self.guar_ent = guarantee_entanglement\n",
    "        \n",
    "        if (not self.guar_ent):\n",
    "            self.successful_entanglements = 0\n",
    "        elif (self.coherence < 1e-5 and self.coherence > 0):\n",
    "            print(f\"Warning: low coherence times make entanglement unlikely. Requiring guaranteed entanglement with coherence time {self.coherence} may be susceptible to infinite looping.\")\n",
    "\n",
    "\n",
    "        self.tl = Timeline()\n",
    "        \n",
    "        # Logging for debugging with SeQUeNCe's log module\n",
    "        log_filename = 'log_filename'\n",
    "        log.set_logger(__name__, self.tl, log_filename)\n",
    "        log.set_logger_level('DEBUG')\n",
    "        modules = ['timeline', 'node', 'generation', 'main']    # put more module names here\n",
    "        for module in modules:\n",
    "            log.track_module(module)\n",
    "        \n",
    "    def setup(self):\n",
    "        #Create the timeline for the simulation\n",
    "\n",
    "        self.tl.__init__()\n",
    "\n",
    "        #Create a circuit for Alice and Bob to share\n",
    "        self.shared_circ = CustomCircuit(2)\n",
    "\n",
    "        #Create nodes for Alice, Bob, and a Bell State Management Node to generate entanglement\n",
    "        self.a = PlayerNode('a', self.tl, self.shared_circ, 0, fid = self.fidelity, coh = self.coherence)\n",
    "        self.b = PlayerNode('b', self.tl, self.shared_circ, 1, fid = self.fidelity, coh = self.coherence)\n",
    "\n",
    "        #The referee's channel uses SeQUeNCe's built-in BSMNode\n",
    "        self.ent_node = BSMNode('ent_node', self.tl, ['a', 'b'])\n",
    "\n",
    "        #Set the efficiency of the BSM to 1, which means no errors\n",
    "        self.bsm = self.ent_node.get_components_by_type('SingleAtomBSM')[0]\n",
    "        self.bsm.update_detectors_params('efficiency', 1)\n",
    "\n",
    "        #Create a node for the referee to get and receive bits\n",
    "        self.r = Node('ref', self.tl)\n",
    "        self.nodes = [self.a, self.b, self.ent_node, self.r]\n",
    "\n",
    "        #Create quantum channels between Alice and Bob and the ref\n",
    "        self.qcA = QuantumChannel('qcA', self.tl, attenuation = 0, distance = 1000)\n",
    "        self.qcB = QuantumChannel('qcB', self.tl, attenuation = 0, distance = 1000)\n",
    "        self.qcA.set_ends(self.a, self.ent_node.name)\n",
    "        self.qcB.set_ends(self.b, self.ent_node.name)\n",
    "\n",
    "        #Create classical channels between all existing nodes\n",
    "        #Classical channels are one way only, so we have to make two channels for each connection\n",
    "        for i in range (len(self.nodes)):\n",
    "            for j in range(len(self.nodes)):\n",
    "                if (i != j):\n",
    "                    cc = ClassicalChannel('cc_%s_%s'%(self.nodes[i].name, self.nodes[j].name), self.tl, 1000, 1e8)\n",
    "                    cc.set_ends(self.nodes[i], self.nodes[j].name)\n",
    "    \n",
    "    #Define a function to simulate the games and print the number won\n",
    "    def start(self, games: int = 100):\n",
    "        self.games = games\n",
    "        \n",
    "        for i in range(self.games):\n",
    "            #Create nodes for every player and define entanglement protocol\n",
    "            self.setup()\n",
    "            \n",
    "            #Add and run the entanglement protocol to each player node\n",
    "            generate_entanglement(self.a, self.b, self.ent_node)\n",
    "            self.tl.init()\n",
    "            self.a.protocols[0].start()\n",
    "            self.b.protocols[0].start()\n",
    "            self.tl.run()\n",
    "\n",
    "            mem_a = self.a.get_components_by_type('Memory')[0]\n",
    "            \n",
    "            #Keep rerunning the entanglement protocol until entanglement is successfully created\n",
    "            if (self.guar_ent):\n",
    "                while (mem_a.entangled_memory['node_id'] == None): \n",
    "                    if (self.debug):\n",
    "                        print(f'game {i}, entanglement failed')\n",
    "                    generate_entanglement(self.a, self.b, self.ent_node)\n",
    "                    self.a.protocols[0].start()\n",
    "                    self.b.protocols[0].start()\n",
    "                    self.tl.run()\n",
    "                if (self.debug):\n",
    "                    print(f'game {i}, entanglement success')\n",
    "            else:\n",
    "                if (self.a.get_components_by_type('Memory')[0].entangled_memory['node_id'] != None):\n",
    "                    self.successful_entanglements += 1\n",
    "            \n",
    "            #Play a round and store the result in a variable\n",
    "            rnd = self.play_round()\n",
    "            \n",
    "            #If the result is a win, add one to the win counter\n",
    "            if rnd:\n",
    "                self.wins += 1\n",
    "        \n",
    "        if (not self.guar_ent):\n",
    "            print('Successfully entangled Alice and Bob\\'s qubits', self.successful_entanglements, 'out of', self.games, 'games.')\n",
    "            \n",
    "        print('Won', self.wins, 'out of', self.games, 'games.')\n",
    "    \n",
    "    #Define a function to send input bits to each player and return whether their outputs won the win condition\n",
    "    def play_round(self):\n",
    "        #Reset all participants' protocols\n",
    "        self.preset()\n",
    "        \n",
    "        #Add protocols for each node to assign their behavior\n",
    "        self.a.resource_manager.add_player_protocol('prot_r', 'ref')\n",
    "        self.a.resource_manager.add_alice_protocol()\n",
    "        self.b.resource_manager.add_player_protocol('prot_r', 'ref')\n",
    "        self.b.resource_manager.add_bob_protocol()\n",
    "        \n",
    "        #Add protocol to the referee to assign their behavior\n",
    "        prot_r = RefereeProtocol(self.r, 'prot_r', self.tl, [self.a, self.b], eff = self.efficiency, debug = self.debug, ge = self.guar_ent)\n",
    "\n",
    "        #Send bits to both Alice and Bob, who will respond automatically\n",
    "        self.r.protocols[0].sendBit('a.pp', 'a')\n",
    "        self.r.protocols[0].sendBit('b.pp', 'b')\n",
    "        self.tl.run()\n",
    "        \n",
    "        #Get whether Alice and Bob won or lost, and return it to the start function\n",
    "        return prot_r.get_result()\n",
    "        \n",
    "    #Define a function to clear player protocols and circuits to ensure the game runs from scratch\n",
    "    def preset(self):\n",
    "        self.a.protocols = []\n",
    "        self.b.protocols = []\n",
    "        self.r.protocols = []\n",
    "        self.shared_circ.gates = []\n",
    "        self.shared_circ.measured_qubits = []"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2fccfe2-6329-4e8b-bae3-2ab410d24422",
   "metadata": {},
   "source": [
    "### Simulations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55f57b5d-3e1b-4c87-8c3d-9e60dd26cc3c",
   "metadata": {},
   "source": [
    "#### Ideal Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0147d1a7-e603-4c5e-a697-2c304405595e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Won 853 out of 1000 games.\n"
     ]
    }
   ],
   "source": [
    "# Create a game object, then run it 1000 times.\n",
    "g = Game()\n",
    "g.start(1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9442bc00-9ceb-4212-ba95-7ad95a60845e",
   "metadata": {},
   "source": [
    "#### Fidelity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0fac180b-e602-4507-bd71-7a9d0feaf99d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Won 619 out of 1000 games.\n"
     ]
    }
   ],
   "source": [
    "#Create a game object with lower fidelity of entanglement. Doing so erases the benefits of the quantum strategy.\n",
    "g_low_fidelity = Game(fid = 0.5)\n",
    "g_low_fidelity.start(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "be1f36a7-af03-46c1-ab0b-92dd9761c66c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Won 740 out of 1000 games.\n"
     ]
    }
   ],
   "source": [
    "g_mid_fidelity = Game(fid = 0.75)\n",
    "g_mid_fidelity.start(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "4abaa7aa-bdbd-4573-a16c-475367009134",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Won 810 out of 1000 games.\n"
     ]
    }
   ],
   "source": [
    "g_higher_fidelity = Game(fid = 0.9)\n",
    "g_higher_fidelity.start(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "141f8974-f3d8-4f91-b2c8-034a5f2c920d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Won 842 out of 1000 games.\n"
     ]
    }
   ],
   "source": [
    "g_high_fidelity = Game(fid = 0.95)\n",
    "g_high_fidelity.start(1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d846e319-cc44-4b94-b097-86be5c356b82",
   "metadata": {},
   "source": [
    "#### Entanglement Generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "43e1626a-fbce-4c32-9113-df41bf1d6e68",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successfully entangled Alice and Bob's qubits 516 out of 1000 games.\n",
      "Won 774 out of 1000 games.\n"
     ]
    }
   ],
   "source": [
    "#Create a game object where entanglement is not guaranteed.\n",
    "#The BSM protocol generates entanglement successfully 50% of the time.\n",
    "#At this level of success, the benefits of the quantum strategy again vanish.\n",
    "g_imperfect_entanglement = Game(guarantee_entanglement = False)\n",
    "g_imperfect_entanglement.start(1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b4c1b54-11da-4e11-85a9-aa6e672d9d69",
   "metadata": {},
   "source": [
    "#### Measurement Efficiency"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "05353a11-5396-41fe-b7f9-4c4f8bcdf69f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Won 792 out of 1000 games.\n"
     ]
    }
   ],
   "source": [
    "#Create a game with measurement efficiency of 90%\n",
    "#This means that 10% of the time a qubit should be measured as a 1, it is measured as a 0\n",
    "g_low_efficiency = Game(eff = 0.9)\n",
    "g_low_efficiency.start(1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfaaa020-f996-47cb-ba8d-5b0ba30cd4da",
   "metadata": {},
   "source": [
    "#### Coherence Time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "560b3ae1-feb3-45ad-9b76-98d008488d8b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Won 310 out of 1000 games.\n"
     ]
    }
   ],
   "source": [
    "#Create a game with coherence time of 1e-5 seconds\n",
    "g_low_coherence = Game(coh = 1e-5)\n",
    "g_low_coherence.start(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "21111447-c204-49b3-859d-f41ebec02e73",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Won 323 out of 1000 games.\n"
     ]
    }
   ],
   "source": [
    "#Create a game with coherence time of 4e-4 seconds\n",
    "g_med_coherence = Game(coh = 4e-4)\n",
    "g_med_coherence.start(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "dfe7b424-152a-4d2b-8315-28b5545edf7b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Won 846 out of 1000 games.\n"
     ]
    }
   ],
   "source": [
    "#Create a game with coherence time of .001 seconds\n",
    "g_high_coherence = Game(coh = 1e-3)\n",
    "g_high_coherence.start(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "d96fe57b-ce1a-4bd9-b76a-558e3856eb41",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successfully entangled Alice and Bob's qubits 496 out of 1000 games.\n",
      "Won 779 out of 1000 games.\n"
     ]
    }
   ],
   "source": [
    "#Create a game with coherence time of .001 seconds and without guaranteed entanglement\n",
    "g_high_coherence = Game(coh = 1e-3, guarantee_entanglement = False)\n",
    "g_high_coherence.start(1000)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}