
def  __snake_case							(	__magic_name__		,    __magic_name__						):







				'''simple docstring'''


				_validate_point(_A						)
				_validate_point(_A						)
				if len(_A						) != len(_A						):
								raise ValueError("Both points must be in the same n-dimensional space"						)

				return float(sum(abs(a - b						) for a, b in zip(_A		,    _A						)						)						)

def  __snake_case							(	__magic_name__						):







				'''simple docstring'''


				if point:
								if isinstance(_A		,    _A						):
												for item in point:
																if not isinstance(_A		,    (int, float)						):
																				lowercase         =      (
																				    "Expected a list of numbers as input, found "
																				    F'''{type(_A						).__name__}'''
																				)
																				raise TypeError(_A						)
								else:
												lowercase         =      F'''Expected a list of numbers as input, found {type(_A						).__name__}'''
												raise TypeError(_A						)
				else:
								raise ValueError("Missing an input"						)

def  __snake_case							(	__magic_name__		,    __magic_name__						):







				'''simple docstring'''


				_validate_point(_A						)
				_validate_point(_A						)
				if len(_A						) != len(_A						):
								raise ValueError("Both points must be in the same n-dimensional space"						)

				return float(sum(abs(x - y						) for x, y in zip(_A		,    _A						)						)						)


if __name__ == "__main__":
						import doctest

						doctest.testmod()






import numpy as np
import qiskit


def 		lowerCamelCase__       (						_A = 8	,      _A = None				):







	'''simple docstring'''





	snake_case_						       =	np.random.default_rng(seed=_A				)

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

	# Quantum Circuit to simulate BB84
	snake_case_						       =	qiskit.QuantumCircuit(_A	,      name="BB84"				)

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

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

	bbaa_circ.barrier()
	bbaa_circ.measure_all()

	# Simulate the quantum circuit.
	snake_case_						       =	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.
	snake_case_						       =	qiskit.execute(_A	,      _A	,      shots=1	,      seed_simulator=_A				)
	# Returns the result of measurement.
	snake_case_						       =	job.result().get_counts(_A				).most_frequent()

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

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


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

		testmod()
