Notas de la versión de Qiskit 0.15

0.15.0

Terra 0.12.0

Preludio

La versión 0.12.0 incluye varias novedades y correcciones de errores. El mayor cambio de esta versión es la incorporación de pulsos paramétricos a OpenPulse. Son comandos de Pulso que toman parámetros en lugar de puntos de muestreo para describir un pulso. 0.12.0 es también la primera versión que incluye compatibilidad con Python 3.8. También marca el inicio de la eliminación del soporte para Python 3.5, que será retirado cuando la comunidad de desarrolladores deje de soportarlo.

Nuevas funciones

El pase qiskit.transpiler.passes.CSPLayout se ha ampliado con dos nuevos parámetros: call_limit y time_limit. Estas opciones permiten limitar la duración del pase. La opción call_limit limita el número de veces que se puede llamar a la función recursiva en el solucionador de backtracking. Del mismo modo, time_limit limita el tiempo (en segundos) de ejecución del solucionador. Los valores por defecto son 1000 llamadas y 10 segundos respectivamente.

qiskit.pulse.Acquire puede aplicarse ahora a un único qubit. Esto hace que la programación de pulsos sea más coherente y fácil de razonar, ya que ahora todas las operaciones se aplican a un único canal. Por ejemplo:

acquire = Acquire(duration=10)
schedule = Schedule()
schedule.insert(60, acquire(AcquireChannel(0), MemorySlot(0), RegisterSlot(0)))
schedule.insert(60, acquire(AcquireChannel(1), MemorySlot(1), RegisterSlot(1)))

Se ha añadido un nuevo método qiskit.transpiler.CouplingMap.draw() para qiskit.transpiler.CouplingMap para generar una imagen graphviz a partir del gráfico del mapa de acoplamiento. Por ejemplo:
```
from qiskit.transpiler import CouplingMap

coupling_map = CouplingMap(
    [[0, 1], [1, 0], [1, 2], [1, 3], [2, 1], [3, 1], [3, 4], [4, 3]])
coupling_map.draw()
```
Se han añadido pulsos paramétricos a OpenPulse. Se trata de comandos de impulso parametrizados y comprendidos por el backend. Las formas de impulso arbitrarias siguen siendo compatibles con el comando SamplePulse. Las nuevas clases de pulso compatibles son:
- qiskit.pulse.ConstantPulse
- qiskit.pulse.Drag
- qiskit.pulse.Gaussian
- qiskit.pulse.GaussianSquare
Pueden utilizarse como cualquier otro comando Pulse. Un ejemplo
```
from qiskit.pulse import (Schedule, Gaussian, Drag, ConstantPulse,
                          GaussianSquare)

sched = Schedule(name='parametric_demo')
sched += Gaussian(duration=25, sigma=4, amp=0.5j)(DriveChannel(0))
sched += Drag(duration=25, amp=0.1, sigma=5, beta=4)(DriveChannel(1))
sched += ConstantPulse(duration=25, amp=0.3+0.1j)(DriveChannel(1))
sched += GaussianSquare(duration=1500, amp=0.2, sigma=8,
                        width=140)(MeasureChannel(0)) << sched.duration
```
El programa resultante será similar a un programa SamplePulse construido utilizando qiskit.pulse.pulse_lib, sin embargo, el muestreo de la forma de onda será realizado por el backend. El método qiskit.pulse.Schedule.draw() puede seguir utilizándose como de costumbre. Sin embargo, el comando se convertirá en un SamplePulse con el método qiskit.pulse.ParametricPulse.get_sample_pulse() , por lo que el pulso mostrado puede no muestrear la función continua de la misma manera que lo hará el backend.

Esta función puede utilizarse para construir programas de pulsos para cualquier backend, pero los pulsos se convertirán en objetos SamplePulse si el backend no admite pulsos paramétricos. Los backends que los soporten tendrán el siguiente nuevo atributo:
```
backend.configuration().parametric_pulses: List[str]
# e.g. ['gaussian', 'drag', 'constant']
```
Tenga en cuenta que el backend no necesita soportar todos los pulsos paramétricos definidos en Qiskit.

