

"""simple docstring"""





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




def     _A    (    UpperCamelCase_	:			float = np.pi / 2,     UpperCamelCase_	:			float = np.pi / 2,     UpperCamelCase_	:			float = np.pi / 2)      ->		qiskit.result.counts.Counts:
   '''simple docstring'''


   __lowercase								=		QuantumRegister(3,     "qr")  # Define the number of quantum bits
   __lowercase								=		ClassicalRegister(1,     "cr")  # Define the number of classical bits

   __lowercase								=		QuantumCircuit(UpperCamelCase_,     UpperCamelCase_)  # Define the quantum circuit.

   # Build the circuit
   quantum_circuit.u(UpperCamelCase_,     UpperCamelCase_,     UpperCamelCase_,     0)  # Quantum State to teleport
   quantum_circuit.h(1)  # add hadamard gate
   quantum_circuit.cx(
       1,     2)  # add control gate with qubit 1 as control and 2 as target.
   quantum_circuit.cx(0,     1)
   quantum_circuit.h(0)
   quantum_circuit.cz(0,     2)  # add control z gate.
   quantum_circuit.cx(1,     2)

   quantum_circuit.measure([2],     [0])  # measure the qubit.

   # Simulate the circuit using qasm simulator
   __lowercase								=		Aer.get_backend("aer_simulator")
   __lowercase								=		execute(UpperCamelCase_,     UpperCamelCase_,     shots=1000)

   return job.result().get_counts(UpperCamelCase_)


if __name__ == "__main__":
   print(
       'Total count for teleported state is: '
       F"{quantum_teleportation(np.pi/2, np.pi/2, np.pi/2)}"
   )







"""simple docstring"""





def     _A    (    UpperCamelCase_	:			int,     UpperCamelCase_	:			int = 1000)      ->		str:
   '''simple docstring'''


   if (not isinstance(UpperCamelCase_,     UpperCamelCase_)) or (digit_position <= 0):
      raise ValueError("Digit position must be a positive integer")
   elif (not isinstance(UpperCamelCase_,     UpperCamelCase_)) or (precision < 0):
      raise ValueError("Precision must be a nonnegative integer")

   # compute an approximation of (16 ** (n - 1)) * pi whose fractional part is mostly
   # accurate
   __lowercase								=		(
       4 * _subsum(UpperCamelCase_,     1,     UpperCamelCase_)
       - 2 * _subsum(UpperCamelCase_,     4,     UpperCamelCase_)
       - _subsum(UpperCamelCase_,     5,     UpperCamelCase_)
       - _subsum(UpperCamelCase_,     6,     UpperCamelCase_)
   )

   # return the first hex digit of the fractional part of the result
   return hex(int((sum_result % 1) * 16))[2:]




def     _A    (    UpperCamelCase_	:			int,     UpperCamelCase_	:			int,     UpperCamelCase_	:			int)      ->		float:
   '''simple docstring'''


   __lowercase								=		0.0
   for sum_index in range(digit_pos_to_extract + precision):
      __lowercase								=		8 * sum_index + denominator_addend
      if sum_index < digit_pos_to_extract:
         # if the exponential term is an integer and we mod it by the denominator
         # before dividing, only the integer part of the sum will change;
         # the fractional part will not
         __lowercase								=		pow(
             16,     digit_pos_to_extract - 1 - sum_index,     UpperCamelCase_)
      else:
         __lowercase								=		pow(16,     digit_pos_to_extract - 1 - sum_index)
      total += exponential_term / denominator
   return total


if __name__ == "__main__":
   import doctest

   doctest.testmod()




