Circuit processing

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

@@ -0,0 +1,19 @@
+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_circuit = sys.argv[1]
+
+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/circuitoptimizing/remove-redundancies/remove_redundancies_optimizer.py

@@ -0,0 +1,19 @@
+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_circuit = sys.argv[1]
+
+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/aer-noisy/aer_noisy_executor.py

@@ -0,0 +1,27 @@
+import sys
+from pytket.qasm import circuit_from_qasm_str
+from pytket.extensions.qiskit import AerBackend
+
+from qiskit_aer.noise import NoiseModel
+from qiskit_aer.noise.errors import depolarizing_error
+
+input_circuit = sys.argv[1]
+shots = sys.argv[2]
+
+try:
+    circuit = circuit_from_qasm_str(input_circuit)
+except Exception as e:
+    print("Was not able to convert to OpenQASM: ", e)
+    sys.exit(1)
+
+# 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)
+c = backend.get_compiled_circuit(circuit)
+handle = backend.process_circuit(c, n_shots=int(shots))
+counts = backend.get_result(handle).get_counts()
+print(counts)

solvers/circuitprocessing/default-executor/default_executor.py

@@ -0,0 +1,18 @@
+import sys
+from pytket.qasm import circuit_from_qasm_str
+from pytket.extensions.qiskit import AerBackend
+
+input_circuit = sys.argv[1]
+shots = int(sys.argv[2])
+
+try:
+    circuit = circuit_from_qasm_str(input_circuit)
+except Exception as e:
+    print("Was not able to convert to OpenQASM: ", e)
+    sys.exit(1)
+
+backend = AerBackend()
+c = backend.get_compiled_circuit(circuit)
+handle = backend.process_circuit(c, n_shots=shots)
+counts = backend.get_result(handle).get_counts()
+print(counts)

solvers/circuitprocessing/projectq-executor/projectq_executor.py

@@ -0,0 +1,17 @@
+import sys
+from pytket.qasm import circuit_from_qasm_str
+from pytket.extensions.projectq import ProjectQBackend
+
+input_circuit = sys.argv[1]
+shots = int(sys.argv[2])
+
+try:
+    circuit = circuit_from_qasm_str(input_circuit)
+except Exception as e:
+    print("Was not able to convert to OpenQASM: ", e)
+    sys.exit(1)
+
+backend = ProjectQBackend()
+handle = backend.process_circuit(circuit, n_shots=shots)
+result = backend.get_result(handle)
+print(result.get_shots())

solvers/circuitprocessing/qulacs-executor/qulacs_executor.py

@@ -0,0 +1,18 @@
+import sys
+from pytket.qasm import circuit_from_qasm_str
+from pytket.extensions.qulacs import QulacsBackend
+
+input_circuit = sys.argv[1]
+shots = int(sys.argv[2])
+
+try:
+    circuit = circuit_from_qasm_str(input_circuit)
+except Exception as e:
+    print("Was not able to convert to OpenQASM: ", e)
+    sys.exit(1)
+
+backend = QulacsBackend()
+c = backend.get_compiled_circuit(circuit)
+handle = backend.process_circuit(c, n_shots=shots)
+counts = backend.get_result(handle).get_counts()
+print(counts)

solvers/circuitprocessing/requirements.txt

@@ -0,0 +1,5 @@
+pytket
+pytket-qiskit
+pytket-pyquil
+pytket-projectq
+pytket-qulacs

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

@@ -0,0 +1,55 @@
+package edu.kit.provideq.toolbox.circuit.processing;
+
+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.meta.Problem;
+import edu.kit.provideq.toolbox.meta.ProblemManager;
+import edu.kit.provideq.toolbox.meta.ProblemType;
+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",
+      String.class,
+      String.class
+  );
+
+  @Bean
+  ProblemManager<String, String> getCircuitProcessingManager(
+      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)
+    );
+  }
+}

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

@@ -0,0 +1,19 @@
+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"
+      );
+
+  @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,57 @@
+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"
+      );
+
+  @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,43 @@
+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"
+      );
+
+  @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,43 @@
+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"
+      );
+
+  @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();
+  }
+}