Cuando el backend soporta pulsos paramétricos, y el programa de pulsos se construye con ellos, el Qobj ensamblado es significativamente más pequeño. El tamaño de un PulseQobj construido enteramente con pulsos paramétricos depende sólo del número de instrucciones, mientras que el tamaño de un PulseQobj construido de otra forma crecerá con la duración de las instrucciones (ya que cada muestra debe especificarse con un valor).

Añadidas funciones de utilidad, qiskit.scheduler.measure() y qiskit.scheduler.measure_all() al módulo qiskit.scheduler. Estas funciones devuelven un qiskit.pulse.Schedule objeto que mide qubits utilizando OpenPulse. Por ejemplo:

from qiskit.scheduler import measure, measure_all

measure_q0_schedule = measure(qubits=[0], backend=backend)
measure_all_schedule = measure_all(backend)
measure_custom_schedule = measure(qubits=[0],
                                  inst_map=backend.defaults().instruction_schedule_map,
                                  meas_map=[[0]],
                                  qubit_mem_slots={0: 1})

Los objetos Pulse qiskit.pulse.Schedule tienen ahora mejores representaciones que para horarios simples deberían ser expresiones Python válidas.
Los métodos qiskit.circuit.QuantumCircuit métodos qiskit.circuit.QuantumCircuit.measure_active(), qiskit.circuit.QuantumCircuit.measure_all()y qiskit.circuit.QuantumCircuit.remove_final_measurements() tienen ahora un kwarg adicional inplace. Cuando inplace se ajusta a False la función devolverá una copia modificada del circuito. Esto es diferente del comportamiento por defecto, que modificará el objeto circuito en su lugar y no devolverá nada.
Se han añadido varios métodos constructores nuevos a la clase qiskit.transpiler.CouplingMap para construir objetos con gráficos básicos de acoplamiento de qubits. Los nuevos métodos constructores son:
Por ejemplo, para utilizar los nuevos constructores para obtener un mapa de acoplamiento de 5 qubits conectados en una cadena lineal ahora puede ejecutar:
```
from qiskit.transpiler import CouplingMap

coupling_map = CouplingMap.from_line(5)
coupling_map.draw()
```
Introducido un nuevo pase qiskit.transpiler.passes.CrosstalkAdaptiveSchedule. Este paso pretende reducir el impacto del ruido de diafonía en un programa. Utiliza los datos de caracterización de la diafonía del backend para programar las puertas. Cuando un par de puertas tiene una alta diafonía, se serializan utilizando una barrera. La serialización ingenua es perjudicial porque incurre en errores de decoherencia. Por lo tanto, este paso utiliza un enfoque de optimización SMT para calcular un programa que minimice el impacto de la diafonía, así como los errores de decoherencia.

El pase toma como entrada un circuito que ya está transpilado en el backend, es decir, el circuito está expresado en términos de qubits físicos y se han insertado puertas de intercambio y descompuesto en CNOT si es necesario. Utilizando este circuito y los datos de caracterización de la diafonía, se utiliza una optimización Z3 para construir un nuevo circuito programado como salida.

