New FEU is now updated with tests

Author: Axel Dahlberg

qlinklayer/feu.py

@@ -113,15 +113,6 @@ def select_bright_state(self, min_fidelity):
 
         return None
 
-    def recalculate_estimate(self):
-        """
-        Recalculates and updates the stored fidelity estimate
-        :return: float
-            The recalculated fidelity estimate
-        """
-        self.estimated_fidelity = self._estimate_fidelity()
-        return self.estimated_fidelity
-
     def _estimate_fidelity(self, alphaA=None, alphaB=None):
         """
         Calculates the fidelity by extracting parameters from the mhp components, calculating an estimated state of
@@ -139,7 +130,7 @@ def _compute_total_detection_probabilities(self):
         what is the probability that a detector clicks at the midpoint.
         :return: tuple (p_det_A, p_det_B)
         """
-        mhp_conn = self.mhp_service.conn
+        mhp_conn = self.mhp_service.get_mhp_conn(self.node)
         total_det_effA = self._compute_total_detection_probability_of_node(mhp_conn.nodeA)
         total_det_effB = self._compute_total_detection_probability_of_node(mhp_conn.nodeB)
         return total_det_effA, total_det_effB
@@ -152,13 +143,14 @@ def _compute_total_detection_probability_of_node(self, node):
         """
         p_zero_phonon = node.qmem.photon_emission_noise.p_zero_phonon
         collection_eff = node.qmem.photon_emission_noise.collection_eff
-        if node == self.mhp_service.conn.nodeA:
-            p_loss = self.mhp_service.get_fibre_transmissivities(node)[0]
+        mhp_conn = self.mhp_service.get_mhp_conn(node)
+        if node == mhp_conn.nodeA:
+            p_no_loss = self.mhp_service.get_fibre_transmissivities(node)[0]
         else:
-            p_loss = self.mhp_service.get_fibre_transmissivities(node)[1]
-        detection_eff = self.mhp_service.conn.midpoint.detection_eff
+            p_no_loss = self.mhp_service.get_fibre_transmissivities(node)[1]
+        detection_eff = mhp_conn.midPoint.detection_eff
 
-        total_detection_eff = p_zero_phonon * collection_eff * (1 - p_loss) * detection_eff
+        total_detection_eff = p_zero_phonon * collection_eff * p_no_loss * detection_eff
 
         return total_detection_eff
 
@@ -179,7 +171,8 @@ def _compute_conditional_detection_probabilities(self, alphaA=None, alphaB=None)
             alphaB = alphaA
 
         p_det_A, p_det_B = self._compute_total_detection_probabilities()
-        p_dc = self.mhp_service.conn.midpoint.pdark
+        mhp_conn = self.mhp_service.get_mhp_conn(self.node)
+        p_dc = mhp_conn.midPoint.pdark
         # Dark count probabilities for both detectors
         p_no_dc = (1 - p_dc)**2
         p_at_least_one_dc = 1 - p_no_dc
@@ -208,27 +201,6 @@ def _estimate_success_probability(self, alphaA=None, alphaB=None):
         """
         return sum(self._compute_conditional_detection_probabilities(alphaA, alphaB))
 
-    def _extract_params(self):
-        """
-        Extracts parameters for fidelity estimation from the provided hardware such as midpoint detectors, fibre
-        properties, node state preparation, etc.
-        :return: Parameters to use for fidelity estimation
-        """
-        # Get the transmissivity info from the service
-        etaA, etaB = self.mhp_service.get_fibre_transmissivities(self.node)
-
-        # Get bright state info from the service (states are prepared in sqrt(1-alpha)|0> + sqrt(alpha)|1> so the
-        # probability of emission is simply alpha for both end nodes
-        alphaA, alphaB = self.mhp_service.get_bright_state_populations(self.node)
-
-        # Get the probability of a dark count at the midpoint
-        pdark = self.mhp_service.calculate_dark_count_probability(self.node)
-
-        # Get the dephasing photon parameter from the quantum memory device at our node
-        dp_photon = (1 - getattr(self.node.qmem.photon_emission_noise, '_dp_photon', 0))
-
-        return etaA, etaB, alphaA, alphaB, pdark, dp_photon
-
     def _calculate_estimated_state(self, alphaA=None, alphaB=None):
         """
         Calculates an estimated state based on the provided parameters.  See eq (8) in
@@ -237,11 +209,12 @@ def _calculate_estimated_state(self, alphaA=None, alphaB=None):
         :return: obj `~numpy.matrix`
             A density matrix of the estimated entangled state
         """
-        if self._estimate_success_probability(alphaA, alphaB) == 0:
-            raise LinkLayerException("Cannot estimate state when success probability is zero")
         p_uu, p_ud, p_du, p_dd = self._compute_conditional_detection_probabilities(alphaA, alphaB)
+        if (p_uu + p_ud + p_du + p_dd) == 0:
+            raise LinkLayerException("Cannot estimate state when success probability is zero")
 
