Qシャープ

// Copyright (c) Microsoft Corporation. 
// MIT ライセンスに基づいてライセンスされています。

名前空間Microsoft.Quantum.Canon { open Microsoft.Quantum.Intrinsic ; open Microsoft.Quantum.Arithmetic ; open Microsoft.Quantum.Arrays ; open Microsoft.Quantum.Diagnostics ; open Microsoft.Quantum.Math ;​​​​​​​​​​​​​​​​​​​  
     
     
     
     
     

    /// # 概要/// 
n 量子ビットの数値状態 $\ket{j}$ によって制御されるときにユニタリ $V_j$ を適用する乗算制御ユニタリ演算 $U$ を適用します。 /// /// $U = \sum^{N-1}_{j=0}\ket{j}\bra{j}\otimes V_j$。/// /// # 入力/// ## unitaryGenerator /// 最初の要素 `Int` がユニタリの数 $N$ であるタプル、/// 2 番目の要素 `(Int -> ('T => () is Adj + Ctl))` /// は、$[0,N-1]$ 内の整数 $j$ を受け取り、ユニタリ演算 $V_j$ を出力する関数です。/// /// ## インデックス/// 数値状態 $\ket{j}$ をリトルエンディアン形式でエンコードする $n$ 量子ビット制御レジスタ。 /// /// ## target /// $V_j$ が作用する汎用量子ビットレジスタ。/// /// # 備考/// `coefficients` は、指定された数が $2^n$ 未満の場合、単位元でパディングされます。この実装では、 /// $n-1$ 個の補助量子ビットを使用します。/// /// # 参考文献/// - [ *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 が失敗しました。インデックス キュービットの数は 0 より大きくなければなりません。" ; } if nUnitaries > 0 { let assistant = []; Adjoint MultiplexOperationsFromGeneratorImpl ( unitaryGeneratorWithOffset , assistant , index ,    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
                           
            
             
            
             
        
            
               
                ターゲット); 
} }        
    

    /// # 概要
/// `MultiplexOperationsFromGenerator` の実装手順。/// # 参照/// - Microsoft.Quantum.Canon.MultiplexOperationsFromGenerator内部操作MultiplexOperationsFromGeneratorImpl < ' T > ( unitaryGenerator : ( Int , Int , ( Int -> ( ' T => Unit is Adj + Ctl ))), supplemental : Qubit [], index : LittleEndian , target : ' T ) : Unit { body (...) { let nIndex = Length ( index ! ); let nStates = 2 ^ nIndex ;    
    
    
                        
      
          
               
               

            unitaryGeneratorを作成します。​​​​​     

            nUnitariesLeft = MinI ( nUnitaries 、nStates / 2 )とします。nUnitariesRight = MinI ( nUnitaries 、nStates )とします。      
                

            leftUnitaries = ( nUnitariesLeft 、unitaryOffset 、unitaryFunction ) ; rightUnitaries = ( nUnitariesRight - nUnitariesLeft 、unitaryOffset + nUnitariesLeft 、unitaryFunction ) ;     
                     

            newControls = LittleEndian ( Most (インデックス! ) )とします。   

            if nUnitaries > 0 { if Length ( auxiliary ) == 1 and nIndex == 0 { // 終了ケース    
                        
                    

                    ( Controlled Adjoint ( unitaryFunction ( unitaryOffset )))( assistant , target ); } elif Length ( assistant ) == 0 and nIndex >= 1 { // ケースの開始let newauxiliary = Tail ( index ! ); if nUnitariesRight > 0 { MultiplexOperationsFromGeneratorImpl ( rightUnitaries , [ newauxiliary ], newControls , target ); } within { X ( newauxiliary ); } apply { MultiplexOperationsFromGeneratorImpl ( leftUnitaries , [ newauxiliary ], newControls , target ); } } else { // nIndex を 1 減らし、Length(auxiliary) を 1 に設定する再帰。let controls = [ Tail ( index ! )] + assistant ; use newauxiliary = Qubit (); andauxiliary = Qubit [ MaxI ( 0 , Length ( controls ) - 2 )]を使用します。within { ApplyAndChain ( andauxiliary , controls , newauxiliary ); } apply { if nUnitariesRight > 0 { MultiplexOperationsFromGeneratorImpl ( rightUnitaries , [ newauxiliary ], newControls , target ); } within { ( Controlled X )( assistant , newauxiliary ); } apply { MultiplexOperationsFromGeneratorImpl ( leftUnitaries , [ newauxiliary ], newControls , target );   
                         
                    
                       
                        
                           
                    
                     
                        
                      
                           
                    
                  
                    
                         
                       
                          
                     
                          
                      
                            
                               
                        
                         
                              
                          
                               
                        } } 
} } } adjoint auto ;制御された( controlRegister 、...) { MultiplexOperationsFromGeneratorImpl ( unitaryGenerator 、auxiliary + controlRegister 、index 、target ); } adjoint制御されたauto ; }                    
                
            
        
         
           
                 
        
          
    

    /// # 概要/// 