Para utilizar el pase en un circuito circ:
```
dag = circuit_to_dag(circ)
pass_ = CrosstalkAdaptiveSchedule(backend_prop, crosstalk_prop)
scheduled_dag = pass_.run(dag)
scheduled_circ = dag_to_circuit(scheduled_dag)
```
backend_prop es un qiskit.providers.models.BackendProperties para el backend de destino. crosstalk_prop es un dict que especifica las tasas de error condicionales. Para dos puertas g1 y g2, crosstalk_prop[g1][g2] especifica la tasa de error condicional de g1 cuando g1 y g2 se ejecutan simultáneamente. En una futura versión de qiskit-ignis se añadirá un método para generar crosstalk_prop . Hasta entonces, tendrás que conocer ya las propiedades de diafonía de tu dispositivo o escribir manualmente tus propios experimentos de caracterización de dispositivos.
En el gestor de pases predefinidos para el nivel de optimización 1, qiskit.transpiler.preset_passmanagers.level_1_pass_manager() si qiskit.transpiler.passes.TrivialLayout layout pass no se ajusta perfectamente a un circuito determinado, se utiliza en su lugar qiskit.transpiler.passes.DenseLayout en su lugar.
Añadido un nuevo método abstracto qiskit.quantum_info.Operator.dot() a la clase abstracta BaseOperator , por lo que se incluye para todas las implementaciones de esa clase abstracta, incluyendo qiskit.quantum_info.Operator y los objetos QuantumChannel (por ejemplo qiskit.quantum_info.Choi). Este método devuelve el operador derecho multiplicación a.dot(b) $= a \cdot b$ . Esto equivale a llamar al método operator qiskit.quantum_info.Operator.compose() con el kwarg front ajustado a True.
Añadido qiskit.quantum_info.average_gate_fidelity() y qiskit.quantum_info.gate_error() al módulo qiskit.quantum_info para trabajar con qiskit.quantum_info.Operator y QuantumChannel (por ejemplo qiskit.quantum_info.Choi) objetos.

Se ha añadido la función qiskit.quantum_info.partial_trace() a la función qiskit.quantum_info que funciona con qiskit.quantum_info.Statevector y qiskit.quantum_info.DensityMatrix clases de estado cuántico. Por ejemplo:

from qiskit.quantum_info.states import Statevector
from qiskit.quantum_info.states import DensityMatrix
from qiskit.quantum_info.states import partial_trace

psi = Statevector.from_label('10+')
partial_trace(psi, [0, 1])
rho = DensityMatrix.from_label('10+')
partial_trace(rho, [0, 1])

En qiskit.circuit.QuantumCircuit.draw() o qiskit.visualization.circuit_drawer() se llama con el kwarg with_layout en True (por defecto) la visualización de salida mostrará ahora los qubits físicos como enteros para distinguirlos claramente de los qubits virtuales.

Por ejemplo:
```
from qiskit import QuantumCircuit
from qiskit import transpile
from qiskit.test.mock import FakeVigo

qc = QuantumCircuit(3)
qc.h(0)
qc.cx(0, 1)
qc.cx(0, 2)
transpiled_qc = transpile(qc, FakeVigo())
transpiled_qc.draw(output='mpl')
```
Añadidas nuevas funciones de medida de estado al qiskit.quantum_info módulo: qiskit.quantum_info.entropy(), qiskit.quantum_info.mutual_information(), qiskit.quantum_info.concurrence()y qiskit.quantum_info.entanglement_of_formation(). Estas funciones funcionan con los botones qiskit.quantum_info.Statevector y qiskit.quantum_info.DensityMatrix clases.
Los métodos de descomposición para puertas de un solo qubit en qiskit.quantum_info.synthesis.one_qubit_decompose.OneQubitEulerDecomposer se han ampliado para incluir ahora también la base 'ZXZ' , caracterizada por tres rotaciones alrededor del eje Z,X,Z. Esto significa que un operador general 2x2 puede descomponerse en las siguientes bases: U3, U1X, ZYZ, ZXZ, XYX, ZXZ.

Problemas conocidos

La ejecución de funciones que utilizan qiskit.tools.parallel_map() (por ejemplo qiskit.execute.execute(), qiskit.compiler.transpile()y qiskit.transpiler.PassManager.run()) puede no funcionar cuando se llama desde un script que se ejecuta fuera de un bloque if __name__ == '__main__': cuando se utiliza Python 3.8 en MacOS. Este problema no afecta a otros entornos. Esto se debe a cambios en la forma de lanzar procesos paralelos en Python 3.8 en MacOS. Si RuntimeError o AttributeError son activados por scripts que llaman directamente a parallel_map() o cuando se llama a una función que lo utiliza internamente con Python 3.8 en MacOS incrustar las llamadas de script dentro de if __name__ == '__main__': debería solucionar el problema. Por ejemplo:

