




import math

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

def 					UpperCAmelCase_							(      __UpperCAmelCase						:	int = 3							)					-> qiskit.result.counts.Counts:
      if isinstance(__UpperCAmelCase			,			__UpperCAmelCase							):
            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(__UpperCAmelCase							) != 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).'							)

      SCREAMING_SNAKE_CASE_							=			QuantumRegister(__UpperCAmelCase			,			'qr'							)
      SCREAMING_SNAKE_CASE_							=			ClassicalRegister(__UpperCAmelCase			,			'cr'							)

      SCREAMING_SNAKE_CASE_							=			QuantumCircuit(__UpperCAmelCase			,			__UpperCAmelCase							)

      SCREAMING_SNAKE_CASE_							=			number_of_qubits

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

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

      # measure all the qubits
      quantum_circuit.measure(__UpperCAmelCase			,			__UpperCAmelCase							)
      # simulate with 10000 shots
      SCREAMING_SNAKE_CASE_							=			Aer.get_backend('qasm_simulator'							)
      SCREAMING_SNAKE_CASE_							=			execute(__UpperCAmelCase			,			__UpperCAmelCase			,			shots=1_00_00							)

      return job.result().get_counts(__UpperCAmelCase							)


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





from math import sqrt

def 					UpperCAmelCase_							(      __UpperCAmelCase						:	int							)					-> bool:

      if 1 < number < 4:
            # 2 and 3 are primes
            return True
      elif number < 2 or number % 2 == 0 or number % 3 == 0:
            # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
            return False

      # All primes number are in format of 6k +/- 1
      for i in range(5			,			int(sqrt(__UpperCAmelCase							) + 1							)			,			6							):
            if number % i == 0 or number % (i + 2) == 0:
                  return False
      return True

def 					UpperCAmelCase_							(      __UpperCAmelCase						:	int = 1_00_01							)					-> int:
      SCREAMING_SNAKE_CASE_							=			0
      SCREAMING_SNAKE_CASE_							=			1
      while count != nth and number < 3:
            number += 1
            if is_prime(__UpperCAmelCase							):
                  count += 1
      while count != nth:
            number += 2
            if is_prime(__UpperCAmelCase							):
                  count += 1
      return number


if __name__ == "__main__":
   print(f'''{solution() = }''')