

'''simple docstring'''



import math

import numpy as np
import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute


def A				(__lowerCamelCase				:int = 3		):





						if isinstance(_snake_case			,     _snake_case		):
												raise TypeError("""number of qubits must be a integer."""		)
						if number_of_qubits <= 0:
												raise ValueError("""number of qubits must be > 0."""		)
						if math.floor(_snake_case		) != number_of_qubits:
												raise ValueError("""number of qubits must be exact integer."""		)
						if number_of_qubits > 10:
												raise ValueError("""number of qubits too large to simulate(>10)."""		)

						_lowerCAmelCase  						=			QuantumRegister(_snake_case			,     """qr"""		)
						_lowerCAmelCase  						=			ClassicalRegister(_snake_case			,     """cr"""		)

						_lowerCAmelCase  						=			QuantumCircuit(_snake_case			,     _snake_case		)

						_lowerCAmelCase  						=			number_of_qubits

						for i in range(_snake_case		):
												quantum_circuit.h(number_of_qubits - i - 1		)
												counter -= 1
												for j in range(_snake_case		):
																		quantum_circuit.cp(np.pi / 2 ** (counter - j)			,     _snake_case			,     _snake_case		)

						for k in range(number_of_qubits // 2		):
												quantum_circuit.swap(_snake_case			,     number_of_qubits - k - 1		)

						# measure all the qubits
						quantum_circuit.measure(_snake_case			,     _snake_case		)
						# simulate with 10000 shots
						_lowerCAmelCase  						=			Aer.get_backend("""qasm_simulator"""		)
						_lowerCAmelCase  						=			execute(_snake_case			,     _snake_case			,     shots=10000		)

						return job.result().get_counts(_snake_case		)


if __name__ == "__main__":
						print(
						    F"""Total count for quantum fourier transform state is: \
    {quantum_fourier_transform(3)}"""
						)


'''simple docstring'''



import numpy as np
import qiskit


def A				(__lowerCamelCase				:int = 8			,     __lowerCamelCase				:int | None = None		):
						_lowerCAmelCase  						=			np.random.default_rng(seed=__lowerCamelCase		)

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

						# Quantum Circuit to simulate BB84
						_lowerCAmelCase  						=			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.
						_lowerCAmelCase  						=			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.
						_lowerCAmelCase  						=			qiskit.execute(__lowerCamelCase			,     __lowerCamelCase			,     shots=1			,     seed_simulator=__lowerCamelCase		)
						# Returns the result of measurement.
						_lowerCAmelCase  						=			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.
						_lowerCAmelCase  						=			"""""".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.
						_lowerCAmelCase  						=			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()