from qiskit import QuantumCircuit, QiskitError
from qiskit import execute, BasicAer

qc1 = QuantumCircuit(2, 2)
qc1.h(0)
qc1.cx(0, 1)
qc1.measure([0,1], [0,1])
# making another circuit: superpositions
qc2 = QuantumCircuit(2, 2)
qc2.h([0,1])
qc2.measure([0,1], [0,1])
execute([qc1, qc2], BasicAer.get_backend('qasm_simulator'))

Se debería cambiar a:

from qiskit import QuantumCircuit, QiskitError
from qiskit import execute, BasicAer

def main():
    qc1 = QuantumCircuit(2, 2)
    qc1.h(0)
    qc1.cx(0, 1)
    qc1.measure([0,1], [0,1])
    # making another circuit: superpositions
    qc2 = QuantumCircuit(2, 2)
    qc2.h([0,1])
    qc2.measure([0,1], [0,1])
    execute([qc1, qc2], BasicAer.get_backend('qasm_simulator'))

if __name__ == '__main__':
    main()

si se producen errores con Python 3.8 en MacOS.

Notas de actualización

El valor del parámetro rep_time del objeto de configuración del backend Pulse está ahora en unidades de segundos, no de microsegundos. La primera vez que se inicialice un objeto PulseBackendConfiguration , éste lanzará una única advertencia al usuario para indicárselo.
El argumento rep_time para qiskit.compiler.assemble() ahora toma un valor en unidades de segundos, no microsegundos. Esto se hizo para que las unidades con todo lo demás en el pulso. Si ha introducido un valor para rep_time , asegúrese de actualizar el valor para tener en cuenta este cambio.
El valor de la propiedad base_gate de los objetos qiskit.circuit.ControlledGate se ha cambiado de la clase de la puerta base a una instancia de la clase de la puerta base.

La propiedad base_gate_name de qiskit.circuit.ControlledGate se ha eliminado; puede obtener el nombre de la puerta base accediendo a base_gate.name en el objeto. Por ejemplo:

from qiskit import QuantumCircuit
from qiskit.extensions import HGate

qc = QuantumCircuit(3)
cch_gate = HGate().control(2)
base_gate_name = cch_gate.base_gate.name

Cambiado qiskit.quantum_info.Operator métodos mágicos para que __mul__ (que se ejecuta mediante la operación de multiplicación de python, si el lado izquierdo de la operación lo tiene definido) implemente la multiplicación de matrices a la derecha (es decir qiskit.quantum_info.Operator.dot()), y __rmul__ (que se ejecuta mediante la operación de multiplicación de python desde el lado derecho de la operación si el izquierdo no tiene definido __mul__ ) implementa la multiplicación escalar (es decir, qiskit.quantum_info.Operator.multiply()). Anteriormente, ambos métodos aplicaban la multiplicación escalar.
El segundo argumento de la función qiskit.quantum_info.process_fidelity()target , es ahora opcional. Si no se especifica un unitario de destino, se devolverá la fidelidad de proceso del canal de entrada con el operador de identidad.
qiskit.compiler.assemble() respetará ahora el valor configurado de max_shots para un backend. Si se especifica un valor para el kwarg de shots que exceda los tiros máximos establecidos en la configuración del backend la función lanzará ahora una excepción QiskitError . Además, si no se proporciona ningún argumento de disparos, el valor por defecto es 1024 (el comportamiento anterior) o max_shots desde el backend, el que sea menor.

Notas sobre características en desuso

