import qiskit 
import qiskit.quantum_info as qiskit_quantum_info
import numpy as np
import matplotlib.pyplot as plt
np.set_printoptions(precision=3, suppress=True)
# "http://192.168.1.58:8000"

'http://192.168.1.58:8000'

nbqubits =2
qc = qiskit.QuantumCircuit(nbqubits)

qc.h(0)
# qc.cx(0,1)
# qc.x(0)

qc.crx(np.pi/3,0,1)
# qc.rx(np.pi/3,1)

statevector = qiskit_quantum_info.Statevector.from_instruction(qc)
print(statevector.data)
print(statevector.probabilities())

labels=['00','10','01','11']
plt.bar(range(2**nbqubits), statevector.probabilities())
plt.xticks(range(2**nbqubits),labels=labels)
qc.draw(output='mpl')

[0.707+0.j    0.612+0.j    0.   +0.j    0.   -0.354j]
[0.5   0.375 0.    0.125]

I = np.array([[1,0],[0,1]])
# print(I)
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
# print(H @ I)
# print(np.kron(I,I))
ket0 = np.array([1,0])
ket00 = np.kron(ket0,ket0)
print(ket00)

CNOT = np.array([[1,0,0,0],
                 [0,1,0,0],
                 [0,0,0,1],
                 [0,0,1,0]])

qs = ket00
qs =np.kron(H,I) @ qs
qs =CNOT @ qs
print(qs)

probas = np.abs(qs)**2
print(probas)

[1 0 0 0]
[0.707 0.    0.    0.707]
[0.5 0.  0.  0.5]

class QiskitRegister:
    def __init__(self,nbqubits:int):
        self.nbqubits = nbqubits
        self.qc = qiskit.QuantumCircuit(nbqubits)
        # print('init',self.nbqubits)
    def h(self,qubit):
        # print('h', qubit)
        self.qc.h(self.nbqubits - qubit -1)
    def qstate(self):
        return qiskit_quantum_info.Statevector.from_instruction(self.qc).data
    def probas(self):
        return qiskit_quantum_info.Statevector.from_instruction(self.qc).probabilities()
    def _rev(self,qubit):
        return self.nbqubits-qubit-1
    def x(self,qubit:int):
        self.qc.x(self._rev(qubit))
    def cnot(self,q0,q1):
        self.qc.cx(self._rev(q0),self._rev(q1))  
    def _swap(self,qubit):
        if not qubit < self.nbqubits-1: 
            print("QISKIT ERROR!!!")
        self.qc.swap(self._rev(qubit),self._rev(qubit+1))
          
        
                    
qiskitR = QiskitRegister(2)
qiskitR.h(0)
qiskitR.cnot(0,1)

print(qiskitR.qstate())
print(qiskitR.probas())
qiskitR.qc.draw(output='mpl', reverse_bits=True)

[0.707+0.j 0.   +0.j 0.   +0.j 0.707+0.j]
[0.5 0.  0.  0.5]

class QucvRegister:
    def __init__(self,nbqubits:int):
        self.nbqubits = nbqubits
        self._qs = np.zeros(2**nbqubits,dtype='complex')
        self._qs[0]=1
    def qstate(self):
        return self._qs
    def probas(self):
        return np.abs(self._qs)**2     
    def h(self,qubit):
        H = np.array([[1,1],[1,-1]])/np.sqrt(2)
        I = np.array([[1,0],[0,1]])
        M = H
        for _ in range(qubit): 
            M = np.kron(I,M)   
        # M = I kr I kr I kr H   (qubit ==3)  
        for _ in range(self.nbqubits-qubit-1):
            M = np.kron(M,I)
        # M = I kr I kr I kr H kr I kr I  (qubit ==3, nbqubits =6)  
        self._qs= M @ self._qs
    def _1gate(self,qubit,gate):
        I = np.array([[1,0],[0,1]])
        M = gate
        for _ in range(qubit): 
            M = np.kron(I,M)
        for _ in range(self.nbqubits-qubit-1):
            M = np.kron(M,I)
        self._qs= M @ self._qs        
    def x(self,qubit):
        X=np.array([[0,1],[1,0]])
        self._1gate(qubit,X)    
    def rx(self,t,qubit):
        m = np.array([[np.cos(t/2),-1j*np.sin(t/2)],
                      [-1j*np.sin(t/2),np.cos(t/2)]])
        self._1gate(qubit,m)       
    def _swap(self,qubit):
        if not qubit<self.nbqubits-1: 
            print("QUCV ERROR!!!")
            return
        SWAP = np.array([[1,0,0,0],
                         [0,0,1,0],
                         [0,1,0,0],
                         [0,0,0,1]])
        I = np.array([[1,0],[0,1]])
        M = SWAP
        for _ in range(qubit): 
            M = np.kron(I,M)
        for _ in range(self.nbqubits-qubit-2):
            M = np.kron(M,I)
        self._qs= M @ self._qs
    def _2gates(self,q0,q1,gate):
        if not q0<q1: 
            print("not q0<q1")
            # return
            SWAP = np.array([[1,0,0,0],[0,0,1,0],[0,1,0,0],[0,0,0,1]])
            q0,q1 = q1,q0
            gate = SWAP @ gate @ SWAP

        for q in range(q1-1,q0,-1):
            self._swap(q)
        I = np.array([[1,0],[0,1]])
        M = gate
        for _ in range(q0): 
            M = np.kron(I,M)
        for _ in range(self.nbqubits-q0-2):
            M = np.kron(M,I)
        self._qs= M @ self._qs        
        for q in range(q0+1,q1):
            self._swap(q)
    def cnot(self,q0,q1):
        CNOT = np.array([[1,0,0,0],[0,1,0,0],[0,0,0,1],[0,0,1,0]])
        self._2gates(q0,q1,CNOT)    
    def crx(self,t,q0,q1):
        m = np.array([[1,0,0,0],[0,1,0,0],
                      [0,0,np.cos(t/2),-1j*np.sin(t/2)],
                      [0,0,-1j*np.sin(t/2),np.cos(t/2)]])
        self._2gates(q0,q1,m)
    def shots(self,nbshots):
        return np.random.multinomial(nbshots, self.probas())



                 
qucvR = QucvRegister(2)
qucvR.h(0)
qucvR.cnot(0,1)

# print(qucvR.qstate())
# print(qucvR.probas())       
print(qucvR.shots(1000))       

[487   0   0 513]

QRegister = QucvRegister
qname = "qucv"
qstate = []
for _ in range(2):
    print('simulador',qname)
    qregister = QRegister(2)
    # qregister.x(1)
    # qregister._swap(0)
    qregister.h(0)
    qregister.cnot(0,1)
    qstate.append(qregister.qstate())
    QRegister = QiskitRegister
    qname = "qiskit"
    
if np.array_equal( qstate[0],qstate[1]):
    print('good')
else:
    print('ERROR !!!!!!!!!!!!!!!!!!!!')
print('qucv',qstate[0])
print('qiskit',qstate[1])

simulador qucv
simulador qiskit
good
qucv [0.707+0.j 0.   +0.j 0.   +0.j 0.707+0.j]
qiskit [0.707+0.j 0.   +0.j 0.   +0.j 0.707+0.j]