Circuit processing

solvers/circuitprocessing/circuitexecution/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/requirements.txt

@@ -0,0 +1,3 @@
+pytket
+pytket-qiskit
+# pytket-qulacs

solvers/circuitprocessing/circuitoptimizing/decompose-multi-cx/decompose_multi_cx_optimizer.py

@@ -0,0 +1,25 @@
+import sys
+from pytket.qasm import circuit_from_qasm_str, circuit_to_qasm_str
+from pytket.predicates import CompilationUnit
+from pytket.passes import DecomposeMultiQubitsCX
+
+input_path = sys.argv[1]
+
+# read input from file
+with open(input_path, 'r') as input_file:
+    text = input_file.read()
+
+input_circuit = text
+
+try:
+    circuit = circuit_from_qasm_str(input_circuit)
+except Exception as e:
+    print("Was not able to convert to OpenQASM: ", e)
+    sys.exit(1)
+
+pass1 = DecomposeMultiQubitsCX()
+cu = CompilationUnit(circuit)
+pass1.apply(cu)
+
+print(circuit_to_qasm_str(cu.circuit))
+

solvers/circuitprocessing/circuitoptimizing/remove-redundancies/remove_redundancies_optimizer.py

@@ -0,0 +1,24 @@
+import sys
+from pytket.qasm import circuit_from_qasm_str, circuit_to_qasm_str
+from pytket.predicates import CompilationUnit
+from pytket.passes import RemoveRedundancies
+
+input_path = sys.argv[1]
+
+# read input from file
+with open(input_path, 'r') as input_file:
+    text = input_file.read()
+
+input_circuit = text
+
+try:
+    circuit = circuit_from_qasm_str(input_circuit)
+except Exception as e:
+    print("Was not able to convert to OpenQASM: ", e)
+    sys.exit(1)
+
+pass1 = RemoveRedundancies()
+cu = CompilationUnit(circuit)
+pass1.apply(cu)
+
+print(circuit_to_qasm_str(cu.circuit))

solvers/circuitprocessing/circuitoptimizing/requirements.txt

@@ -0,0 +1 @@
+pytket

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

@@ -0,0 +1,62 @@
+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;
+
+@Configuration
+public class CircuitProcessingConfiguration {
+  public static final ProblemType<String, String> CIRCUIT_PROCESSING = new ProblemType<>(
+      "circuit-processing",
+      "A quantum circuit processing problem that routes a QASM circuit through optimization, "
+          + "error mitigation, or execution.",
+      String.class,
+      String.class
+  );
+
+  @Bean
+  ProblemManager<String, String> getCircuitProcessingManager(
+      ResourceProvider provider,
+      MoveToExecutionSolver moveToExecutionSolver,
+      MoveToOptimizationSolver moveToOptimizationSolver,
+      MoveToMitigationSolver moveToMitigationSolver
+  ) {
+    return new ProblemManager<>(
+        CIRCUIT_PROCESSING,
+        Set.of(
+            moveToExecutionSolver,
+            moveToOptimizationSolver,
+            moveToMitigationSolver
+        ),
+        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);
+    }
+  }
+}

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

@@ -0,0 +1,20 @@
+package edu.kit.provideq.toolbox.circuit.processing.solver;
+
+import edu.kit.provideq.toolbox.circuit.processing.CircuitProcessingConfiguration;
+import edu.kit.provideq.toolbox.meta.ProblemSolver;
+import edu.kit.provideq.toolbox.meta.ProblemType;
+import edu.kit.provideq.toolbox.meta.SubRoutineDefinition;
+
+public abstract class CircuitProcessingSolver implements ProblemSolver<String, String> {
+  public static final SubRoutineDefinition<String, String> CIRCUIT_PROCESSING_SUBROUTINE =
+      new SubRoutineDefinition<>(
+          CircuitProcessingConfiguration.CIRCUIT_PROCESSING,
+          "Creates a circuit processing solver",
+          true
+      );
+
+  @Override
+  public ProblemType<String, String> getProblemType() {
+    return CircuitProcessingConfiguration.CIRCUIT_PROCESSING;
+  }
+}

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