Los métodos para añadir puertas a un qiskit.circuit.QuantumCircuit con argumentos de palabra clave abreviados (por ejemplo, ctl, tgt) han cambiado de nombre para ser más descriptivos (por ejemplo, control_qubit, target_qubit). Los nombres antiguos han quedado obsoletos. A continuación se incluye una tabla con las firmas de llamada antiguas y nuevas para los métodos de QuantumCircuit .

Tipo de instrucción	Firma anterior	Nueva firma
`qiskit.extensions.HGate`	`qc.h(q)`	`qc.h(qubit)`
`qiskit.extensions.CHGate`	`qc.ch(ctl, tgt)`	`qc.ch((control_qubit, target_qubit))`
`qiskit.extensions.IdGate`	`qc.iden(q)`	`qc.iden(qubit)`
`qiskit.extensions.RGate`	`qc.iden(q)`	`qc.iden(qubit)`
`qiskit.extensions.RGate`	`qc.r(theta, phi, q)`	`qc.r(theta, phi, qubit)`
`qiskit.extensions.RXGate`	`qc.rx(theta, q)`	`qc.rx(theta, qubit)`
`qiskit.extensions.CrxGate`	`qc.crx(theta, ctl, tgt)`	`qc.crx(theta, control_qubit, target_qubit)`
`qiskit.extensions.RYGate`	`qc.ry(theta, q)`	`qc.ry(theta, qubit)`
`qiskit.extensions.CryGate`	`qc.cry(theta, ctl, tgt)`	`qc.cry(theta, control_qubit, target_qubit)`
`qiskit.extensions.RZGate`	`qc.rz(phi, q)`	`qc.rz(phi, qubit)`
`qiskit.extensions.CrzGate`	`qc.crz(theta, ctl, tgt)`	`qc.crz(theta, control_qubit, target_qubit)`
`qiskit.extensions.SGate`	`qc.s(q)`	`qc.s(qubit)`
`qiskit.extensions.SdgGate`	`qc.sdg(q)`	`qc.sdg(qubit)`
`qiskit.extensions.FredkinGate`	`qc.cswap(ctl, tgt1, tgt2)`	`qc.cswap(control_qubit, target_qubit1, target_qubit2)`
`qiskit.extensions.TGate`	`qc.t(q)`	`qc.t(qubit)`
`qiskit.extensions.TdgGate`	`qc.tdg(q)`	`qc.tdg(qubit)`
`qiskit.extensions.U1Gate`	`qc.u1(theta, q)`	`qc.u1(theta, qubit)`
`qiskit.extensions.Cu1Gate`	`qc.cu1(theta, ctl, tgt)`	`qc.cu1(theta, control_qubit, target_qubit)`
`qiskit.extensions.U2Gate`	`qc.u2(phi, lam, q)`	`qc.u2(phi, lam, qubit)`
`qiskit.extensions.U3Gate`	`qc.u3(theta, phi, lam, q)`	`qc.u3(theta, phi, lam, qubit)`
`qiskit.extensions.Cu3Gate`	`qc.cu3(theta, phi, lam, ctl, tgt)`	`qc.cu3(theta, phi, lam, control_qubit, target_qubit)`
`qiskit.extensions.XGate`	`qc.x(q)`	`qc.x(qubit)`
`qiskit.extensions.CnotGate`	`qc.cx(ctl, tgt)`	`qc.cx(control_qubit, target_qubit)`
`qiskit.extensions.ToffoliGate`	`qc.ccx(ctl1, ctl2, tgt)`	`qc.ccx(control_qubit1, control_qubit2, target_qubit)`
`qiskit.extensions.YGate`	`qc.y(q)`	`qc.y(qubit)`
`qiskit.extensions.CyGate`	`qc.cy(ctl, tgt)`	`qc.cy(control_qubit, target_qubit)`
`qiskit.extensions.ZGate`	`qc.z(q)`	`qc.z(qubit)`
`qiskit.extensions.CzGate`	`qc.cz(ctl, tgt)`	`qc.cz(control_qubit, target_qubit)`

