




from __future__ import annotations




def 					SCREAMING_SNAKE_CASE	(       __UpperCamelCase			:						float | int       ,     __UpperCamelCase			:						float | int       ,     __UpperCamelCase			:						float | int       ,     )  ->							list[float | int]:
    if not all((nth_term, start_term_a, common_ratio_r)      ):
        return []
    UpperCAmelCase_							 =     []
    UpperCAmelCase_							 =     1
    UpperCAmelCase_							 =     common_ratio_r
    for _ in range(int(__UpperCamelCase      )      ):
        if not series:
            series.append(__UpperCamelCase      )
        else:
            power += 1
            series.append(float(start_term_a * multiple      )      )
            UpperCAmelCase_							 =     pow(float(__UpperCamelCase      )       ,     __UpperCamelCase      )
    return series


if __name__ == "__main__":
 import doctest

 doctest.testmod()

 _lowerCamelCase			 =						float(input('Enter the last number (n term) of the Geometric Series'))
 _lowerCamelCase			 =						float(input('Enter the starting term (a) of the Geometric Series'))
 _lowerCamelCase			 =						float(
     input('Enter the common ratio between two terms (r) of the Geometric Series')
 )
 print('Formula of Geometric Series => a + ar + ar^2 ... +ar^n')
 print(geometric_series(nth_term, start_term_a, common_ratio_r))











import math

import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute




def 					SCREAMING_SNAKE_CASE	(       __UpperCamelCase			:						int = 1       ,     __UpperCamelCase			:						int = 1      )  ->							qiskit.result.counts.Counts:
    if isinstance(__UpperCamelCase       ,     __UpperCamelCase      ) or isinstance(__UpperCamelCase       ,     __UpperCamelCase      ):
        raise TypeError('''inputs must be integers.'''      )
    if (bit_a < 0) or (bit_a < 0):
        raise ValueError('''inputs must be positive.'''      )
    if (math.floor(__UpperCamelCase      ) != bit_a) or (math.floor(__UpperCamelCase      ) != bit_a):
        raise ValueError('''inputs must be exact integers.'''      )
    if (bit_a > 1) or (bit_a > 1):
        raise ValueError('''inputs must be less or equal to 1.'''      )

    # build registers
    UpperCAmelCase_							 =     QuantumRegister(2       ,     '''qr'''      )
    UpperCAmelCase_							 =     ClassicalRegister(2       ,     '''cr'''      )

    UpperCAmelCase_							 =     QuantumCircuit(__UpperCamelCase       ,     __UpperCamelCase      )

    # entanglement the qubits
    quantum_circuit.h(1      )
    quantum_circuit.cx(1       ,     0      )

    # send the information
    UpperCAmelCase_							 =     str(__UpperCamelCase      ) + str(__UpperCamelCase      )

    if c_information == "11":
        quantum_circuit.x(1      )
        quantum_circuit.z(1      )
    elif c_information == "10":
        quantum_circuit.z(1      )
    elif c_information == "01":
        quantum_circuit.x(1      )
    else:
        quantum_circuit.i(1      )

    # unentangled the circuit
    quantum_circuit.cx(1       ,     0      )
    quantum_circuit.h(1      )

    # measure the circuit
    quantum_circuit.measure(__UpperCamelCase       ,     __UpperCamelCase      )

    UpperCAmelCase_							 =     Aer.get_backend('''aer_simulator'''      )
    UpperCAmelCase_							 =     execute(__UpperCamelCase       ,     __UpperCamelCase       ,     shots=1000      )

    return job.result().get_counts(__UpperCamelCase      )


if __name__ == "__main__":
 print(F"Counts for classical state send: {superdense_coding(1,1)}")





