


'''simple docstring'''






import numpy as np
import qiskit






def 	_A				(lowerCAmelCase__  :int = 8				,						lowerCAmelCase__  :int | None = None		)   ->  str:




					'''simple docstring'''



					_a			      =							np.random.default_rng(seed=lowerCAmelCase__		)

					# Roughly 25% of the qubits will contribute to the key.
					# So we take more than we need.
					_a			      =							6 * key_len
					# Measurement basis for Alice's qubits.
					_a			      =							rng.integers(2				,						size=lowerCAmelCase__		)
					# The set of states Alice will prepare.
					_a			      =							rng.integers(2				,						size=lowerCAmelCase__		)
					# Measurement basis for Bob's qubits.
					_a			      =							rng.integers(2				,						size=lowerCAmelCase__		)

					# Quantum Circuit to simulate BB84
					_a			      =							qiskit.QuantumCircuit(lowerCAmelCase__				,						name='BB84'		)

					# Alice prepares her qubits according to rules above.
					for index, _ in enumerate(lowerCAmelCase__		):
										if alice_state[index] == 1:
															bbaa_circ.x(lowerCAmelCase__		)
										if alice_basis[index] == 1:
															bbaa_circ.h(lowerCAmelCase__		)
					bbaa_circ.barrier()

					# Bob measures the received qubits according to rules above.
					for index, _ in enumerate(lowerCAmelCase__		):
										if bob_basis[index] == 1:
															bbaa_circ.h(lowerCAmelCase__		)

					bbaa_circ.barrier()
					bbaa_circ.measure_all()

					# Simulate the quantum circuit.
					_a			      =							qiskit.Aer.get_backend('aer_simulator'		)
					# We only need to run one shot because the key is unique.
					# Multiple shots will produce the same key.
					_a			      =							qiskit.execute(lowerCAmelCase__				,						lowerCAmelCase__				,						shots=1				,						seed_simulator=lowerCAmelCase__		)
					# Returns the result of measurement.
					_a			      =							job.result().get_counts(lowerCAmelCase__		).most_frequent()

					# Extracting the generated key from the simulation results.
					# Only keep measurement results where Alice and Bob chose the same basis.
					_a			      =							''.join(
					    [
					        result_bit
					        for alice_basis_bit, bob_basis_bit, result_bit in zip(
					            lowerCAmelCase__				,						lowerCAmelCase__				,						lowerCAmelCase__		)
					        if alice_basis_bit == bob_basis_bit
					    ]		)

					# Get final key. Pad with 0 if too short, otherwise truncate.
					_a			      =							gen_key[:key_len] if len(lowerCAmelCase__		) >= key_len else gen_key.ljust(lowerCAmelCase__				,						'0'		)
					return key


if __name__ == "__main__":
	print(f'''The generated key is : {bbaa(8, seed=0)}''')
	from doctest import testmod

	testmod()





'''simple docstring'''






def 	_A				(lowerCAmelCase__  :Union[str, Any]		)   ->  List[str]:




     '''simple docstring'''



     return [
         {
             0: [1, 2],
             1: [0, 2],
             2: [0, 1, 3, 5],
             3: [2, 4],
             4: [3],
             5: [2, 6, 8],
             6: [5, 7],
             7: [6, 8],
             8: [5, 7],
         },
         {
             0: [6],
             1: [9],
             2: [4, 5],
             3: [4],
             4: [2, 3],
             5: [2],
             6: [0, 7],
             7: [6],
             8: [],
             9: [1],
         },
         {
             0: [4],
             1: [6],
             2: [],
             3: [5, 6, 7],
             4: [0, 6],
             5: [3, 8, 9],
             6: [1, 3, 4, 7],
             7: [3, 6, 8, 9],
             8: [5, 7],
             9: [5, 7],
         },
         {
             0: [1, 3],
             1: [0, 2, 4],
             2: [1, 3, 4],
             3: [0, 2, 4],
             4: [1, 2, 3],
         },
     ][index]






def 	_A				(lowerCAmelCase__  :dict[int, list[int]]		)   ->  list[tuple[int, int]]:




     '''simple docstring'''



     _a			      =							0
     _a			      =							len(lowerCAmelCase__		)  # No of vertices in graph
     _a			      =							[0] * n
     _a			      =							[False] * n

     def dfs(lowerCAmelCase__  :Dict				,						lowerCAmelCase__  :str				,						lowerCAmelCase__  :Dict				,						lowerCAmelCase__  :Union[str, Any]		):
          _a			      =							True
          _a			      =							id_
          id_ += 1
          for to in graph[at]:
               if to == parent:
                    pass
               elif not visited[to]:
                    dfs(lowerCAmelCase__				,						lowerCAmelCase__				,						lowerCAmelCase__				,						id_		)
                    _a			      =							min(low[at]				,						low[to]		)
                    if id_ <= low[to]:
                         bridges.append((at, to) if at < to else (to, at)		)
               else:
                    # This edge is a back edge and cannot be a bridge
                    _a			      =							min(low[at]				,						low[to]		)

     _a			      =							[]
     for i in range(lowerCAmelCase__		):
          if not visited[i]:
               dfs(lowerCAmelCase__				,						-1				,						lowerCAmelCase__				,						id_		)
     return bridges


if __name__ == "__main__":
 import doctest

 doctest.testmod()