-        visibility = self.mhp_service.conn.midpoint.visibility
+        mhp_conn = self.mhp_service.get_mhp_conn(self.node)
+        visibility = mhp_conn.midPoint.visibility
 
         ent_state = (p_ud * dm10 +  # |10><10| part
                      p_du * dm01 +  # |01><01| part

tests/test_feu.py

@@ -13,16 +13,15 @@
 
 
 class TestSingleClickFidelityEstimationUnit(unittest.TestCase):
-    def create_nodes(self, alice_device_positions, bob_device_positions):
-        # Set up Alice
-        aliceMemory = NVCommunicationDevice(name="AliceMem", num_positions=alice_device_positions)
-        alice = QuantumNode(name="Alice", nodeID=1, memDevice=aliceMemory)
-
-        # Set up Bob
-        bobMemory = NVCommunicationDevice(name="BobMem", num_positions=bob_device_positions)
-        bob = QuantumNode(name="Bob", nodeID=2, memDevice=bobMemory)
-
-        return alice, bob
+    def setUp(self):
+        # Setup MHP network and MHP service
+        network = setup_physical_network(ConfigPathStorage.NETWORK_NV_LAB_NOCAV_NOCONV)
+        alice = network.get_node_by_id(0)
+        bob = network.get_node_by_id(1)
+        self.mhp_conn = network.get_connection(alice, bob, "mhp_conn")
+        mhp_service = SimulatedNodeCentricMHPService("mhp_service", alice, bob, conn=self.mhp_conn)
+        self.feuA = SingleClickFidelityEstimationUnit(alice, mhp_service)
+        self.feuB = SingleClickFidelityEstimationUnit(alice, mhp_service)
 
     def test_dm_fidelity(self):
         # Basic test cases using bell states
@@ -52,103 +51,65 @@ def test_dm_fidelity(self):
         self.assertEqual(round(dm_fidelity(dm11, dm11, squared=True), ndigits=8), 1)
 
     def test_success_prob_est(self):
-        # Setup MHP network and MHP service
-        network = setup_physical_network(ConfigPathStorage.NETWORK_NV_LAB_NOCAV_NOCONV)
-        alice = network.get_node_by_id(0)
-        bob = network.get_node_by_id(1)
-        mhp_conn = network.get_connection(alice, bob, "mhp_conn")
-        mhp_service = SimulatedNodeCentricMHPService("mhp_service", alice, bob, conn=mhp_conn)
-        feu = SingleClickFidelityEstimationUnit(alice, mhp_service)
 
-        print(feu._estimate_success_probability())
+        with self.assertRaises(LinkLayerException):
+            self.feuA._estimate_success_probability()
+
+        # Should evaluate to total detection probability
+        p_succ = self.feuA._estimate_success_probability(1, 0)
+        self.assertAlmostEqual(p_succ, 4e-4, places=4)
+
+        # Test zero alpha
+        p_succ = self.feuA._estimate_success_probability(0)
+        self.assertAlmostEqual(p_succ, 0, places=4)
+
+        # Test linearity in alpha
+        for i in range(11):
+            alpha = i/20
+            p_succ = self.feuA._estimate_success_probability(alpha)
+            self.assertAlmostEqual(p_succ, 2 * alpha * (4e-4), places=4)
 
     def test_fidelity_estimation(self):
-        # Check various parameters against the estimation
-        etaA = 1       # Transmitivity of fibre from A to midpoint
-        etaB = 1       # Transmitivity of fibre from B to midpoint
-        alphaA = 0.5   # Bright state population at A
-        alphaB = 0.5   # Bright state population at B
-        pdark = 0      # Probability of a dark count at the midpoint
-        dp_photon = 1  # Dephasing parameter of the entangled qubit
-        ideal_state = kron(b01.H, b01)  # (|01> + |10>)(<01| + <10|)
-
-        # Check a lossless scenario with bright state populations of 1/2
-        estimated_state = SingleClickFidelityEstimationUnit._calculate_estimated_state(etaA, etaB, alphaA, alphaB,
-                                                                                       pdark, dp_photon)
-
-        estimated_fidelity = dm_fidelity(estimated_state, ideal_state, squared=True)
-        self.assertTrue(isclose(estimated_fidelity, 2 / 3))
-
-        # Check a lossless scenario with a dark count probability of 1/2
-        pdark = 0.5
-        estimated_state = SingleClickFidelityEstimationUnit._calculate_estimated_state(etaA, etaB, alphaA, alphaB,
-                                                                                       pdark, dp_photon)
-
-        estimated_fidelity = dm_fidelity(ideal_state, estimated_state, squared=True)
-        self.assertEqual(round(estimated_fidelity, ndigits=5), 0.5)
-
-        # Check that depolarizing the electron completely would estimate 0 fidelity with the desired state
-        dp_photon = 0
-        estimated_state = SingleClickFidelityEstimationUnit._calculate_estimated_state(etaA, etaB, alphaA, alphaB,
-                                                                                       pdark, dp_photon)
-
-        estimated_fidelity = dm_fidelity(ideal_state, estimated_state, squared=True)
-        self.assertEqual(estimated_fidelity, 0)
-
-        # Check that effectively setting chance of no clicks to zero yields a state with 0 fidelity to the ideal state
-        alphaA = 1
-        alphaB = 1
-        estimated_state = SingleClickFidelityEstimationUnit._calculate_estimated_state(etaA, etaB, alphaA, alphaB,
-                                                                                       pdark, dp_photon)
-
-        estimated_fidelity = dm_fidelity(ideal_state, estimated_state, squared=True)
-        self.assertEqual(estimated_fidelity, 0)
-
-        # Test a few extreme cases
-        # Transmitivity of the fibres from a and b are 0 (imagine someone cuts the fibre)
-        with self.assertRaises(EasySquidException):
-            SingleClickFidelityEstimationUnit._calculate_estimated_state(etaA=0, etaB=0, alphaA=0, alphaB=0, pdark=0,
-                                                                         dp_photon=0)
-
-        with self.assertRaises(EasySquidException):
-            SingleClickFidelityEstimationUnit._calculate_estimated_state(etaA=0, etaB=0, alphaA=1, alphaB=1, pdark=0,
-                                                                         dp_photon=0)
-
-        # Probability of a dark count is 1, effectively never get single clicks
-        with self.assertRaises(EasySquidException):
-            SingleClickFidelityEstimationUnit._calculate_estimated_state(etaA=1, etaB=1, alphaA=1, alphaB=1, pdark=1,
-                                                                         dp_photon=0)
+        # Both electrons excited
+        self.assertAlmostEqual(self.feuA._estimate_fidelity(1), 0, places=4)
+
+        # No excitation (all dark counts)
+        self.assertAlmostEqual(self.feuA._estimate_fidelity(0), 0, places=4)
+
+        # Check linearity in alpha (for high enough alpha due to dark counts)
+        for i in range(40, 100):
+            alpha = i/200
+            F = self.feuA._estimate_fidelity(alpha)
+            self.assertAlmostEqual(F, 1 - alpha, places=1)
+
+        # Perfect entanglement when no dark counts
+        self.mhp_conn.midPoint.pdark = 0
+        self.assertAlmostEqual(self.feuA._estimate_fidelity(0.00001), 1, places=1)
+
+        with self.assertRaises(LinkLayerException):
+            self.feuA._calculate_estimated_state(0)
 
     def test_minimum_fidelities(self):
-        nodeA, nodeB = self.create_nodes(1, 1)
-        mhp_service = SimulatedNodeCentricMHPService("mhp_service", nodeA, nodeB)
-        feuA = SingleClickFidelityEstimationUnit(nodeA, mhp_service)
-        feuB = SingleClickFidelityEstimationUnit(nodeB, mhp_service)
-
-        self.assertTrue(isclose(feuA.estimated_fidelity, 0.9473684210526312))
-        self.assertTrue(isclose(feuB.estimated_fidelity, 0.9473684210526312))
-        self.assertEqual(feuA.achievable_fidelities, feuB.achievable_fidelities)
-        self.assertEqual(feuA.achievable_fidelities[0][0], 0.1)
-        self.assertTrue(isclose(feuA.achievable_fidelities[0][1], 0.9473684210526312))
-        self.assertEqual(feuA.achievable_fidelities[1][0], 0.3)
-        self.assertTrue(isclose(feuA.achievable_fidelities[1][1], 0.8235294278458571))
-
-        self.assertTrue(isclose(feuA.get_max_fidelity(), 0.9473684210526312))
-
-        protoA = mhp_service.get_node_proto(nodeA)
+
+        self.assertEqual(self.feuA.achievable_fidelities, self.feuB.achievable_fidelities)
+        self.assertEqual(self.feuA.achievable_fidelities[0][0], 0.1)
+        self.assertTrue(isclose(self.feuA.achievable_fidelities[0][1], 0.8614038170052276))
+        self.assertEqual(self.feuA.achievable_fidelities[1][0], 0.3)
+        self.assertTrue(isclose(self.feuA.achievable_fidelities[1][1], 0.6800331800062903))
+
+        self.assertTrue(isclose(self.feuA.get_max_fidelity(), 0.8614038170052276))
+
+        protoA = self.feuA.mhp_service.get_node_proto(self.feuA.node)
         protoA.set_allowed_bright_state_populations([0.1, 0.2])
 
         with self.assertRaises(LinkLayerException):
-            feuA._calculate_achievable_fidelities()
+            self.feuA._calculate_achievable_fidelities()
 
     def test_get_bright_state(self):
-        nodeA, nodeB = self.create_nodes(1, 1)
-        mhp_service = SimulatedNodeCentricMHPService("mhp_service", nodeA, nodeB)
-        feuA = SingleClickFidelityEstimationUnit(nodeA, mhp_service)
-
-        self.assertEqual(feuA.select_bright_state(0.9), 0.1)
-        self.assertEqual(feuA.select_bright_state(0.8), 0.3)
-        self.assertEqual(feuA.select_bright_state(0.95), None)
+        self.assertEqual(self.feuA.select_bright_state(0.9), None)
+        self.assertEqual(self.feuA.select_bright_state(0.8), 0.1)
+        self.assertEqual(self.feuA.select_bright_state(0.7), 0.1)
+        self.assertEqual(self.feuA.select_bright_state(0.6), 0.3)
 
 
 if __name__ == '__main__':