




"""simple docstring"""




from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


__A :		Optional[Any]      							=    {
    '''configuration_gptsan_japanese''': ['''GPTSAN_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''GPTSanJapaneseConfig'''],
    '''tokenization_gptsan_japanese''': ['''GPTSanJapaneseTokenizer'''],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __A :		str      							=    [
      '''GPTSAN_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST''',
      '''GPTSanJapaneseForConditionalGeneration''',
      '''GPTSanJapaneseModel''',
      '''GPTSanJapanesePreTrainedModel''',
  ]
  __A :		Optional[Any]      							=    [
      '''GPTSanJapaneseTokenizer''',
  ]


if TYPE_CHECKING:
  from .configuration_gptsan_japanese import GPTSAN_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTSanJapaneseConfig
  from .tokenization_gptsan_japanese import GPTSanJapaneseTokenizer

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_gptsan_japanese import (
        GPTSAN_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST,
        GPTSanJapaneseForConditionalGeneration,
        GPTSanJapaneseModel,
        GPTSanJapanesePreTrainedModel,
    )
    from .tokenization_gptsan_japanese import GPTSanJapaneseTokenizer


else:
  import sys

  __A :		List[Any]      							=    _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)










"""simple docstring"""




import numpy as np
import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute
def 					A_			(		snake_case_     :       float = np.pi / 2						,snake_case_     :       float = np.pi / 2						,snake_case_     :       float = np.pi / 2    ):







    '''simple docstring'''
    UpperCamelCase				:   Union[str, Any]          =							QuantumRegister(3						,"""qr"""    )  # Define the number of quantum bits
    UpperCamelCase				:   Any          =							ClassicalRegister(1						,"""cr"""    )  # Define the number of classical bits

    UpperCamelCase				:   Any          =							QuantumCircuit(snake_case_						,snake_case_    )  # Define the quantum circuit.

    # Build the circuit
    quantum_circuit.u(snake_case_						,snake_case_						,snake_case_						,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
    UpperCamelCase				:   Tuple          =							Aer.get_backend("""aer_simulator"""    )
    UpperCamelCase				:   Any          =							execute(snake_case_						,snake_case_						,shots=1_0_0_0    )

    return job.result().get_counts(snake_case_    )


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