La ejecución de qiskit.pulse.Acquire en múltiples qubits ha quedado obsoleta y se eliminará en una futura versión. Además, los parámetros qiskit.pulse.AcquireInstruction mem_slots y reg_slots han quedado obsoletos. En su lugar deben utilizarse reg_slot y mem_slot .
El atributo de la qiskit.providers.models.PulseDefaults clase circuit_instruction_map ha quedado obsoleto y se eliminará en una futura versión. En su lugar, debe utilizar el nuevo atributo instruction_schedule_map. Esto se ha hecho para que coincida con el tipo del valor del atributo, que es un InstructionScheduleMap.

El comando qiskit.pulse.PersistentValue está obsoleto y se eliminará en una futura versión. Se puede conseguir una funcionalidad similar con el comando qiskit.pulse.ConstantPulse (uno de los nuevos pulsos paramétricos). Compara lo siguiente:

from qiskit.pulse import Schedule, PersistentValue, ConstantPulse, \
                         DriveChannel

# deprecated implementation
sched_w_pv = Schedule()
sched_w_pv += PersistentValue(value=0.5)(DriveChannel(0))
sched_w_pv += PersistentValue(value=0)(DriveChannel(0)) << 10

# preferred implementation
sched_w_const = Schedule()
sched_w_const += ConstantPulse(duration=10, amp=0.5)(DriveChannel(0))

Python 3.5 en qiskit-terra está obsoleto. La compatibilidad se suprimirá en la primera versión posterior a la fecha de fin de vida de la versión para la comunidad Python, que es el 13/09/2020.
El kwarg require_cptp de la función qiskit.quantum_info.process_fidelity() ha quedado obsoleta y se eliminará en una futura versión. Se sustituye por dos kwargs independientes require_cp y require_tp.
Ajuste del parámetro scale para qiskit.circuit.QuantumCircuit.draw() y qiskit.visualization.circuit_drawer() como primer argumento posicional está obsoleto y se eliminará en una futura versión. En su lugar, debe utilizar scale como argumento de palabra clave.

El módulo qiskit.tools.qi.qi está obsoleto y se eliminará en una futura versión. Las funciones heredadas del módulo han sido sustituidas por funciones y clases del módulo qiskit.quantum_info módulo. A continuación figura una tabla con las funciones obsoletas y su sustitución:

En desuso	Sustitución
`qiskit.tools.partial_trace()`	`qiskit.quantum_info.partial_trace()`
`qiskit.tools.choi_to_pauli()`	`qiskit.quantum_info.Choi` y `quantum_info.PTM`
`qiskit.tools.chop()`	`numpy.round`
`qiskit.tools.qi.qi.outer`	`numpy.outer`
`qiskit.tools.concurrence()`	`qiskit.quantum_info.concurrence()`
`qiskit.tools.shannon_entropy()`	`qiskit.quantum_info.shannon_entropy()`
`qiskit.tools.entropy()`	`qiskit.quantum_info.entropy()`
`qiskit.tools.mutual_information()`	`qiskit.quantum_info.mutual_information()`
`qiskit.tools.entanglement_of_formation()`	`qiskit.quantum_info.entanglement_of_formation()`
`qiskit.tools.is_pos_def()`	`quantum_info.operators.predicates.is_positive_semidefinite_matrix`

El módulo qiskit.quantum_info.states.states está obsoleto y se eliminará en una futura versión. Las funciones heredadas del módulo han sido sustituidas por funciones y clases del módulo qiskit.quantum_info módulo.

En desuso
Sustitución
qiskit.quantum_info.states.states.basis_state qiskit.quantum_info.Statevector.from_label()
qiskit.quantum_info.states.states.projector qiskit.quantum_info.DensityMatrix
El parámetro scaling del método draw() para los objetos Schedule y Pulse ha quedado obsoleto y se eliminará en una futura versión. En su lugar, debe utilizarse el nuevo parámetro scale . Esto se hizo para tener un argumento coherente entre los dibujos de impulsos y circuitos. Por ejemplo:
```
#The consistency in parameters is seen below
#For circuits
circuit = QuantumCircuit()
circuit.draw(scale=0.2)
#For pulses
pulse = SamplePulse()
pulse.draw(scale=0.2)
#For schedules
schedule = Schedule()
schedule.draw(scale=0.2)
```

