update formatting for purification config for archival purposes

Author: Naphann

quisp/simulations/purification-config-generator.py

@@ -12,7 +12,7 @@ def get_channel_error_from_link_werner_noise(fidelity, dist_in_km) -> float:
     """
     left: float = 0.0
     right: float = 0.3
-    l: float = 0.04500741397
+    l: float = 0.04500741397 # this is the fixed loss probability per kilometer (coming from ~0.2 dB/km)
     iter_count = 0
     while left < right:
         p = (left + right) / 2
@@ -26,23 +26,24 @@ def get_channel_error_from_link_werner_noise(fidelity, dist_in_km) -> float:
                 [p, 1 - 3 * p - l, p, p, l],
                 [p, p, 1 - 3 * p - l, p, l],
                 [p, p, p, 1 - 3 * p - l, l],
-                [0, 0, 0, 0, 1]
+                [0, 0, 0, 0, 1],
             ]
         )
         Qt = Q**dist_in_km
-        calculated_f = (Qt[0, 0] / (Qt[0, 0] + Qt[0, 1] + Qt[0, 2] + Qt[0, 3]))
+        calculated_f = Qt[0, 0] / (Qt[0, 0] + Qt[0, 1] + Qt[0, 2] + Qt[0, 3])
         if calculated_f > fidelity:
             left = p
         else:
             right = p
         if round(calculated_f, 10) == round(fidelity, 10):
             break
-    print(f"we got p = {p}")
-    print(f"    expected: {fidelity}")
-    print(f"    obtained: {calculated_f}")
+    print(f"we got p (fiber error)= {p}")
+    print(f"    expected fidelity (input): {fidelity}")
+    print(f"    obtained from calculation: {calculated_f}")
     print(f" {Qt}")
     return p
 
+
 def get_fidelity_from_target_bsm_swap(f):
     left: float = 0.0
     right: float = 1
@@ -53,7 +54,7 @@ def get_fidelity_from_target_bsm_swap(f):
         if iter_count > 100:
             print("exceed max iteration")
             break
-        fn = p**2 + 3 * ((1 - p)/3) ** 2
+        fn = p**2 + 3 * ((1 - p) / 3) ** 2
         if fn > f:
             right = p
         else:
@@ -70,7 +71,9 @@ def bds_werner_swap(fa, fb):
     f = fa * fb + 3 * (1 - fa) * (1 - fb)
     return f
 
+
 def get_p_from_decoherence_time(decoherence_time_mu_s: int) -> float:
+    # Although QuISP allows for relaxation/excitation noise, we do not include it here.
     left: float = 0.0
     right: float = 0.3
     iter_count = 0
@@ -80,30 +83,41 @@ def get_p_from_decoherence_time(decoherence_time_mu_s: int) -> float:
         if iter_count > 100:
             print("exceed max iteration")
             break
-        Q = np.matrix([[1 - 3 * p, p, p, p], [p, 1 - 3 * p, p, p], [p, p, 1 - 3 * p, p], [p, p, p, 1 - 3 * p]])
+        Q = np.matrix(
+            [
+                [1 - 3 * p, p, p, p],
+                [p, 1 - 3 * p, p, p],
+                [p, p, 1 - 3 * p, p],
+                [p, p, p, 1 - 3 * p],
+            ]
+        )
         Qt = Q**decoherence_time_mu_s
         if Qt[0, 0] > 1 / np.e:
             left = p
         else:
             right = p
         if round(Qt[0, 0], 10) == round(1 / np.e, 10):
             break
-    print(f"we got p = {p}")
-    print(f"    expected: {1/np.e}")
-    print(f"    obtained: {Qt[0, 0]}")
+    print(f"we got p (memory) = {p}")
+    print(f"    expected (fidelity has decohere): {1/np.e}")
+    print(f"    obtained after T time has passed: {Qt[0, 0]}")
     return p
 
-def get_error_param_balanced_mim_werner(link_fidelity, half_distance, coherence_time_mu_s):
+
+def get_error_param_balanced_mim_werner(
+    link_fidelity, half_distance, coherence_time_mu_s
+):
     p_mem_per_mu_s = get_p_from_decoherence_time(coherence_time_mu_s)
     mem_transition_mat = q = np.matrix(
         [
             [1 - 3 * p_mem_per_mu_s, p_mem_per_mu_s, p_mem_per_mu_s, p_mem_per_mu_s],
             [p_mem_per_mu_s, 1 - 3 * p_mem_per_mu_s, p_mem_per_mu_s, p_mem_per_mu_s],
             [p_mem_per_mu_s, p_mem_per_mu_s, 1 - 3 * p_mem_per_mu_s, p_mem_per_mu_s],
             [p_mem_per_mu_s, p_mem_per_mu_s, p_mem_per_mu_s, 1 - 3 * p_mem_per_mu_s],
-        ])
-    total_q = mem_transition_mat ** half_distance
-    gen_time = half_distance * 2 / 208189.206944 * 1_000_000 # to mu s
+        ]
+    )
+    total_q = mem_transition_mat**half_distance
+    gen_time = half_distance * 2 / 208189.206944 * 1_000_000  # to mu s
 
     left: float = 0.0
     right: float = 0.3
@@ -115,8 +129,15 @@ def get_error_param_balanced_mim_werner(link_fidelity, half_distance, coherence_
             print("exceed max iteration")
             break
         # channel transition matrix
-        Q = np.matrix([[1 - 3 * p, p, p, p], [p, 1 - 3 * p, p, p], [p, p, 1 - 3 * p, p], [p, p, p, 1 - 3 * p]])
-        Qt = Q ** half_distance
+        Q = np.matrix(
+            [
+                [1 - 3 * p, p, p, p],
+                [p, 1 - 3 * p, p, p],
+                [p, p, 1 - 3 * p, p],
+                [p, p, p, 1 - 3 * p],
+            ]
+        )
+        Qt = Q**half_distance
         f = Qt[0, 0]
         f = bds_werner_swap(f, f)
 
@@ -142,7 +163,16 @@ def get_error_param_balanced_mim_werner(link_fidelity, half_distance, coherence_
 - output: fidelity of purified Bell pair following a successful purification, total time to obtain 500 purified Bell pairs
 - memory decoherence: 18ms, 55ms (Table 1 in QuNAP paper)
 """
