Add problem fetching from files for tests and configs

Merge circuit execution files

Author: ekulos-code

solvers/circuitprocessing/circuitexecution/aer-noisy/aer_noisy_executor.py

@@ -0,0 +1,40 @@
+import sys
+from pytket.qasm import circuit_from_qasm_str
+
+input_path = sys.argv[1]
+num_runs = int(sys.argv[2])
+backend_name = sys.argv[3]
+
+with open(input_path, 'r') as input_file:
+    text = input_file.read()
+
+try:
+    circuit = circuit_from_qasm_str(text)
+except Exception as e:
+    print("Was not able to convert to OpenQASM: ", e)
+    sys.exit(1)
+
+if backend_name == "aer":
+    from pytket.extensions.qiskit import AerBackend
+    backend = AerBackend()
+elif backend_name == "qulacs":
+    from pytket.extensions.qulacs import QulacsBackend
+    backend = QulacsBackend()
+elif backend_name == "aer_noisy":
+    from pytket.extensions.qiskit import AerBackend
+    from qiskit_aer.noise import NoiseModel
+    from qiskit_aer.noise.errors import depolarizing_error
+    # https://docs.quantinuum.com/tket/user-guide/manual/manual_noise.html
+    noise_model = NoiseModel()
+    noise_model.add_readout_error([[0.9, 0.1], [0.1, 0.9]], [0])
+    noise_model.add_readout_error([[0.95, 0.05], [0.05, 0.95]], [1])
+    noise_model.add_quantum_error(depolarizing_error(0.1, 2), ["cx"], [0, 1])
+    backend = AerBackend(noise_model)
+else:
+    print(f"Unknown backend: {backend_name}", file=sys.stderr)
+    sys.exit(1)
+
+c = backend.get_compiled_circuit(circuit)
+handle = backend.process_circuit(c, n_shots=num_runs)
+counts = backend.get_result(handle).get_counts()
+print(counts)

solvers/circuitprocessing/circuitexecution/default-executor/default_executor.py

@@ -1,11 +1,16 @@
 package edu.kit.provideq.toolbox.circuit.processing;
 
+import edu.kit.provideq.toolbox.ResourceProvider;
 import edu.kit.provideq.toolbox.circuit.processing.solver.MoveToExecutionSolver;
 import edu.kit.provideq.toolbox.circuit.processing.solver.MoveToMitigationSolver;
 import edu.kit.provideq.toolbox.circuit.processing.solver.MoveToOptimizationSolver;
+import edu.kit.provideq.toolbox.exception.MissingExampleException;
 import edu.kit.provideq.toolbox.meta.Problem;
 import edu.kit.provideq.toolbox.meta.ProblemManager;
 import edu.kit.provideq.toolbox.meta.ProblemType;
+import java.io.IOException;
+import java.util.HashSet;
+import java.util.Objects;
 import java.util.Set;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -22,36 +27,36 @@ public class CircuitProcessingConfiguration {
 
   @Bean
   ProblemManager<String, String> getCircuitProcessingManager(
+      ResourceProvider provider,
       MoveToExecutionSolver moveToExecutionSolver,
       MoveToOptimizationSolver moveToOptimizationSolver,
       MoveToMitigationSolver moveToMitigationSolver
   ) {
-    Problem<String, String> demo = new Problem<>(CIRCUIT_PROCESSING);
-    demo.setInput("""
-        OPENQASM 2.0;
-        include "qelib1.inc";
-        qreg q[2];
-        creg c[2];
-        h q[0];
-        cx q[0],q[1];
-        measure q[0] -> c[0];
-        measure q[1] -> c[1];""");
-    Problem<String, String> secondDemo = new Problem<>(CIRCUIT_PROCESSING);
-    secondDemo.setInput("""
-        OPENQASM 2.0;
-        include "qelib1.inc";
-        qreg q[3];
-        crz(0.5) q[0], q[1];
-        t q[2];
-        cswap q[2], q[0], q[1];""");
     return new ProblemManager<>(
         CIRCUIT_PROCESSING,
         Set.of(
             moveToExecutionSolver,
             moveToOptimizationSolver,
             moveToMitigationSolver
         ),
-        Set.of(demo, secondDemo)
+        loadExampleProblems(provider)
     );
   }
+
+  private Set<Problem<String, String>> loadExampleProblems(ResourceProvider provider) {
+    try {
+      String[] problemNames = new String[] {"bell-state.qasm", "cswap.qasm"};
+      var problemSet = new HashSet<Problem<String, String>>();
+      for (var problemName : problemNames) {
+        var problemStream = Objects.requireNonNull(
+            getClass().getResourceAsStream(problemName), "Problem " + problemName + " not found");
+        var problem = new Problem<>(CIRCUIT_PROCESSING);
+        problem.setInput(provider.readStream(problemStream));
+        problemSet.add(problem);
+      }
+      return problemSet;
+    } catch (IOException e) {
+      throw new MissingExampleException(CIRCUIT_PROCESSING, e);
+    }
+  }
 }

