Improvements to M.Q.Preparation namespace.

Build/check_indents.py

@@ -24,7 +24,7 @@ def check_file(filename : str) -> bool:
     found_spaces = False
     found_tabs = False
 
-    with open(filename, 'r') as f:
+    with open(filename, 'r', encoding='utf8') as f:
         contents = list(f.readlines())
 
     for line in contents:

Chemistry/src/Runtime/JordanWigner/JordanWignerOptimizedBlockEncoding.qs

@@ -389,8 +389,8 @@ namespace Microsoft.Quantum.Chemistry.JordanWigner {
 
 
     function _JordanWignerOptimizedBlockEncodingQubitManager_ (targetError : Double, nCoeffs : Int, nZ : Int, nMaj : Int, nIdxRegQubits : Int, ctrlRegister : Qubit[]) : ((LittleEndian, Qubit[], Qubit, Qubit[], Qubit[], Qubit[], LittleEndian, LittleEndian[]), (Qubit, Qubit[], Qubit[], Qubit[], LittleEndian[]), Qubit[]) {
-
-        let ((qROMIdx, qROMGarbage), rest0) = _QuantumROMQubitManager(targetError, nCoeffs, ctrlRegister);
+        // FIXME: This is a dependency on a private function from a different assembly!
+        let ((qROMIdx, qROMGarbage), rest0) = _PartitionedForQuantumROM(targetError, nCoeffs, ctrlRegister);
         let ((signQubit, selectZControlRegisters, optimizedBEControlRegisters, pauliBases, indexRegisters, tmp), rest1) = _JordanWignerSelectQubitManager_(nZ, nMaj, nIdxRegQubits, rest0, new Qubit[0]);
         let registers = Partitioned([3], rest1);
         let pauliBasesIdx = LittleEndian(registers[0]);

Chemistry/src/Runtime/JordanWigner/StatePreparation.qs

@@ -38,12 +38,12 @@ namespace Microsoft.Quantum.Chemistry.JordanWigner {
 
 			// The last term is the reference state.
 			let referenceState = PrepareTrialState((2, [terms[nTerms-1]]), _);
-			
+
 			PrepareUnitaryCoupledClusterState(referenceState, terms[0..nTerms-2], trotterStepSize, qubits);
 		}
     }
-    
-    
+
+
     /// # Summary
     /// Simple state preparation of trial state by occupying
     /// spin-orbitals
@@ -54,23 +54,23 @@ namespace Microsoft.Quantum.Chemistry.JordanWigner {
     /// ## qubits
     /// Qubits of Hamiltonian.
     operation PrepareSingleConfigurationalStateSingleSiteOccupation (qubitIndices : Int[], qubits : Qubit[]) : Unit {
-        
+
         body (...) {
             ApplyToEachCA(X, Subarray(qubitIndices, qubits));
         }
-        
+
         adjoint invert;
         controlled distribute;
         controlled adjoint distribute;
     }
-    
-    
+
+
     function _PrepareSingleConfigurationalStateSingleSiteOccupation (qubitIndices : Int[]) : (Qubit[] => Unit is Adj + Ctl) {
-        
+
         return PrepareSingleConfigurationalStateSingleSiteOccupation(qubitIndices, _);
     }
-    
-    
+
+
     /// # Summary
     /// Sparse multi-configurational state preparation of trial state by adding excitations
     /// to initial trial state.
@@ -85,34 +85,34 @@ namespace Microsoft.Quantum.Chemistry.JordanWigner {
     /// ## qubits
     /// Qubits of Hamiltonian.
     operation PrepareSparseMultiConfigurationalState (initialStatePreparation : (Qubit[] => Unit), excitations : JordanWignerInputState[], qubits : Qubit[]) : Unit {
-        
+
         let nExcitations = Length(excitations);
-        
+
         //FIXME compile error let coefficientsSqrtAbs = Mapped(Compose(Compose(Sqrt, Fst),Fst), excitations);
         mutable coefficientsSqrtAbs = new Double[nExcitations];
         mutable coefficientsNewComplexPolar = new ComplexPolar[nExcitations];
         mutable applyFlips = new Int[][nExcitations];
-        
+
         for (idx in 0 .. nExcitations - 1) {
             let (x, excitation) = excitations[idx]!;
             set coefficientsSqrtAbs w/= idx <- Sqrt(AbsComplexPolar(ComplexAsComplexPolar(Complex(x))));
             set coefficientsNewComplexPolar w/= idx <- ComplexPolar(coefficientsSqrtAbs[idx], ArgComplexPolar(ComplexAsComplexPolar(Complex(x))));
             set applyFlips w/= idx <- excitation;
         }
-        
+
         let nBitsIndices = Ceiling(Lg(IntAsDouble(nExcitations)));
-        
+
         repeat {
             mutable success = false;
-            
+
             using (auxillary = Qubit[nBitsIndices + 1]) {
                 using (flag = Qubit[1]) {
                     let multiplexer = MultiplexerBruteForceFromGenerator(nExcitations, LookupFunction(Mapped(_PrepareSingleConfigurationalStateSingleSiteOccupation, applyFlips)));
-                    (StatePreparationComplexCoefficients(coefficientsNewComplexPolar))(LittleEndian(auxillary));
+                    PrepareArbitraryStateCP(coefficientsNewComplexPolar, LittleEndian(auxillary));
                     multiplexer(LittleEndian(auxillary), qubits);
-                    (Adjoint (StatePreparationPositiveCoefficients(coefficientsSqrtAbs)))(LittleEndian(auxillary));
+                    Adjoint PrepareArbitraryStateD(coefficientsSqrtAbs, LittleEndian(auxillary));
                     (ControlledOnInt(0, X))(auxillary, flag[0]);
-                    
+
                     // if measurement outcome one we prepared required state
                     let outcome = Measure([PauliZ], flag);
                     set success = outcome == One;
@@ -126,9 +126,9 @@ namespace Microsoft.Quantum.Chemistry.JordanWigner {
             ResetAll(qubits);
         }
     }
-    
+
 	/// # Summary
-    /// Unitary coupled-cluster state preparation of trial state 
+    /// Unitary coupled-cluster state preparation of trial state
     ///
     /// # Input
     /// ## initialStatePreparation

Standard/src/Math/Convert.qs

@@ -3,6 +3,24 @@
 
 namespace Microsoft.Quantum.Math {
 
+    /// # Summary
+    /// Converts a real floating-point number to a complex number in its polar
+    /// representation.
+    ///
+    /// # Input
+    /// ## input
+    /// The real number to be represented as a complex number.
+    ///
+    /// # Output
+    /// A complex number representing the given input in terms of polar
+    /// coordinates.
+    function DoubleAsComplexPolar(input : Double) : ComplexPolar {
+        return ComplexPolar(
+            AbsD(input),
+            input < 0.0 ? PI() | 0.0
+        );
+    }
+
     /// # Summary
     /// Converts a complex number of type `ComplexPolar` to a complex
     /// number of type `Complex`.