-def generate_purification_experiment_config(num_bellpairs: int, cnot_error_prob: float, measurement_error_prob: float, with_depolarizing: bool, coherence_time_in_mu_s: int):
+
+
+def generate_purification_experiment_config(
+    num_bellpairs: int,
+    cnot_error_prob: float,
+    measurement_error_prob: float,
+    with_depolarizing: bool,
+    coherence_time_in_mu_s: int,
+):
+    """This function generates simulation config for experiment 4 in the paper with no memory decoherence."""
     # [Config mim_purification_20_20]
     # network = networks.cross_validation_mim_purification_20_20
     # **.qrsa.hm.link_tomography = true
@@ -197,12 +227,20 @@ def generate_purification_experiment_config(num_bellpairs: int, cnot_error_prob:
         "*.alice.is_initiator = true",
         "**.buffers = 2",
         f"**.app.number_of_bellpair = {num_bellpairs}",
-        f"**.qrsa.hm.num_measure = {num_bellpairs}"
+        f"**.qrsa.hm.num_measure = {num_bellpairs}",
     ]
     return [config_name, network_name, *error_params, *other_params]
 
 
-def generate_purification_experiment_config_with_initial_fidelity(num_bellpairs: int, cnot_error_prob: float, measurement_error_prob: float, initial_fidelity: float, with_depolarizing: bool, coherence_time_in_mu_s: int):
+def generate_purification_experiment_config_with_initial_fidelity(
+    num_bellpairs: int,
+    cnot_error_prob: float,
+    measurement_error_prob: float,
+    initial_fidelity: float,
+    with_depolarizing: bool,
+    coherence_time_in_mu_s: int,
+):
+    """This function generates simulation config for experiment 4 in the paper with no memory decoherence."""
     # [Config mim_purification_20_20]
     # network = networks.cross_validation_mim_purification_20_20
     # **.qrsa.hm.link_tomography = true