solvers/circuitprocessing/circuitexecution/executor.py

@@ -87,10 +87,11 @@ public Mono<Solution<ExecutionResult>> solve(
         .orElse(DEFAULT_SIMULATOR);
 
     var processResult = context
-        .getBean(PythonProcessRunner.class, scriptPath + selectedSimulator.getScriptPath(), venv)
+        .getBean(PythonProcessRunner.class, scriptPath + "executor.py", venv)
         .withArguments(
             ProcessRunner.INPUT_FILE_PATH,
-            String.valueOf(shotNumber)
+            String.valueOf(shotNumber),
+            selectedSimulator.getBackendKey()
         )
         .writeInputFile(input)
         .readOutputString()
@@ -112,25 +113,25 @@ public ProblemType<String, ExecutionResult> getProblemType() {
   }
 
   enum QuantumSimulator {
-    AER("AerBackend", "default-executor/default_executor.py"),
-    // PROJECTQ("ProjectQBackend", "projectq-executor/projectq_executor.py"),
-    QULACS("QulacsBackend", "qulacs-executor/qulacs_executor.py"),
-    AER_NOISY("Aer Noisy Backend (max. 2 qubits)", "aer-noisy/aer_noisy_executor.py");
+    AER("AerBackend", "aer"),
+    // PROJECTQ("ProjectQBackend", "projectq"),
+    QULACS("QulacsBackend", "qulacs"),
+    AER_NOISY("Aer Noisy Backend (max. 2 qubits)", "aer_noisy");
 
     private final String value;
-    private final String scriptPath;
+    private final String backendKey;
 
-    QuantumSimulator(String value, String scriptPath) {
+    QuantumSimulator(String value, String backendKey) {
       this.value = value;
-      this.scriptPath = scriptPath;
+      this.backendKey = backendKey;
     }
 
     public String getValue() {
       return value;
     }
 
-    public String getScriptPath() {
-      return scriptPath;
+    public String getBackendKey() {
+      return backendKey;
     }
 
     public static QuantumSimulator fromValue(String value) {

solvers/circuitprocessing/circuitexecution/qulacs-executor/qulacs_executor.py

@@ -1,8 +1,12 @@
 package edu.kit.provideq.toolbox.circuit.processing.solver.executor;
 
+import edu.kit.provideq.toolbox.ResourceProvider;
+import edu.kit.provideq.toolbox.exception.MissingExampleException;
 import edu.kit.provideq.toolbox.meta.Problem;
 import edu.kit.provideq.toolbox.meta.ProblemManager;
 import edu.kit.provideq.toolbox.meta.ProblemType;
+import java.io.IOException;
+import java.util.Objects;
 import java.util.Set;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -19,14 +23,25 @@ public class ExecutorConfiguration {
 
   @Bean
   ProblemManager<String, ExecutionResult> getExecutorProblemManager(
+      ResourceProvider provider,
       ExecutionSolver executionSolver
   ) {
     return new ProblemManager<>(
         EXECUTOR_CONFIG,
-        Set.of(
-            executionSolver
-        ),
-        Set.of(new Problem<>(EXECUTOR_CONFIG))
+        Set.of(executionSolver),
+        loadExampleProblems(provider)
     );
   }
+
+  private Set<Problem<String, ExecutionResult>> loadExampleProblems(ResourceProvider provider) {
+    try {
+      var problemStream = Objects.requireNonNull(
+          getClass().getResourceAsStream("../../bell-state.qasm"), "Problem bell-state.qasm not found");
+      var problem = new Problem<>(EXECUTOR_CONFIG);
+      problem.setInput(provider.readStream(problemStream));
+      return Set.of(problem);
+    } catch (IOException e) {
+      throw new MissingExampleException(EXECUTOR_CONFIG, e);
+    }
+  }
 }

src/main/java/edu/kit/provideq/toolbox/circuit/processing/CircuitProcessingConfiguration.java

@@ -1,8 +1,12 @@
 package edu.kit.provideq.toolbox.circuit.processing.solver.mitigation;
 
+import edu.kit.provideq.toolbox.ResourceProvider;
+import edu.kit.provideq.toolbox.exception.MissingExampleException;
 import edu.kit.provideq.toolbox.meta.Problem;
 import edu.kit.provideq.toolbox.meta.ProblemManager;
 import edu.kit.provideq.toolbox.meta.ProblemType;
+import java.io.IOException;
+import java.util.Objects;
 import java.util.Set;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -19,14 +23,25 @@ public class ErrorMitigationConfiguration {
 
   @Bean
   ProblemManager<String, String> getMitigationProblemManager(
+      ResourceProvider provider,
       ErrorMitigationSolver errorMitigationSolver
   ) {
     return new ProblemManager<>(
         MITIGATION_CONFIG,
-        Set.of(
-            errorMitigationSolver
-        ),
-        Set.of(new Problem<>(MITIGATION_CONFIG))
+        Set.of(errorMitigationSolver),
+        loadExampleProblems(provider)
     );
   }
+
+  private Set<Problem<String, String>> loadExampleProblems(ResourceProvider provider) {
+    try {
+      var problemStream = Objects.requireNonNull(
+          getClass().getResourceAsStream("../../bell-state.qasm"), "Problem bell-state.qasm not found");
+      var problem = new Problem<>(MITIGATION_CONFIG);
+      problem.setInput(provider.readStream(problemStream));
+      return Set.of(problem);
+    } catch (IOException e) {
+      throw new MissingExampleException(MITIGATION_CONFIG, e);
+    }
+  }
 }

src/main/java/edu/kit/provideq/toolbox/circuit/processing/solver/executor/ExecutionSolver.java

@@ -1,8 +1,12 @@
 package edu.kit.provideq.toolbox.circuit.processing.solver.optimization;
 
+import edu.kit.provideq.toolbox.ResourceProvider;
+import edu.kit.provideq.toolbox.exception.MissingExampleException;
 import edu.kit.provideq.toolbox.meta.Problem;
 import edu.kit.provideq.toolbox.meta.ProblemManager;
 import edu.kit.provideq.toolbox.meta.ProblemType;
+import java.io.IOException;
+import java.util.Objects;
 import java.util.Set;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -19,14 +23,25 @@ public class OptimizationConfiguration {
 
   @Bean
   ProblemManager<String, String> getOptimizationProblemManager(
+      ResourceProvider provider,
       OptimizationSolver optimizationSolver
   ) {
     return new ProblemManager<>(
         OPTIMIZATION_CONFIG,
-        Set.of(
-            optimizationSolver
-        ),
-        Set.of(new Problem<>(OPTIMIZATION_CONFIG))
+        Set.of(optimizationSolver),
+        loadExampleProblems(provider)
     );
   }
+
+  private Set<Problem<String, String>> loadExampleProblems(ResourceProvider provider) {
+    try {
+      var problemStream = Objects.requireNonNull(
+          getClass().getResourceAsStream("../../bell-state.qasm"), "Problem bell-state.qasm not found");
+      var problem = new Problem<>(OPTIMIZATION_CONFIG);
+      problem.setInput(provider.readStream(problemStream));
+      return Set.of(problem);
+    } catch (IOException e) {
+      throw new MissingExampleException(OPTIMIZATION_CONFIG, e);
+    }
+  }
 }

src/main/java/edu/kit/provideq/toolbox/circuit/processing/solver/executor/ExecutorConfiguration.java

@@ -0,0 +1,8 @@
+OPENQASM 2.0;
+include "qelib1.inc";
+qreg q[2];
+creg c[2];
+h q[0];
+cx q[0],q[1];
+measure q[0] -> c[0];
+measure q[1] -> c[1];