En desuso	Sustitución
`qiskit.quantum_info.states.states.basis_state`	`qiskit.quantum_info.Statevector.from_label()`
`qiskit.quantum_info.states.states.projector`	`qiskit.quantum_info.DensityMatrix`

Corrección de errores

Anteriormente, si se llamaba a qiskit.circuit.QuantumCircuit.bind_parameters() antes de descomponer un circuito provocaba que los valores límite no se sustituyeran correctamente en las puertas descompuestas. Esto se ha resuelto de forma que la unión y la descomposición puedan producirse en cualquier orden. Corrige los problemas nº 2482 y nº 3509
El paso Collect2qBlocks no había tenido en cuenta anteriormente las condiciones clásicas a la hora de determinar si se incluía una puerta dentro de un bloque existente. En algunos casos, esto hacía que se perdieran las condiciones clásicas al transpilar con optimization_level=3. Esto se ha resuelto para que las puertas condicionadas clásicamente nunca se incluyan en un bloque. Soluciona el problema nº 3215
Todos los tipos de salida para los cajones del circuito en qiskit.circuit.QuantumCircuit.draw() y qiskit.visualization.circuit_drawer() tienen soporte fijo y/o mejorado para puertas personalizadas controladas por dibujo. Corrige los problemas nº 3546, nº 3763 y nº 3764
Se han añadido explicaciones y ejemplos a la documentación de los qiskit.circuit.QuantumCircuit métodos para añadir compuertas: qiskit.circuit.QuantumCircuit.ccx(), qiskit.circuit.QuantumCircuit.ch(), qiskit.circuit.QuantumCircuit.crz(), qiskit.circuit.QuantumCircuit.cswap(), qiskit.circuit.QuantumCircuit.cu1(), qiskit.circuit.QuantumCircuit.cu3(), qiskit.circuit.QuantumCircuit.cx(), qiskit.circuit.QuantumCircuit.cy(), qiskit.circuit.QuantumCircuit.cz(), qiskit.circuit.QuantumCircuit.h(), qiskit.circuit.QuantumCircuit.iden(), qiskit.circuit.QuantumCircuit.rx(), qiskit.circuit.QuantumCircuit.ry(), qiskit.circuit.QuantumCircuit.rz(), qiskit.circuit.QuantumCircuit.s(), qiskit.circuit.QuantumCircuit.sdg(), qiskit.circuit.QuantumCircuit.swap(), qiskit.circuit.QuantumCircuit.t(), qiskit.circuit.QuantumCircuit.tdg(), qiskit.circuit.QuantumCircuit.u1(), qiskit.circuit.QuantumCircuit.u2(), qiskit.circuit.QuantumCircuit.u3(), qiskit.circuit.QuantumCircuit.x(), qiskit.circuit.QuantumCircuit.y(), qiskit.circuit.QuantumCircuit.z(). Soluciona el problema #3400
Correcciones para el manejo del parámetro de número complejo en la visualización de circuitos. Soluciona el problema nº 3640

Otras notas

Los pases del transpilador en el directorio qiskit.transpiler.passes se han organizado en subdirectorios para clasificarlos mejor por funciones. Todos ellos siguen siendo accesibles en el espacio de nombres qiskit.transpiler.passes .

Aer 0.4.0

Añadido