@@ -0,0 +1,58 @@
+package edu.kit.provideq.toolbox.circuit.processing.solver;
+
+import edu.kit.provideq.toolbox.Solution;
+import edu.kit.provideq.toolbox.SolutionStatus;
+import edu.kit.provideq.toolbox.circuit.processing.solver.executor.ExecutionResult;
+import edu.kit.provideq.toolbox.circuit.processing.solver.executor.ExecutorConfiguration;
+import edu.kit.provideq.toolbox.meta.SolvingProperties;
+import edu.kit.provideq.toolbox.meta.SubRoutineDefinition;
+import edu.kit.provideq.toolbox.meta.SubRoutineResolver;
+import java.util.List;
+import org.springframework.stereotype.Component;
+import reactor.core.publisher.Mono;
+
+@Component
+public class MoveToExecutionSolver extends CircuitProcessingSolver {
+  private static final SubRoutineDefinition<String, ExecutionResult> EXECUTOR_SUBROUTINE =
+      new SubRoutineDefinition<>(
+          ExecutorConfiguration.EXECUTOR_CONFIG,
+          "Creates a execution solver",
+          true
+      );
+
+  @Override
+  public String getName() {
+    return "Execute QASM Code";
+  }
+
+  @Override
+  public String getDescription() {
+    return "Move QASM input to the executors";
+  }
+
+  @Override
+  public List<SubRoutineDefinition<?, ?>> getSubRoutines() {
+    return List.of(EXECUTOR_SUBROUTINE);
+  }
+
+  @Override
+  public Mono<Solution<String>> solve(
+      String input,
+      SubRoutineResolver subRoutineResolver,
+      SolvingProperties properties
+  ) {
+    return subRoutineResolver.runSubRoutine(EXECUTOR_SUBROUTINE, input)
+        .map(executionResultSolution -> {
+          Solution<String> solution = new Solution<>(this);
+          SolutionStatus status = executionResultSolution.getStatus();
+          if (status == SolutionStatus.ERROR) {
+            solution.fail();
+            solution.setDebugData(executionResultSolution.getDebugData());
+            return solution;
+          }
+          solution.complete();
+          solution.setSolutionData(executionResultSolution.getSolutionData().toString());
+          return solution;
+        });
+  }
+}

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

@@ -0,0 +1,44 @@
+package edu.kit.provideq.toolbox.circuit.processing.solver;
+
+import edu.kit.provideq.toolbox.Solution;
+import edu.kit.provideq.toolbox.circuit.processing.solver.mitigation.ErrorMitigationConfiguration;
+import edu.kit.provideq.toolbox.meta.SolvingProperties;
+import edu.kit.provideq.toolbox.meta.SubRoutineDefinition;
+import edu.kit.provideq.toolbox.meta.SubRoutineResolver;
+import java.util.List;
+import org.springframework.stereotype.Component;
+import reactor.core.publisher.Mono;
+
+@Component
+public class MoveToMitigationSolver extends CircuitProcessingSolver {
+  private static final SubRoutineDefinition<String, String> MITIGATOR_SUBROUTINE =
+      new SubRoutineDefinition<>(
+          ErrorMitigationConfiguration.MITIGATION_CONFIG,
+          "Creates a mitigation solver",
+          true
+      );
+
+  @Override
+  public String getName() {
+    return "Mitigate QASM Code Errors";
+  }
+
+  @Override
+  public String getDescription() {
+    return "Move QASM input to the error mitigators";
+  }
+
+  @Override
+  public List<SubRoutineDefinition<?, ?>> getSubRoutines() {
+    return List.of(MITIGATOR_SUBROUTINE);
+  }
+
+  @Override
+  public Mono<Solution<String>> solve(
+      String input,
+      SubRoutineResolver subRoutineResolver,
+      SolvingProperties properties
+  ) {
+    return subRoutineResolver.runSubRoutine(MITIGATOR_SUBROUTINE, input);
+  }
+}

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

@@ -0,0 +1,44 @@
+package edu.kit.provideq.toolbox.circuit.processing.solver;
+
+import edu.kit.provideq.toolbox.Solution;
+import edu.kit.provideq.toolbox.circuit.processing.solver.optimization.OptimizationConfiguration;
+import edu.kit.provideq.toolbox.meta.SolvingProperties;
+import edu.kit.provideq.toolbox.meta.SubRoutineDefinition;
+import edu.kit.provideq.toolbox.meta.SubRoutineResolver;
+import java.util.List;
+import org.springframework.stereotype.Component;
+import reactor.core.publisher.Mono;
+
+@Component
+public class MoveToOptimizationSolver extends CircuitProcessingSolver {
+  private static final SubRoutineDefinition<String, String> OPTIMIZER_SUBROUTINE =
+      new SubRoutineDefinition<>(
+          OptimizationConfiguration.OPTIMIZATION_CONFIG,
+          "Creates a optimization solver",
+          true
+      );
+
+  @Override
+  public String getName() {
+    return "Optimize QASM Code";
+  }
+
+  @Override
+  public String getDescription() {
+    return "Move QASM input to the optimizers";
+  }
+
+  @Override
+  public List<SubRoutineDefinition<?, ?>> getSubRoutines() {
+    return List.of(OPTIMIZER_SUBROUTINE);
+  }
+
+  @Override
+  public Mono<Solution<String>> solve(
+      String input,
+      SubRoutineResolver subRoutineResolver,
+      SolvingProperties properties
+  ) {
+    return subRoutineResolver.runSubRoutine(OPTIMIZER_SUBROUTINE, input);
+  }
+}

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

@@ -0,0 +1,13 @@
+package edu.kit.provideq.toolbox.circuit.processing.solver.executor;
+
+import java.util.Optional;
+
+public record ExecutionResult(Optional<String> resultString, Optional<String> circuit) {
+  public boolean hasResult() {
+    return resultString.isPresent();
+  }
+
+  public boolean hasCircuit() {
+    return circuit.isPresent();
+  }
+}