Q Sharp

// Copyright (c) Microsoft Corporation. // Licenciado bajo la Licencia MIT.espacio de nombres Microsoft . Quantum . Canon { abrir Microsoft.Quantum.Intrinsic ; abrir Microsoft.Quantum.Arithmetic ; abrir Microsoft.Quantum.Arrays ; abrir Microsoft.Quantum.Diagnostics ; abrir Microsoft.Quantum.Math ;/// # Resumen /// Aplica una operación unitaria controlada por multiplicación $U$ que aplica una /// operación unitaria $V_j$ cuando es controlada por el estado numérico de n qubits $\ket{j}$. /// /// $U = \sum^{N-1}_{j=0}\ket{j}\bra{j}\otimes V_j$. /// /// # Entrada /// ## unitaryGenerator /// Una tupla donde el primer elemento `Int` es el número de operaciones unitarias $N$, /// y el segundo elemento `(Int -> ('T => () is Adj + Ctl))` /// es una función que toma un entero $j$ en $[0,N-1]$ y produce la operación unitaria /// $V_j$. /// /// ## índice /// Registro de control de $n$ qubits que codifica los estados numéricos $\ket{j}$ en /// formato little-endian. /// /// ## objetivo /// Registro genérico de cúbito sobre el que actúa $V_j$. /// /// # Observaciones /// Los `coeficientes` se rellenarán con elementos identidad si /// se especifican menos de $2^n$. Esta implementación utiliza /// $n-1$ cúbitos auxiliares. /// /// # Referencias /// - [ *Andrew M. Childs, Dmitri Maslov, Yunseong Nam, Neil J. Ross, Yuan Su*, /// arXiv:1711.10980](https://arxiv.org/abs/1711.10980) operation MultiplexOperationsFromGenerator < ' T >( unitaryGenerator : ( Int , ( Int -> ( ' T => Unit is Adj + Ctl ))), index : LittleEndian , target : ' T ) : Unit is Ctl + Adj { let ( nUnitaries , unitaryFunction ) = unitaryGenerator ; let unitaryGeneratorWithOffset = ( nUnitaries , 0 , unitaryFunction ); if Length ( index !) == 0 { fail "MultiplexOperations falló. El número de qubits del índice debe ser mayor que 0." ; } si nUnitaries > 0 { let auxiliary = [] ; Adjoint MultiplexOperationsFromGeneratorImpl ( unitaryGeneratorWithOffset , auxiliary , index , target); } }/// # Resumen /// Paso de implementación de `MultiplexOperationsFromGenerator`. /// # Ver también /// - Operación interna de Microsoft.Quantum.Canon.MultiplexOperationsFromGenerator MultiplexOperationsFromGeneratorImpl < ' T >( unitaryGenerator : ( Int , Int , ( Int -> ( ' T => Unit is Adj + Ctl ))), auxiliary : Qubit [] , index : LittleEndian , target : ' T ) : Unit { body (...) { let nIndex = Length ( index !); let nStates = 2 ^ nIndex ;let ( nUnitaries , unitaryOffset , unitaryFunction ) = unitaryGenerator ;let nUnitariesLeft = MinI ( nUnitaries , nStates / 2 ); let nUnitariesRight = MinI ( nUnitaries , nStates );let leftUnitaries = ( nUnitariesLeft , unitaryOffset , unitaryFunction ); let rightUnitaries = ( nUnitariesRight - nUnitariesLeft , unitaryOffset + nUnitariesLeft , unitaryFunction );let newControls = LittleEndian ( Most ( index !));Si nUnitarios > 0 { si Longitud ( auxiliar ) == 1 y nÍndice == 0 { // Caso de terminación( Adjunto controlado ( unitaryFunction ( unitaryOffset )))( auxiliar , objetivo ); } elif Length ( auxiliar ) == 0 y nIndex >= 1 { // Caso de inicio let newauxiliary = Tail ( índice !); if nUnitariesRight > 0 { MultiplexOperationsFromGeneratorImpl ( rightUnitaries , [ newauxiliary ], newControls , objetivo ); } within { X ( newauxiliary ); } apply { MultiplexOperationsFromGeneratorImpl ( leftUnitaries , [ newauxiliary ], newControls , objetivo ); } } else { // Recursión que reduce nIndex en 1 y establece Length(auxiliary) en 1. let controls = [ Tail ( índice !)] + auxiliary ; use newauxiliary = Qubit () ; use andauxiliary = Qubit [ MaxI ( 0 , Length ( controles ) - 2 )]; dentro de { ApplyAndChain ( andauxiliary , controls , newauxiliary ); } aplicar { si nUnitariesRight > 0 { MultiplexOperationsFromGeneratorImpl ( rightUnitaries , [ newauxiliary ], newControls , target ); } dentro de { ( Controlled X )( auxiliary , newauxiliary ); } aplicar { MultiplexOperationsFromGeneratorImpl ( leftUnitaries , [ newauxiliary ], newControls , target ); }} } } } adjunto automático ; controlado ( controlRegister , ...) { MultiplexOperationsFromGeneratorImpl ( unitaryGenerator , auxiliar + controlRegister , índice , objetivo ); } adjunto controlado automático ; }/// # Resumen /// Aplica una operación unitaria controlada por multiplicación $U$ que aplica una /// operación unitaria $V_j$ cuando es controlada por el estado numérico de n qubits $\ket{j}$. /// /// $U = \sum^{N-1}_{j=0}\ket{j}\bra{j}\otimes V_j$. /// /// # Entrada /// ## unitaryGenerator /// Una tupla donde el primer elemento `Int` es el número de operaciones unitarias $N$, /// y el segundo elemento `(Int -> ('T => () is Adj + Ctl))` /// es una función que toma un entero $j$ en $[0,N-1]$ y produce la operación unitaria /// $V_j$. /// /// ## índice /// Registro de control de $n$ qubits que codifica los estados numéricos $\ket{j}$ en /// formato little-endian. /// /// ## objetivo /// Registro genérico de cúbito sobre el que actúa $V_j$. /// /// # Observaciones /// Los `coeficientes` se rellenarán con elementos identidad si /// se especifican menos de $2^n$. Esta versión se implementa /// directamente mediante un bucle a través de operadores unitarios controlados por n. operación MultiplexOperationsBruteForceFromGenerator < ' T >( unitaryGenerator : ( Int , ( Int -> ( ' T => Unit is Adj + Ctl ))), index : LittleEndian , target : ' T ) : Unit is Adj + Ctl { let nIndex = Length ( index !); let nStates = 2 ^ nIndex ; let ( nUnitaries , unitaryFunction ) = unitaryGenerator ; para idxOp en 0 .. MinI ( nStates , nUnitaries ) - 1 { ( ControlledOnInt ( idxOp , unitaryFunction ( idxOp )))( index !, target ); } }/// # Resumen /// Devuelve una operación unitaria controlada por multiplicación $U$ que aplica una /// operación unitaria $V_j$ cuando es controlada por el estado numérico de n qubits $\ket{j}$. /// /// $U = \sum^{2^n-1}_{j=0}\ket{j}\bra{j}\otimes V_j$. /// /// # Entrada /// ## unitaryGenerator /// Una tupla donde el primer elemento `Int` es el número de operaciones unitarias $N$, /// y el segundo elemento `(Int -> ('T => () is Adj + Ctl))` /// es una función que toma un entero $j$ en $[0,N-1]$ y produce la operación unitaria /// $V_j$. /// /// # Salida /// Una operación unitaria controlada por multiplicación $U$ que aplica operaciones unitarias /// descritas por `unitaryGenerator`. /// /// # Ver también /// - Microsoft.Quantum.Canon.MultiplexOperationsFromGenerator function MultiplexerFromGenerator ( unitaryGenerator : ( Int , ( Int -> ( Qubit [] => Unit is Adj + Ctl )))) : (( LittleEndian , Qubit [] ) => Unit is Adj + Ctl ) { return MultiplexOperationsFromGenerator ( unitaryGenerator , _, _); }/// # Resumen /// Devuelve una operación unitaria controlada por multiplicación $U$ que aplica una /// operación unitaria $V_j$ cuando es controlada por el estado numérico de n qubits $\ket{j}$. /// /// $U = \sum^{2^n-1}_{j=0}\ket{j}\bra{j}\otimes V_j$. /// /// # Entrada /// ## unitaryGenerator /// Una tupla donde el primer elemento `Int` es el número de operaciones unitarias $N$, /// y el segundo elemento `(Int -> ('T => () is Adj + Ctl))` /// es una función que toma un entero $j$ en $[0,N-1]$ y produce la operación unitaria /// $V_j$. /// /// # Salida /// Una operación unitaria controlada por multiplicación $U$ que aplica operaciones unitarias /// descritas por `unitaryGenerator`. /// /// # Ver también /// - Microsoft.Quantum.Canon.MultiplexOperationsBruteForceFromGenerator function MultiplexerBruteForceFromGenerator ( unitaryGenerator : ( Int , ( Int -> ( Qubit [] => Unit is Adj + Ctl )))) : (( LittleEndian , Qubit [] ) => Unit is Adj + Ctl ) { return MultiplexOperationsBruteForceFromGenerator ( unitaryGenerator , _, _); }/// # Resumen /// Calcula una cadena de puertas AND /// /// # Descripción /// Los cúbits auxiliares para calcular resultados temporales deben especificarse explícitamente. /// La longitud de ese registro es `Length(ctrlRegister) - 2`, si hay al menos /// dos controles, de lo contrario la longitud es 0. internal operation ApplyAndChain ( auxRegister : Qubit [] , ctrlRegister : Qubit [] , target : Qubit ) : Unit is Adj { if Length ( ctrlRegister ) == 0 { X ( target ); } elif Length ( ctrlRegister ) == 1 { CNOT ( Head ( ctrlRegister ), target ); } else { EqualityFactI ( Length ( auxRegister ), Length ( ctrlRegister )); let controls1 = ctrlRegister [ 0 .. 0 ] + auxRegister ; let controls2 = Rest ( ctrlRegister ); let targets = auxRegister + [ target ]; ApplyToEachA ( ApplyAnd , Zipped3 ( controls1 , controls2 , targets )); } } }