From 2c7bc0577f58fd054466476cc6de96b5578ed9df Mon Sep 17 00:00:00 2001 From: maryam587 <76907998+maryam587@users.noreply.github.com> Date: Sun, 4 Feb 2024 18:32:56 +0500 Subject: [PATCH] Update auto_grader.py bonus solution --- auto_grader.py | 166 ++++++------------------------------------------- 1 file changed, 19 insertions(+), 147 deletions(-) diff --git a/auto_grader.py b/auto_grader.py index e2e79cb..cd03894 100644 --- a/auto_grader.py +++ b/auto_grader.py @@ -1,8 +1,9 @@ +auto_grader.py import math import cmath as cm from enum import Enum import perceval as pcvl - +import numpy as np class CriteriaType(Enum): n_photons = 0 @@ -10,36 +11,24 @@ class CriteriaType(Enum): performance = 2 prob_error = 3 prob_amplitude_error = 4 - - class CriteriaArgs(Enum): method = 0 weight = 1 direction = 2 - - class MethodType(Enum): linear = 0 log = 1 exp = 2 - - class DirectionType(Enum): plus = 0 minus = 1 - - class GateType(Enum): CZ = 0 CNOT = 1 CCZ = 2 CCNOT = 3 - - def get_photon_number(processor: pcvl.Processor) -> int: return processor._input_state.n - - def calculate_score(weight: list[float, int], value: float, penalty_type: MethodType): weight = float(weight) score = value * weight @@ -47,159 +36,42 @@ def calculate_score(weight: list[float, int], value: float, penalty_type: Method score = (math.log(1+value)) * weight elif penalty_type == MethodType.exp: score = value ** weight - return score - - def get_score(criteria_key: str, criteria: dict, value: list[float, int]) -> float: crit = criteria[criteria_key] for ca in CriteriaArgs: if ca.name not in crit: raise KeyError( f"Missing criteria {ca.name} in criteria {criteria_key}") - value = float(value) - method_type = MethodType[crit[CriteriaArgs.method.name]] direction_type = DirectionType[crit[CriteriaArgs.direction.name]] - score = calculate_score(crit[CriteriaArgs.weight.name], value, method_type) if direction_type == DirectionType.minus: score = -score - print( f"For criteria {criteria_key}, penalty type is {method_type.name}, direction criteria type is {direction_type.name}, weight is {crit[CriteriaArgs.weight.name]}, penalty value is {value}, score is {score}") - return score - - -def get_heralded_and_ancillaries(processor: pcvl.Processor): - return pcvl.BasicState(list(processor.heralds.values())) - - -def get_proba_amplitude_error(processor, mapping, data_states): - sim = pcvl.SimulatorFactory().build(processor) - herald_states = get_heralded_and_ancillaries(processor) - modulus_value = None - phase_value = None - states = [state * herald_states for state in mapping] - data_states = [state * herald_states for state in data_states] - error = 0 - for i_state in states: - for o_state in states: - pa = sim.prob_amplitude(i_state, o_state) - modulus = abs(pa) - phase = cm.phase(pa) - if i_state == o_state: - if modulus_value is None: - modulus_value = modulus - error += abs(modulus - modulus_value)/modulus_value - assert modulus != 0 - - if i_state not in data_states: - if phase_value is None: - phase_value = phase - error += abs(phase - phase_value)/(2*cm.pi) - else: - error += abs(phase - phase_value - cm.pi)/(2*cm.pi) - - else: - error += modulus / modulus_value - return error - - -def rate_processor( - processor: pcvl.Processor, - mapping: dict, - target: dict, - criteria: dict, - gate_type: GateType = GateType.CNOT, - data_states: list[pcvl.BasicState] = None) -> float: + return score - if gate_type == GateType.CCNOT or gate_type == GateType.CCZ: - h_mode = 4 - elif gate_type == GateType.CNOT or gate_type == GateType.CZ: - h_mode = 2 - if gate_type == GateType.CNOT or gate_type == GateType.CCNOT: - cnot = processor - cz = pcvl.Processor("SLOS", processor.m) - cz.add(h_mode, pcvl.BS.H()) - cz.add(0, processor) - cz.add(h_mode, pcvl.BS.H()) - elif gate_type == GateType.CZ or gate_type == GateType.CCZ: - cz = processor - cnot = pcvl.Processor("SLOS", processor.m) - cnot.add(h_mode, pcvl.BS.H()) - cnot.add(0, processor) - cnot.add(h_mode, pcvl.BS.H()) - - analyzer = pcvl.algorithm.Analyzer(cnot, mapping) - analyzer.compute(expected=target) - score = 0 - - for criteria_name in criteria: - current_criteria = CriteriaType[criteria_name] - - if current_criteria == CriteriaType.n_photons: - score += get_score(current_criteria.name, - criteria, get_photon_number(cnot)) - - elif current_criteria == CriteriaType.n_modes: - score += get_score(current_criteria.name, - criteria, cnot.circuit_size) - - elif current_criteria == CriteriaType.performance: - score += get_score(current_criteria.name, - criteria, analyzer.performance) - - elif current_criteria == CriteriaType.prob_error: - score += get_score(current_criteria.name, - criteria, 1-analyzer.fidelity) - - elif current_criteria == CriteriaType.prob_amplitude_error: - get_proba_amplitude_error(cz, mapping.keys(), data_states) - score += get_score(current_criteria.name, - criteria, 1-analyzer.fidelity) - - return score +# Define the initial state +initial_state = np.zeros((max_a + 1, max_b + 1, max_c + 1)) +initial_state[n_a, n_b, n_c] = 1 # Set the coefficient of the initial state to 1 +# Apply CZ(a, b) +cz_ab_matrix = (-1) ** np.outer(np.arange(max_a + 1), np.arange(max_b + 1)) +state_after_cz_ab = np.einsum('abc,ab->abc', initial_state, cz_ab_matrix) -if __name__ == "__main__": - from main import get_CCZ - criteria = { - 'n_photons': { - 'method': 'log', - 'direction': 'minus', - 'weight': 1e-3 - }, - 'n_modes': { - 'method': 'log', - 'direction': 'minus', - 'weight': 1e-4 - }, - 'performance': { - 'method': 'log', - 'direction': 'plus', - 'weight': 10 - }, - 'prob_amplitude_error': { - 'method': 'log', - 'direction': 'minus', - 'weight': 1e7 - } - } +# Apply CZ(b, c) +cz_bc_matrix = (-1) ** np.outer(np.arange(max_b + 1), np.arange(max_c + 1)) +state_after_cz_bc = np.einsum('abc,bc->abc', state_after_cz_ab, cz_bc_matrix) - mapping = {pcvl.BasicState('|1,0,1,0,1,0>'): '000', - pcvl.BasicState('|1,0,1,0,0,1>'): '001', - pcvl.BasicState('|1,0,0,1,1,0>'): '010', - pcvl.BasicState('|1,0,0,1,0,1>'): '011', - pcvl.BasicState('|0,1,1,0,1,0>'): '100', - pcvl.BasicState('|0,1,1,0,0,1>'): '101', - pcvl.BasicState('|0,1,0,1,1,0>'): '110', - pcvl.BasicState('|0,1,0,1,0,1>'): '111'} +# Print the states +print("Initial State:") +print(initial_state) - target = {"000": "000", "001": "001", "010": "010", "011": "011", - "100": "100", "101": "101", "110": "111", "111": "110"} +print("\nState after CZ(a, b):") +print(state_after_cz_ab) - print(rate_processor(get_CCZ(), mapping, target, criteria, - GateType.CCZ, [pcvl.BasicState("|0,1,0,1,0,1>")])) +print("\nState after CZ(b, c):") +print(state_after_cz_bc)