@@ -211,7 +249,9 @@ def generate_purification_experiment_config_with_initial_fidelity(num_bellpairs:
     # **.buffers = 1
 
     # TODO: make this changeable
-    channel_error_single_prob = get_channel_error_from_link_werner_noise(get_fidelity_from_target_bsm_swap(initial_fidelity), 20)
+    channel_error_single_prob = get_channel_error_from_link_werner_noise(
+        get_fidelity_from_target_bsm_swap(initial_fidelity), 20
+    )
 
     # round error probability to 3 decimal places
     cnot_error_prob = round(cnot_error_prob, 3)
@@ -227,7 +267,6 @@ def generate_purification_experiment_config_with_initial_fidelity(num_bellpairs:
     if len(measurement_error_prob_str) == 0:
         measurement_error_prob_str = "0"
 
-
     if with_depolarizing:
         if num_bellpairs != 100_000:
             config_name = f"[Config short_{num_bellpairs}_purification_validation_cnot_{cnot_error_prob_str}_meas_{measurement_error_prob_str}_with_decoherence_{coherence_time_in_mu_s}_ms_initial_fidelity_{initial_fid_str}]"
@@ -266,7 +305,7 @@ def generate_purification_experiment_config_with_initial_fidelity(num_bellpairs:
         "*.alice.is_initiator = true",
         "**.buffers = 2",
         f"**.app.number_of_bellpair = {num_bellpairs}",
-        f"**.qrsa.hm.num_measure = {num_bellpairs}"
+        f"**.qrsa.hm.num_measure = {num_bellpairs}",
     ]
     return [config_name, network_name, *error_params, *other_params]
 
@@ -287,32 +326,52 @@ def write_config(filename: str, configs: list[list[str]]):
             the_file.write("\n\n\n")
 
 
-memory_coherence_time_params = [18 * 1000, 55 * 1000] # in milliseconds
+memory_coherence_time_params = [18 * 1000, 55 * 1000]  # in milliseconds
 link_fidelities = list(np.linspace(0.6, 1, 21))
 
 config_no_error = generate_purification_experiment_config(100_000, 0, 0, False, 0)
-config_no_error_short_time = generate_purification_experiment_config(500, 0, 0, False, 0)
+config_no_error_short_time = generate_purification_experiment_config(
+    500, 0, 0, False, 0
+)
 # config_only_depolarizing_error = [generate_purification_experiment_config(100_000, 0, 0, True, dp) for dp in memory_coherence_time_params]
-config_purification_initial_fidelity_no_error = [generate_purification_experiment_config_with_initial_fidelity(100_000, 0, 0, fid, False, 0) for fid in link_fidelities]
-config_purification_initial_fidelity_no_error_short_time = [generate_purification_experiment_config_with_initial_fidelity(500, 0, 0, fid, False, 0) for fid in link_fidelities]
-
-config_purification_initial_fidelity_18ms = [generate_purification_experiment_config_with_initial_fidelity(100_000, 0, 0, fid, True, 18_000) for fid in link_fidelities]
-config_purification_initial_fidelity_55ms = [generate_purification_experiment_config_with_initial_fidelity(100_000, 0, 0, fid, True, 55_000) for fid in link_fidelities]
-
-config_purification_initial_fidelity_18ms_short = [generate_purification_experiment_config_with_initial_fidelity(500, 0, 0, fid, True, 18_000) for fid in link_fidelities]
-config_purification_initial_fidelity_55ms_short = [generate_purification_experiment_config_with_initial_fidelity(500, 0, 0, fid, True, 55_000) for fid in link_fidelities]
-
-
-# purification_config_no_operation_error = [generate_purification_experiment_config(gp, 0, False, coherence_time) for gp in np.arange(0, 1.00, 0.025)]
-
-# purification_config_gate_error = [generate_purification_experiment_config(gp, 0, False, coherence_time) for gp in np.arange(0, 1.00, 0.025)]
-# purification_config_gate_error_with_depo = [generate_purification_experiment_config(gp, 0, True, coherence_time) for gp in np.arange(0, 1.00, 0.025)]
-# purification_config_meas_error = [generate_purification_experiment_config(0, gp, False, coherence_time) for gp in np.arange(0, 1.00, 0.025)]
-# purification_config_meas_error_with_depo = [generate_purification_experiment_config(0, gp, True, coherence_time) for gp in np.arange(0, 1.00, 0.025)]
-
-# delete the duplicate config in the lists, "purification_validation_cnot_0_meas_0_"
-# purification_config_gate_error = purification_config_gate_error[1:]
-# purification_config_gate_error_with_depo = purification_config_gate_error_with_depo[1:]
+config_purification_initial_fidelity_no_error = [
+    generate_purification_experiment_config_with_initial_fidelity(
+        100_000, 0, 0, fid, False, 0
+    )
+    for fid in link_fidelities
+]
+config_purification_initial_fidelity_no_error_short_time = [
+    generate_purification_experiment_config_with_initial_fidelity(
+        500, 0, 0, fid, False, 0
+    )
+    for fid in link_fidelities
+]
+
+config_purification_initial_fidelity_18ms = [
+    generate_purification_experiment_config_with_initial_fidelity(
+        100_000, 0, 0, fid, True, 18_000
+    )
+    for fid in link_fidelities
+]
+config_purification_initial_fidelity_55ms = [
+    generate_purification_experiment_config_with_initial_fidelity(
+        100_000, 0, 0, fid, True, 55_000
+    )
+    for fid in link_fidelities
+]
+
+config_purification_initial_fidelity_18ms_short = [
+    generate_purification_experiment_config_with_initial_fidelity(
+        500, 0, 0, fid, True, 18_000
+    )
+    for fid in link_fidelities
+]
+config_purification_initial_fidelity_55ms_short = [
+    generate_purification_experiment_config_with_initial_fidelity(
+        500, 0, 0, fid, True, 55_000
+    )
+    for fid in link_fidelities
+]
 
 write_config(
     "cross_validation_config_generated.ini",
@@ -334,15 +393,3 @@ def write_config(filename: str, configs: list[list[str]]):
         # *purification_config_meas_error_with_depo,
     ],
 )
-
-# for tf in np.linspace(0.6, 1, 21):
-#     print('========================')
-#     print(f'target fidelity = {tf}')
-#     print(get_fidelity_from_target_bsm_swap(tf))
-#     print('========================\n\n')
-
-# for tf in np.linspace(0.76, 1, 21):
-#     print('========================')
-#     print(f'target fidelity = {tf}')
-#     print(get_channel_error_from_link_werner_noise(tf, 20))
-#     print('========================\n\n')