def test_parameter_counting(self): #XY Model: SPAM=True n = stdxy.target_model().num_params self.assertEqual(n,44) # 2*16 + 3*4 = 44 n = stdxy.target_model().num_nongauge_params self.assertEqual(n,28) # full 16 gauge params #XY Model: SPAM=False tst = stdxy.target_model() del tst.preps['rho0'] del tst.povms['Mdefault'] n = tst.num_params self.assertEqual(n,32) # 2*16 = 32 n = tst.num_nongauge_params self.assertEqual(n,18) # gates are all unital & TP => only 14 gauge params (2 casimirs) #XYI Model: SPAM=True n = stdxyi.target_model().num_params self.assertEqual(n,60) # 3*16 + 3*4 = 60 n = stdxyi.target_model().num_nongauge_params self.assertEqual(n,44) # full 16 gauge params: SPAM gate + 3 others #XYI Model: SPAM=False tst = stdxyi.target_model() del tst.preps['rho0'] del tst.povms['Mdefault'] n = tst.num_params self.assertEqual(n,48) # 3*16 = 48 n = tst.num_nongauge_params self.assertEqual(n,34) # gates are all unital & TP => only 14 gauge params (2 casimirs) #XYI Model: SP0=False tst = stdxyi.target_model() tst.preps['rho0'] = pygsti.modelmembers.states.TPState(tst.preps['rho0']) n = tst.num_params self.assertEqual(n,59) # 3*16 + 2*4 + 3 = 59 n = tst.num_nongauge_params self.assertEqual(n,44) # 15 gauge params (minus one b/c can't change rho?) #XYI Model: G0=SP0=False tst.operations['Gi'] = pygsti.modelmembers.operations.FullTPOp(tst.operations['Gi']) tst.operations['Gx'] = pygsti.modelmembers.operations.FullTPOp(tst.operations['Gx']) tst.operations['Gy'] = pygsti.modelmembers.operations.FullTPOp(tst.operations['Gy']) n = tst.num_params self.assertEqual(n,47) # 3*12 + 2*4 + 3 = 47 n = tst.num_nongauge_params self.assertEqual(n,35) # full 12 gauge params of single 4x3 gate
def test_clifford_compilations(self): # Tests the Clifford compilations hard-coded into the various std models. Perhaps this can be # automated to run over all the std models that contain a Clifford compilation? from pygsti.modelpacks.legacy import std1Q_Cliffords target_model = std1Q_Cliffords.target_model() clifford_group = rb.group.construct_1q_clifford_group() from pygsti.modelpacks.legacy import std1Q_XY target_model = std1Q_XY.target_model() clifford_compilation = std1Q_XY.clifford_compilation compiled_cliffords = pygsti.models.modelconstruction.create_explicit_alias_model( target_model, clifford_compilation) for key in list(compiled_cliffords.operations.keys()): self.assertLess( np.sum( abs(compiled_cliffords.operations[key] - clifford_group.matrix(key))), 10**(-10)) from pygsti.modelpacks.legacy import std1Q_XYI target_model = std1Q_XYI.target_model() clifford_compilation = std1Q_XYI.clifford_compilation compiled_cliffords = pygsti.models.modelconstruction.create_explicit_alias_model( target_model, clifford_compilation) for key in list(compiled_cliffords.operations.keys()): self.assertLess( np.sum( abs(compiled_cliffords.operations[key] - clifford_group.matrix(key))), 10**(-10))
def setUpClass(cls): super(RBTheoryWeightedInfidelityTester, cls).setUpClass() cls.target_model = std1Q_XY.target_model() cls.mdl = cls.target_model.copy() depol_strength_X = 1e-3 depol_strength_Y = 3e-3 lx = 1. - depol_strength_X depmap_X = np.array([[1., 0., 0., 0.], [0., lx, 0., 0.], [0., 0., lx, 0.], [0, 0., 0., lx]]) ly = 1. - depol_strength_Y depmap_Y = np.array([[1., 0., 0., 0.], [0., ly, 0., 0.], [0., 0., ly, 0.], [0, 0., 0., ly]]) cls.mdl.operations['Gx'] = np.dot(depmap_X, cls.target_model.operations['Gx']) cls.mdl.operations['Gy'] = np.dot(depmap_Y, cls.target_model.operations['Gy']) Gx_weight = 1 Gy_weight = 2 cls.weights = {'Gx': Gx_weight, 'Gy': Gy_weight} GxAGI = ot.average_gate_infidelity(cls.mdl.operations['Gx'], cls.target_model.operations['Gx']) GyAGI = ot.average_gate_infidelity(cls.mdl.operations['Gy'], cls.target_model.operations['Gy']) cls.expected_AGI = (Gx_weight * GxAGI + Gy_weight * GyAGI) / (Gx_weight + Gy_weight) GxAEI = ot.entanglement_infidelity(cls.mdl.operations['Gx'], cls.target_model.operations['Gx']) GyAEI = ot.entanglement_infidelity(cls.mdl.operations['Gy'], cls.target_model.operations['Gy']) cls.expected_EI = (Gx_weight * GxAEI + Gy_weight * GyAEI) / (Gx_weight + Gy_weight)
def setUpClass(cls): cls.target_model = std1Q_XY.target_model() cls.prepStrs = std1Q_XY.fiducials cls.measStrs = std1Q_XY.fiducials cls.germs = std1Q_XY.germs cls.maxLens = [1, 4] super(EvalTree1QBase, cls).setUpClass()
def setUpClass(cls): return # SKIP TESTS super(RBTheoryXYModelTester, cls).setUpClass() cls.target_model = std1Q_XY.target_model() cls.mdl = cls.target_model.depolarize(op_noise=1e-3) cls.clifford_group = rb.group.construct_1q_clifford_group() cls.clifford_compilation = std1Q_XY.clifford_compilation
def setUpClass(cls): super(RBTheoryZrotModelTester, cls).setUpClass() cls.target_model = std1Q_XY.target_model() cls.mdl = cls.target_model.copy() Zrot_unitary = np.array([[1., 0.], [0., np.exp(-1j * 0.01)]]) Zrot_channel = ot.unitary_to_pauligate(Zrot_unitary) for key in cls.target_model.operations.keys(): cls.mdl.operations[key] = np.dot(Zrot_channel, cls.target_model.operations[key])
def test_lsgst_experiment_list(self): maxLens = [1, 2] lsgstExpList = stdlists.make_lsgst_experiment_list( self.opLabels, self.strs, self.strs, self.germs, maxLens, fidPairs=None, truncScheme="whole germ powers") lsgstExpListb = stdlists.make_lsgst_experiment_list( std1Q_XY.target_model(), self.strs, self.strs, self.germs, maxLens, fidPairs=None, truncScheme="whole germ powers") # with Model as first arg
def test_lsgst_experiment_list(self): maxLens = [1, 2] lsgstExpList = gstcircuits.create_lsgst_circuits( self.opLabels, self.strs, self.strs, self.germs, maxLens, fid_pairs=None, trunc_scheme="whole germ powers") lsgstExpListb = gstcircuits.create_lsgst_circuits( std1Q_XY.target_model(), self.strs, self.strs, self.germs, maxLens, fid_pairs=None, trunc_scheme="whole germ powers") # with Model as first arg self.assertEqual(set(lsgstExpList), set(lsgstExpListb))
def test_elgst_lists_structs(self): # ELGST maxLens = [1, 2] elgstLists = stdlists.make_elgst_lists(self.opLabels, self.germs, maxLens, truncScheme="whole germ powers") maxLens = [1, 2] elgstLists2 = stdlists.make_elgst_lists( self.opLabels, self.germs, maxLens, truncScheme="whole germ powers", nest=False, includeLGST=False) elgstLists2b = stdlists.make_elgst_lists( std1Q_XY.target_model(), self.germs, maxLens, truncScheme="whole germ powers", nest=False, includeLGST=False) # with a Model as first arg
def test_elgst_lists_structs(self): # ELGST maxLens = [1, 2] elgstLists = gstcircuits.create_elgst_lists( self.opLabels, self.germs, maxLens, trunc_scheme="whole germ powers") maxLens = [1, 2] elgstLists2 = gstcircuits.create_elgst_lists( self.opLabels, self.germs, maxLens, trunc_scheme="whole germ powers", nest=False, include_lgst=False) elgstLists2b = gstcircuits.create_elgst_lists( std1Q_XY.target_model(), self.germs, maxLens, trunc_scheme="whole germ powers", nest=False, include_lgst=False) # with a Model as first arg
def test_rpe_demo(self): #Declare the particular RPE instance we are interested in #(X and Y pi/2 rotations) rpeconfig_inst = rpeconfig_GxPi2_GyPi2_00 #Declare a variety of relevant parameters target_model = Std1Q_XY.target_model() target_model.set_all_parameterizations('TP') maxLengths_1024 = [1,2,4,8,16,32,64,128,256,512,1024] stringListsRPE = RPEConstr.make_rpe_angle_string_list_dict(10,rpeconfig_inst) angleList = ['alpha','epsilon','theta'] numStrsD = {} numStrsD['RPE'] = [6*i for i in np.arange(1,12)] #Create noisy model mdl_real = target_model.rotate(rotate=[0.01,0.01,0]) #Extract noisy model angles true_alpha = RPE.extract_alpha(mdl_real,rpeconfig_inst) true_epsilon = RPE.extract_epsilon(mdl_real,rpeconfig_inst) true_theta = RPE.extract_theta(mdl_real,rpeconfig_inst) #Load pre-simulated dataset # N=100 # DS = gst.construction.generate_fake_data(mdl_real,stringListsRPE['totalStrList'],N,sampleError='binomial',seed=1) DS = gst.io.load_dataset(compare_files + '/rpe_test_ds.txt') #Analyze dataset resultsRPE = RPE.analyze_rpe_data(DS,mdl_real,stringListsRPE,rpeconfig_inst) PhiFunErrorListCorrect = np.array([1.4647120176458639e-08, 5.466086847039087e-09, 2.811838817340373e-09, 9.295340015064157e-09, 1.4896280285670027e-08, 1.4897848815698111e-08, 4.269122493016919e-09, 1.4897576120637135e-08, 1.4897610849801124e-08, 6.193216574995608e-09, 1.4469989279702888e-08]) alphaErrorListCorrect= np.array([0.05000352128724339, 0.09825031832409103, 0.02500687294425541, 0.012575500499770742, 0.012523502109159201, 0.0044641536173215535, 0.0007474956215971496, 0.00018069665046693828, 0.00027322234186732963, 0.00020451259672338296, 3.198565800954789e-05]) epsilonErrorListCorrect = np.array([0.18811777239515082, 0.009964509397691668, 0.004957204616348632, 0.007362158521305728, 0.00010888027730326932, 0.0015920480408759818, 0.001403238695757869, 0.0004870373015233298, 0.0001929699810709895, 3.411170328226909e-05, 2.723356656519904e-05]) thetaErrorListCorrect= np.array([0.018281791956737087, 0.015230174647994477, 0.0018336710008779447, 0.004525418577473875, 0.0047631900047339125, 0.002627347622582976, 0.0030228260649800788, 0.002591470061459089, 0.0027097752869584, 0.002733081374122569, 0.0027947590038843876]) PhiFunErrorList = resultsRPE['PhiFunErrorList'] alphaErrorList = resultsRPE['alphaErrorList'] epsilonErrorList = resultsRPE['epsilonErrorList'] thetaErrorList = resultsRPE['thetaErrorList'] assert np.linalg.norm(PhiFunErrorListCorrect-PhiFunErrorList) < 1e-8 assert np.linalg.norm(alphaErrorListCorrect-alphaErrorList) < 1e-8 assert np.linalg.norm(epsilonErrorListCorrect-epsilonErrorList) < 1e-8 assert np.linalg.norm(thetaErrorListCorrect-thetaErrorList) < 1e-8 # again, with consistency checks # We are currently not testing the consistency check. -KMR 2/26/18 # dummy_k_list = [ 1 ] #EGN: not sure what this should really be... # resultsRPE_2 = RPE.analyze_rpe_data(DS,mdl_real,stringListsRPE,rpeconfig_inst, # do_consistency_check=True, k_list=dummy_k_list) # with self.assertRaises(ValueError): # RPE.analyze_rpe_data(DS,mdl_real,stringListsRPE,rpeconfig_inst, # do_consistency_check=True) #no k_list given #Print results print('alpha_true - pi/2 =',true_alpha-np.pi/2) print('epsilon_true - pi/2 =',true_epsilon-np.pi/2) print('theta_true =',true_theta) print() print('alpha_true - alpha_est_final =',resultsRPE['alphaErrorList'][-1]) print('epsilon_true - epsilon_est_final =',resultsRPE['epsilonErrorList'][-1]) print('theta_true - theta_est_final =',resultsRPE['thetaErrorList'][-1])
def setUp(self): std.target_model()._check_paramvec() super(CodecsTestCase, self).setUp() self.model = std.target_model() self.germs = pygsti.construction.circuit_list([('Gx', ), ('Gy', ) ]) #abridged for speed self.fiducials = std.fiducials self.maxLens = [1, 2] self.opLabels = list(self.model.operations.keys()) self.lsgstStrings = pygsti.construction.make_lsgst_lists( self.opLabels, self.fiducials, self.fiducials, self.germs, self.maxLens) self.datagen_gateset = self.model.depolarize(op_noise=0.05, spam_noise=0.1) test = self.datagen_gateset.copy() self.ds = pygsti.construction.generate_fake_data( self.datagen_gateset, self.lsgstStrings[-1], nSamples=1000, sampleError='binomial', seed=100) #Make an model with instruments E = self.datagen_gateset.povms['Mdefault']['0'] Erem = self.datagen_gateset.povms['Mdefault']['1'] Gmz_plus = np.dot(E, E.T) Gmz_minus = np.dot(Erem, Erem.T) self.mdl_withInst = self.datagen_gateset.copy() self.mdl_withInst.instruments['Iz'] = pygsti.obj.Instrument({ 'plus': Gmz_plus, 'minus': Gmz_minus }) self.mdl_withInst.instruments['Iztp'] = pygsti.obj.TPInstrument({ 'plus': Gmz_plus, 'minus': Gmz_minus }) self.results = self.runSilent(pygsti.do_long_sequence_gst, self.ds, std.target_model(), self.fiducials, self.fiducials, self.germs, self.maxLens) #make a confidence region factory estLbl = "default" crfact = self.results.estimates[estLbl].add_confidence_region_factory( 'go0', 'final') crfact.compute_hessian(comm=None) crfact.project_hessian('std') #create a Workspace object self.ws = pygsti.report.create_standard_report( self.results, None, title="GST Codec TEST Report", confidenceLevel=95) std.target_model()._check_paramvec() #create miscellaneous other objects self.miscObjects = [] self.miscObjects.append( pygsti.objects.labeldicts.OutcomeLabelDict([(('0', ), 90), (('1', ), 10)]))
def test_json(self): #basic types s = json.dumps(range(10)) x = json.loads(s) s = json.dumps(4 + 3.0j) x = json.loads(s) s = json.dumps(np.array([1, 2, 3, 4], 'd')) x = json.loads(s) s = json.dumps(testObj) x = json.loads(s) #string list s = json.dumps(self.lsgstStrings) x = json.loads(s) self.assertEqual(x, self.lsgstStrings) # DataSet s = json.dumps(self.ds) x = json.loads(s) self.assertEqual(list(x.keys()), list(self.ds.keys())) self.assertEqual(x[('Gx', )].as_dict(), self.ds[('Gx', )].as_dict()) # Model s = json.dumps(self.datagen_gateset) with open(temp_files + "/model.json", 'w') as f: json.dump(self.datagen_gateset, f) with open(temp_files + "/model.json", 'r') as f: x = json.load(f) s = json.dumps(self.mdl_withInst) x = json.loads(s) self.assertAlmostEqual(self.mdl_withInst.frobeniusdist(x), 0) #print(s) x._check_paramvec(True) self.assertAlmostEqual(self.datagen_gateset.frobeniusdist(x), 0) # Results (containing confidence region) std.target_model()._check_paramvec() print("target_model = ", id(std.target_model())) print("rho0 parent = ", id(std.target_model().preps['rho0'].parent)) #import bpdb; bpdb.set_trace() with open(temp_files + "/results.json", 'w') as f: json.dump(self.results, f) print("mdl_target2 = ", id(std.target_model())) print("rho0 parent2 = ", id(std.target_model().preps['rho0'].parent)) std.target_model()._check_paramvec() with open(temp_files + "/results.json", 'r') as f: x = json.load(f) self.assertEqual(list(x.estimates.keys()), list(self.results.estimates.keys())) self.assertEqual( list(x.estimates['default'].confidence_region_factories.keys()), list(self.results.estimates['default'].confidence_region_factories. keys())) # Workspace s = json.dumps(self.ws) x = json.loads(s) #TODO: comparison (?) #Misc other objects for obj in self.miscObjects: s = json.dumps(obj) x = json.loads(s)
def create_nqubit_gateset(nQubits, geometry="line", maxIdleWeight=1, maxhops=0, extraWeight1Hops=0, extraGateWeight=0, sparse=False, gateNoise=None, prepNoise=None, povmNoise=None, verbosity=0): # noise can be either a seed or a random array that is long enough to use printer = pygsti.obj.VerbosityPrinter.build_printer(verbosity) printer.log("Creating a %d-qubit %s model" % (nQubits,geometry)) mdl = pygsti.obj.ExplicitOpModel() # no preps/POVMs # TODO: sparse prep & effect vecs... acton(...) analogue? #Full preps & povms -- maybe another option ##Create initial model with std prep & POVM #eLbls = []; eExprs = [] #formatStr = '0' + str(nQubits) + 'b' #for i in range(2**nQubits): # eLbls.append( format(i,formatStr)) # eExprs.append( str(i) ) #Qlbls = tuple( ['Q%d' % i for i in range(nQubits)] ) #mdl = pygsti.construction.build_explicit_model( # [2**nQubits], [Qlbls], [], [], # effectLabels=eLbls, effectExpressions=eExprs) printer.log("Created initial model") qubitGraph = QubitGraph(nQubits, geometry) printer.log("Created qubit graph:\n"+str(qubitGraph)) printer.log("Creating Idle:") mdl.operations['Gi'] = create_global_idle(qubitGraph, maxIdleWeight, sparse, printer-1) #1Q gates: X(pi/2) & Y(pi/2) on each qubit Gx = std1Q_XY.target_model().operations['Gx'] Gy = std1Q_XY.target_model().operations['Gy'] weight_maxhops_tuples_1Q = [(1,maxhops+extraWeight1Hops)] + \ [ (1+x,maxhops) for x in range(1,extraGateWeight+1) ] for i in range(nQubits): printer.log("Creating 1Q X(pi/2) gate on qubit %d!!" % i) mdl.operations["Gx%d"%i] = create_composed_gate( Gx, (i,), qubitGraph, weight_maxhops_tuples_1Q, idle_noise=mdl.operations['Gi'], loc_noise_type="manylittle", sparse=sparse, verbosity=printer-1) printer.log("Creating 1Q Y(pi/2) gate on qubit %d!!" % i) mdl.operations["Gy%d"%i] = create_composed_gate( Gy, (i,), qubitGraph, weight_maxhops_tuples_1Q, idle_noise=mdl.operations['Gi'], loc_noise_type="manylittle", sparse=sparse, verbosity=printer-1) #2Q gates: CNOT gates along each graph edge Gcnot = std2Q_XYICNOT.target_model().operations['Gcnot'] weight_maxhops_tuples_2Q = [(1,maxhops+extraWeight1Hops),(2,maxhops)] + \ [ (2+x,maxhops) for x in range(1,extraGateWeight+1) ] for i,j in qubitGraph.edges(): #note: all edges have i<j so "control" of CNOT is always lower index (arbitrary) printer.log("Creating CNOT gate between qubits %d and %d!!" % (i,j)) mdl.operations["Gc%dt%d"% (i,j)] = create_composed_gate( Gcnot, (i,j), qubitGraph, weight_maxhops_tuples_2Q, idle_noise=mdl.operations['Gi'], loc_noise_type="manylittle", sparse=sparse, verbosity=printer-1) #Insert noise on gates vecNoSpam = mdl.to_vector() assert( _np.linalg.norm(vecNoSpam)/len(vecNoSpam) < 1e-6 ) if gateNoise is not None: if isinstance(gateNoise,tuple): # use as (seed, strength) seed,strength = gateNoise rndm = _np.random.RandomState(seed) vecNoSpam += _np.abs(rndm.random_sample(len(vecNoSpam))*strength) #abs b/c some params need to be positive else: #use as a vector vecNoSpam += gateNoise[0:len(vecNoSpam)] mdl.from_vector(vecNoSpam) #SPAM basis1Q = pygsti.obj.Basis("pp",2) prepFactors = [ pygsti.obj.TPSPAMVec(pygsti.construction.basis_build_vector("0", basis1Q)) for i in range(nQubits)] if prepNoise is not None: if isinstance(prepNoise,tuple): # use as (seed, strength) seed,strength = prepNoise rndm = _np.random.RandomState(seed) depolAmts = _np.abs(rndm.random_sample(nQubits)*strength) else: depolAmts = prepNoise[0:nQubits] for amt,vec in zip(depolAmts,prepFactors): vec.depolarize(amt) mdl.preps['rho0'] = pygsti.obj.TensorProdSPAMVec('prep',prepFactors) factorPOVMs = [] for i in range(nQubits): effects = [ (l,pygsti.construction.basis_build_vector(l, basis1Q)) for l in ["0","1"] ] factorPOVMs.append( pygsti.obj.TPPOVM(effects) ) if povmNoise is not None: if isinstance(povmNoise,tuple): # use as (seed, strength) seed,strength = povmNoise rndm = _np.random.RandomState(seed) depolAmts = _np.abs(rndm.random_sample(nQubits)*strength) else: depolAmts = povmNoise[0:nQubits] for amt,povm in zip(depolAmts,factorPOVMs): povm.depolarize(amt) mdl.povms['Mdefault'] = pygsti.obj.TensorProdPOVM( factorPOVMs ) printer.log("DONE! - returning Model with dim=%d and gates=%s" % (mdl.dim, list(mdl.operations.keys()))) return mdl
def test_lsgst_lists_structs(self): maxLens = [1, 2] lsgstLists = gstcircuits.create_lsgst_circuit_lists( std1Q_XY.target_model(), self.strs, self.strs, self.germs, maxLens, fid_pairs=None, trunc_scheme="whole germ powers") # also try a Model as first arg self.assertEqual( lsgstLists[-1][26]._str, 'GxGx(Gx)^2GxGx' ) # ensure that (.)^2 appears in string (*not* expanded) lsgstLists2 = gstcircuits.create_lsgst_circuit_lists( self.opLabels, self.strs, self.strs, self.germs, maxLens, fid_pairs=None, trunc_scheme="truncated germ powers") self.assertEqual(set(lsgstLists[-1]), set(lsgstLists2[-1])) lsgstLists3 = gstcircuits.create_lsgst_circuit_lists( self.opLabels, self.strs, self.strs, self.germs, maxLens, fid_pairs=None, trunc_scheme="length as exponent") lsgstStructs3 = gstcircuits.make_lsgst_structs( self.opLabels, self.strs, self.strs, self.germs, maxLens, fid_pairs=None, trunc_scheme="length as exponent") self.assertEqual(set(lsgstLists3[-1]), set(lsgstStructs3[-1])) maxLens = [1, 2] lsgstLists4 = gstcircuits.create_lsgst_circuit_lists( self.opLabels, self.strs, self.strs, self.germs, maxLens, fid_pairs=None, trunc_scheme="whole germ powers", nest=False) lsgstStructs4 = gstcircuits.make_lsgst_structs( self.opLabels, self.strs, self.strs, self.germs, maxLens, fid_pairs=None, trunc_scheme="whole germ powers", nest=False) self.assertEqual(set(lsgstLists4[-1]), set(lsgstStructs4[-1])) lsgstLists5 = gstcircuits.create_lsgst_circuit_lists( self.opLabels, self.strs, self.strs, self.germs, maxLens, fid_pairs=self.testFidPairs, trunc_scheme="whole germ powers") lsgstStructs5 = gstcircuits.make_lsgst_structs( self.opLabels, self.strs, self.strs, self.germs, maxLens, fid_pairs=self.testFidPairs, trunc_scheme="whole germ powers") self.assertEqual(set(lsgstLists5[-1]), set(lsgstStructs5[-1])) lsgstLists6 = gstcircuits.create_lsgst_circuit_lists( self.opLabels, self.strs, self.strs, self.germs, maxLens, fid_pairs=self.testFidPairsDict, trunc_scheme="whole germ powers") lsgstStructs6 = gstcircuits.make_lsgst_structs( self.opLabels, self.strs, self.strs, self.germs, maxLens, fid_pairs=self.testFidPairsDict, trunc_scheme="whole germ powers") self.assertEqual(set(lsgstLists6[-1]), set(lsgstStructs6[-1])) lsgstLists7 = gstcircuits.create_lsgst_circuit_lists( self.opLabels, self.strs, self.strs, self.germs, maxLens, fid_pairs=None, trunc_scheme="whole germ powers", keep_fraction=0.5, keep_seed=1234) lsgstStructs7 = gstcircuits.make_lsgst_structs( self.opLabels, self.strs, self.strs, self.germs, maxLens, fid_pairs=None, trunc_scheme="whole germ powers", keep_fraction=0.5, keep_seed=1234) self.assertEqual(set(lsgstLists7[-1]), set(lsgstStructs7[-1])) lsgstLists8 = gstcircuits.create_lsgst_circuit_lists( self.opLabels, self.strs, self.strs, self.germs, maxLens, fid_pairs=self.testFidPairs, trunc_scheme="whole germ powers", keep_fraction=0.7, keep_seed=1234) lsgstStructs8 = gstcircuits.make_lsgst_structs( self.opLabels, self.strs, self.strs, self.germs, maxLens, fid_pairs=self.testFidPairs, trunc_scheme="whole germ powers", keep_fraction=0.7, keep_seed=1234) self.assertEqual(set(lsgstLists8[-1]), set(lsgstStructs8[-1])) # empty max-lengths ==> no output lsgstStructs9 = gstcircuits.make_lsgst_structs(self.opLabels, self.strs, self.strs, self.germs, [], include_lgst=False) self.assertEqual(len(lsgstStructs9), 0) # checks against data lgst_strings = cc.create_lgst_circuits(self.strs, self.strs, self.opLabels) lsgstStructs10 = gstcircuits.make_lsgst_structs( self.opLabels, self.strs, self.strs, self.germs, maxLens, dscheck=self.ds, action_if_missing="drop", verbosity=4) self.assertEqual([Circuit(('Gx', ))], list(lsgstStructs10[-1]))
def test_lsgst_lists_structs(self): maxLens = [1, 2] lsgstLists = stdlists.make_lsgst_lists( std1Q_XY.target_model(), self.strs, self.strs, self.germs, maxLens, fidPairs=None, truncScheme="whole germ powers") # also try a Model as first arg lsgstStructs = stdlists.make_lsgst_structs( std1Q_XY.target_model(), self.strs, self.strs, self.germs, maxLens, fidPairs=None, truncScheme="whole germ powers") # also try a Model as first arg self.assertEqual(set(lsgstLists[-1]), set(lsgstStructs[-1].allstrs)) lsgstLists2 = stdlists.make_lsgst_lists( self.opLabels, self.strs, self.strs, self.germs, maxLens, fidPairs=None, truncScheme="truncated germ powers") lsgstStructs2 = stdlists.make_lsgst_structs( self.opLabels, self.strs, self.strs, self.germs, maxLens, fidPairs=None, truncScheme="truncated germ powers") self.assertEqual(set(lsgstLists2[-1]), set(lsgstStructs2[-1].allstrs)) lsgstLists3 = stdlists.make_lsgst_lists( self.opLabels, self.strs, self.strs, self.germs, maxLens, fidPairs=None, truncScheme="length as exponent") lsgstStructs3 = stdlists.make_lsgst_structs( self.opLabels, self.strs, self.strs, self.germs, maxLens, fidPairs=None, truncScheme="length as exponent") self.assertEqual(set(lsgstLists3[-1]), set(lsgstStructs3[-1].allstrs)) maxLens = [1, 2] lsgstLists4 = stdlists.make_lsgst_lists( self.opLabels, self.strs, self.strs, self.germs, maxLens, fidPairs=None, truncScheme="whole germ powers", nest=False) lsgstStructs4 = stdlists.make_lsgst_structs( self.opLabels, self.strs, self.strs, self.germs, maxLens, fidPairs=None, truncScheme="whole germ powers", nest=False) self.assertEqual(set(lsgstLists4[-1]), set(lsgstStructs4[-1].allstrs)) lsgstLists5 = stdlists.make_lsgst_lists( self.opLabels, self.strs, self.strs, self.germs, maxLens, fidPairs=self.testFidPairs, truncScheme="whole germ powers") lsgstStructs5 = stdlists.make_lsgst_structs( self.opLabels, self.strs, self.strs, self.germs, maxLens, fidPairs=self.testFidPairs, truncScheme="whole germ powers") self.assertEqual(set(lsgstLists5[-1]), set(lsgstStructs5[-1].allstrs)) lsgstLists6 = stdlists.make_lsgst_lists( self.opLabels, self.strs, self.strs, self.germs, maxLens, fidPairs=self.testFidPairsDict, truncScheme="whole germ powers") lsgstStructs6 = stdlists.make_lsgst_structs( self.opLabels, self.strs, self.strs, self.germs, maxLens, fidPairs=self.testFidPairsDict, truncScheme="whole germ powers") self.assertEqual(set(lsgstLists6[-1]), set(lsgstStructs6[-1].allstrs)) lsgstLists7 = stdlists.make_lsgst_lists( self.opLabels, self.strs, self.strs, self.germs, maxLens, fidPairs=None, truncScheme="whole germ powers", keepFraction=0.5, keepSeed=1234) lsgstStructs7 = stdlists.make_lsgst_structs( self.opLabels, self.strs, self.strs, self.germs, maxLens, fidPairs=None, truncScheme="whole germ powers", keepFraction=0.5, keepSeed=1234) self.assertEqual(set(lsgstLists7[-1]), set(lsgstStructs7[-1].allstrs)) lsgstLists8 = stdlists.make_lsgst_lists( self.opLabels, self.strs, self.strs, self.germs, maxLens, fidPairs=self.testFidPairs, truncScheme="whole germ powers", keepFraction=0.7, keepSeed=1234) lsgstStructs8 = stdlists.make_lsgst_structs( self.opLabels, self.strs, self.strs, self.germs, maxLens, fidPairs=self.testFidPairs, truncScheme="whole germ powers", keepFraction=0.7, keepSeed=1234) self.assertEqual(set(lsgstLists8[-1]), set(lsgstStructs8[-1].allstrs)) # TODO assert correctness # empty max-lengths ==> no output lsgstStructs9 = stdlists.make_lsgst_structs(self.opLabels, self.strs, self.strs, self.germs, []) self.assertEqual(len(lsgstStructs9), 0) # checks against datasets lgst_strings = cc.list_lgst_circuits(self.strs, self.strs, self.opLabels) lsgstStructs10 = stdlists.make_lsgst_structs(self.opLabels, self.strs, self.strs, self.germs, maxLens, dscheck=self.ds, actionIfMissing="drop", verbosity=4) self.assertEqual([Circuit(('Gx', ))], lsgstStructs10[-1].allstrs)