Se ha añadido NoiseModel.from_backend para crear un modelo básico de ruido de dispositivo para un servidor IBMQ (#569)

Se han añadido métodos de simulación multi-GPU a QasmSimulator, StatevectorSimulator, y UnitarySimulator. El simulador qasm dispone de una versión para gpu de los métodos de matriz de densidad y vector de estado y puede accederse a él mediante "method": "density_matrix_gpu" o "method": "statevector_gpu" en backend_options. Se puede acceder al método del simulador de vector de estado gpu mediante "method": "statevector_gpu". Se puede acceder al método GPU del simulador unitario utilizando "method": "unitary_gpu". Estos backends utilizan CUDA y requieren una GPU NVidia.(#544)

Añadido el backend PulseSimulator (#542)

Añadidas las clases PulseSystemModel y HamiltonianModel para representar los modelos que se utilizarán en PulseSimulator (#496, #493)

Añadido duffing_model_generators para generar objetos PulseSystemModel a partir de una lista de parámetros (#516)

Migrado el solucionador de funciones ODE a C++ (#442, #350)

Añadidas pruebas de simulador de impulsos de alto nivel (#379)

CMake BLAS_LIB_PATH bandera para establecer la ruta para buscar BLAS lib (#543)

Cambiado

Cambiada la estructura del directorio src para organizar el código fuente del simulador. Las cabeceras del controlador del simulador se han movido a src/controllers y las cabeceras del estado del método del simulador están en src/simulators (#544)

Movida la ubicación de varias funciones (#568): * Movido el contenido de qiskit.provider.aer.noise.errors al módulo qiskit.providers.noise * Movido el contenido de qiskit.provider.aer.noise.utils al módulo qiskit.provider.aer.utils .

Optimización activada para agregar puertas consecutivas en un circuito (fusión) por defecto (#579).

En desuso

Funciones utils.qobj_utils obsoletas (#568)

Obsoleto qiskit.providers.aer.noise.device.basic_device_noise_model. Se sustituye por el método NoiseModel.from_backend (#569)

Eliminado

Eliminados los métodos NoiseModel.as_dict, QuantumError.as_dict, ReadoutError.as_dict, y QuantumError.kron que estaban obsoletos en 0.3 (#568).

Ignis 0.2

Sin cambios

Aqua 0.6

Sin cambios

IBM Proveedor Q 0.4.6

Añadido

Se han añadido varios métodos nuevos a IBMQBackend:
- wait_for_final_state() hasta que finalice el trabajo. Toma una función de devolución de llamada que invocará después de cada consulta para proporcionar información.
- active_jobs() devuelve los trabajos enviados a un backend que actualmente se encuentran en estado inacabado.
- job_limit() devuelve el límite de trabajos para un backend.
- remaining_jobs_count() devuelve el número de trabajos que puede enviar al backend antes de que se alcance el límite de trabajos.
QueueInfo dispone ahora de un nuevo método format() que devuelve una cadena formateada con la información de la cola.
IBMQJob dispone ahora de tres nuevos métodos: done(), running(), y cancelled() que se utilizan para indicar el estado del trabajo.
qiskit.providers.ibmq.ibmqbackend.IBMQBackend.run() acepta ahora un parámetro opcional job_tags. Si se especifica, las job_tags se asignan al trabajo, que puede utilizarse posteriormente como filtro en qiskit.providers.ibmq.ibmqbackend.IBMQBackend.jobs().
IBMQJobManager ahora tiene un nuevo método retrieve_job_set() que le permite recuperar un conjunto de tareas enviado previamente utilizando el ID del conjunto de tareas.

Cambiado

La jerarquía Exception se ha perfeccionado con clases más especializadas. Sin embargo, puede seguir capturando sus excepciones padre (como IBMQAccountError). Además, la clase de excepción IBMQApiUrlError ha sido sustituida por IBMQAccountCredentialsInvalidUrl y IBMQAccountCredentialsInvalidToken.

En desuso

El uso de urls proxy sin protocolo (por ejemplo, http://) está obsoleto debido a los recientes cambios en Python.

¿Le ha resultado útil esta página?

Informe de un error, de una errata o solicite contenido en GitHub.