n 量子ビットの数値状態 $\ket{j}$ によって制御されるときにユニタリ $V_j$ を適用する乗算制御ユニタリ演算 $U$ を適用します。 /// /// $U = \sum^{N-1}_{j=0}\ket{j}\bra{j}\otimes V_j$。/// /// # 入力/// ## unitaryGenerator /// 最初の要素 `Int` がユニタリの数 $N$ であるタプル、/// 2 番目の要素 `(Int -> ('T => () is Adj + Ctl))` /// は、$[0,N-1]$ 内の整数 $j$ を受け取り、ユニタリ演算 $V_j$ を出力する関数です。/// /// ## インデックス/// 数値状態 $\ket{j}$ をリトルエンディアン形式でエンコードする $n$ 量子ビット制御レジスタ。 /// /// ## target /// $V_j$ が作用する汎用量子ビット レジスタ。/// /// # 備考/// `coefficients` は、指定された数が $2^n$ 未満の場合、恒等元でパディングされます。 このバージョンは、n 制御ユニタリ演算子をループ処理することによって直接実装されます。operation 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 ; for idxOp in 0. . MinI ( nStates 、nUnitaries ) - 1 { ( ControlledOnInt ( idxOp 、unitaryFunction ( idxOp )))(インデックス! 、ターゲット); } }    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
                    
          
           
           
            
              
              
        
    

    /// # 概要/// 
n 量子ビット数状態 $\ket{j}$ によって制御されるときにユニタリ $V_j$ を適用する、乗算制御ユニタリ演算 $U$ を返します。 /// /// $U = \sum^{2^n-1}_{j=0}\ket{j}\bra{j}\otimes V_j$。/// /// # 入力/// ## unitaryGenerator /// 最初の要素 `Int` がユニタリの数 $N$ であるタプル、/// 2 番目の要素 `(Int -> ('T => () is Adj + Ctl))` /// は、$[0,N-1]$ 内の整数 $j$ を受け取り、ユニタリ演算 $V_j$ を出力する関数です。/// /// # 出力/// `unitaryGenerator` によって記述されたユニタリを適用する、乗算制御ユニタリ演算 $U$ 。/// /// # 参照/// - Microsoft.Quantum.Canon.MultiplexOperationsFromGenerator function MultiplexerFromGenerator ( unitaryGenerator : ( Int , ( Int -> ( Qubit [] => Unit is Adj + Ctl )))) : (( LittleEndian , Qubit []) => Unit is Adj + Ctl ) { return MultiplexOperationsFromGenerator ( unitaryGenerator , _ , _ ); }    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
                          
           
    

    /// # 概要/// 
n 量子ビット数状態 $\ket{j}$ によって制御されるときにユニタリ $V_j$ を適用する、乗算制御ユニタリ演算 $U$ を返します。 /// /// $U = \sum^{2^n-1}_{j=0}\ket{j}\bra{j}\otimes V_j$。/// /// # 入力/// ## unitaryGenerator /// 最初の要素 `Int` がユニタリの数 $N$ であるタプル、/// 2 番目の要素 `(Int -> ('T => () is Adj + Ctl))` /// は、$[0,N-1]$ 内の整数 $j$ を受け取り、ユニタリ演算 $V_j$ を出力する関数です。/// /// # 出力/// `unitaryGenerator` によって記述されたユニタリを適用する、乗算制御ユニタリ演算 $U$ 。/// /// # 参照/// - Microsoft.Quantum.Canon.MultiplexOperationsBruteForceFromGenerator function MultiplexerBruteForceFromGenerator ( unitaryGenerator : ( Int , ( Int -> ( Qubit [] => Unit is Adj + Ctl )))) : (( LittleEndian , Qubit []) => Unit is Adj + Ctl ) { return MultiplexOperationsBruteForceFromGenerator ( unitaryGenerator , _ , _ ); }    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
                          
           
    

    /// # 概要
/// AND ゲートのチェーンを計算します/// /// # 説明/// 一時的な結果を計算するための補助量子ビットは、明示的に指定する必要があります。/// 少なくとも2 つのコントロールがある場合、そのレジスタの長さは `Length(ctrlRegister) - 2` です。それ以外の場合、長さは 0 です。内部操作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 ; controls2 = Rest ( ctrlRegister )とします。targets = auxRegister + [ target ]とします。ApplyToEachA ( ApplyAnd , Zipped3 ( controls1 , controls2 , target ) ) とします。 } } }