def test_hamiltonian_builder_index_shift_3D(): """ Check if PBC are enforced correctly in the Hamiltonian construction (in fact, in the construction of the plaquette list). """ param = {'L': [2, 2, 4], 'lambda': 0, 'J': -1.0} builder = HamiltonianBuilder(param, states=[]) # Set up test case. expected = np.array([ [1, 2, 4], [0, 3, 5], [3, 0, 6], [2, 1, 7], [5, 6, 8], [4, 7, 9], [7, 4, 10], [6, 5, 11], [9, 10, 12], [8, 11, 13], [11, 8, 14], [10, 9, 15], [13, 14, 0], [12, 15, 1], [15, 12, 2], [14, 13, 3], ]) for n in range(builder.S[-1]): print(n) for d in range(len(param['L'])): assert expected[n, d] == builder.shift_index(n, d)
def test_u_operator(): """ Check if the plaquette operator U does what it should do. """ param = {'lambda': 0, 'J': -1.0} # Testcase 1: should give an overlap. # |0000 0001 0010 0000> ---> |0000000010010000> param['L'] = [2, 4] builder = HamiltonianBuilder(param, states=[]) state = int('0000000100100000', 2) expected_state = int('0000000010010000', 2) constructed_state, _ = apply_u(state, builder.plaquettes[2]) assert expected_state == constructed_state # Testcase 2: should anihilate # |0010 0000 0010 0000> ---> 0 state = int('0010 0000 0000 0000'.replace(' ', ''), 2) constructed_state, _ = apply_u(state, builder.plaquettes[2]) assert constructed_state == 0 # --- # Testcase 3: 3D builder. param['L'] = [2, 2, 2] builder = HamiltonianBuilder(param, states=[]) state = set_bits([20, 7]) expected = set_bits([19, 14]) p_ind = [19, 14, 7, 20] constructed, _ = apply_u(state, p_ind + [set_bits(p_ind)]) assert expected == constructed constructed, _ = apply_u(state, builder.plaquettes[19]) assert expected == constructed
def draw(self, a=2, axis=None, label=None, plaquettes=True, point_color='#5C60C0', latt2=None): """ 3D plot for the current lattice. """ with plt.style.context('seaborn-notebook'): if axis is None: self.fig = plt.figure() self.fig.set_size_inches(2.6, 2.2) self.ax = self.fig.add_subplot(111, projection='3d') else: self.ax = axis if latt2 is not None: latt2.ax = self.ax # Draw the actual system. self.dlinks = self._draw_2D_lattice() points = self._draw_state() if latt2 is not None: latt2.dlinks = self.dlinks points2 = latt2._draw_state(colors=['black', point_color]) # Get flippable plaquettes & color them. if plaquettes: builder = HamiltonianBuilder({'L': self.L}, [], silent=True) pflip = self._find_flippable_plaquettes(builder) print(f'# of flippable plaquettes: {len(pflip)}') for p in builder.plaquettes: if p in pflip: pass #self._highlight_plaquette(p[:-1], color='green', alpha=0.1) else: pass self._highlight_plaquette(p[:-1], color='red', alpha=0.1) # Set viewpoint correctly. self.ax.view_init(elev=90, azim=-90) self.ax.set_axis_off() self.ax.set_xlim(0, a * self.L[0]) self.ax.set_ylim(0, a * self.L[1]) #self.ax.set_zlim(0, a*self.L[2]) if not axis: self.fig.subplots_adjust(left=0.001, right=1.1, top=1.1, bottom=0.001) if label is not None: self.ax.text(-0.5, 0, self.ax.get_zlim()[1] + 0.5, label, fontsize=24)
def test_plaquette_list_2D(): """ Check if the correct list of plaquettes is found in 2D. """ param = {'L': [2, 4], 'lambda': 0, 'J': -1.0} builder = HamiltonianBuilder(param, states=[]) # Set up test case. expected = [ [0, 3, 4, 1], [2, 1, 6, 3], [4, 7, 8, 5], [6, 5, 10, 7], [8, 11, 12, 9], [10, 9, 14, 11], [12, 15, 0, 13], [14, 13, 2, 15], ] # Check plaquettes. for i, p in enumerate(builder.plaquettes): assert expected[i] == p[:-1] # Check the mask array. for i, p in enumerate(builder.plaquettes): mask = 0 for k in expected[i]: mask = mask + (1 << k) assert mask == p[-1]
def test_u_dagger_operator(): """ Check if the inverse plaquette operator U^+ does what it should do. """ param = {'lambda': 0, 'J': -1.0} param['L'] = [2, 2, 2] builder = HamiltonianBuilder(param, states=[]) state = set_bits([20, 7]) expected = set_bits([19, 14]) p_ind = [19, 14, 7, 20] constructed, _ = apply_u_dagger(state, p_ind + [set_bits(p_ind)]) assert 0 == constructed constructed, _ = apply_u_dagger(state, builder.plaquettes[19]) assert 0 == constructed # --- state = set_bits([19, 14]) expected = set_bits([20, 7]) p_ind = [19, 14, 7, 20] constructed, _ = apply_u_dagger(state, p_ind + [set_bits(p_ind)]) assert expected == constructed
def test_hamiltonian_builder_index_shift_2D(): """ Check if PBC are enforced correctly in the Hamiltonian construction (in fact, in the construction of the plaquette list). """ # 2D check. param = {'L': [2, 4], 'lambda': 0, 'J': -1.0} builder = HamiltonianBuilder(param, states=[]) # Set up test case. expected = np.array([ [1, 2], [0, 3], [3, 4], [2, 5], [5, 6], [4, 7], [7, 0], [6, 1], ]) for n in range(builder.S[-1]): for d in range(len(param['L'])): assert expected[n, d] == builder.shift_index(n, d)
def test_plaquette_list_3D(): """ Check if the correct list of plaquettes is found in 3D. """ param = {'L': [2, 2, 2], 'lambda': 0, 'J': -1.0} builder = HamiltonianBuilder(param, states=[]) # Set up test case. expected = [ [0, 4, 6, 1], [1, 8, 13, 2], [0, 5, 12, 2], [3, 1, 9, 4], [4, 11, 16, 5], [3, 2, 15, 5], [6, 10, 0, 7], [7, 2, 19, 8], [6, 11, 18, 8], [9, 7, 3, 10], [10, 5, 22, 11], [9, 8, 21, 11], [12, 16, 18, 13], [13, 20, 1, 14], [12, 17, 0, 14], [15, 13, 21, 16], [16, 23, 4, 17], [15, 14, 3, 17], [18, 22, 12, 19], [19, 14, 7, 20], [18, 23, 6, 20], [21, 19, 15, 22], [22, 17, 10, 23], [21, 20, 9, 23], ] # Chekc the plaquette index. for i, p in enumerate(builder.plaquettes): assert expected[i] == p[:-1] # Check the mask array. for i, p in enumerate(builder.plaquettes): mask = 0 for k in expected[i]: mask = mask + (1 << k) assert mask == p[-1]
def draw(self, a=2, axis=None, label=None, plaquettes=True, type='particle'): """ 3D plot for the current lattice. """ if axis is None: self.fig = plt.figure() self.fig.set_size_inches(2.6, 2.2) self.ax = self.fig.add_subplot(111) else: self.ax = axis # Draw the actual system. self.dlinks = self._draw_2D_lattice() points = self._draw_state(type=type) # Get flippable plaquettes & color them. if plaquettes: builder = HamiltonianBuilder({'L': self.L}, [], silent=True) pflip = self._find_flippable_plaquettes(builder) print(f'# of flippable plaquettes: {len(pflip)}') for p in builder.plaquettes: if p in pflip: pass self._highlight_plaquette(p[:-1], color='green', alpha=0.1) else: pass self._highlight_plaquette(p[:-1], color='red', alpha=0.1) # Set viewpoint correctly. self.ax.set_axis_off() # self.ax.set_xlim(0, a*self.L[0]) # self.ax.set_ylim(0, a*self.L[1]) if label is not None: self.ax.text(-0.5, 0, self.ax.get_zlim()[1] + 0.5, label, fontsize=24)
for p in plaquettes: if apply_u_dagger(state, p, sign=False)[0]: c_1 += 1 elif apply_u(state, p, sign=False)[0]: c_2 += 1 return c_1, c_2 # Read the GL states for a given winding sector. L = [2, 2, 4] winding_states, _ = read_winding_sector( L, [0, 0, 0], basedir='../python_data/local_state_storage/') winding_states = np.sort(winding_states) # Count. builder = HamiltonianBuilder({'L': L}, [], silent=True) n_states = len(winding_states) plaquettes = builder.get_plaquette_list(separate_lists=True) # Compute observables. obs = np.zeros(shape=(n_states, 6)) for k in range(n_states): for j, p in enumerate(plaquettes): obs[k, 2 * j:2 + 2 * j] = count_flippable_plaquettes( winding_states[k], p) # Show progress. if not (k + 1) % (1e4): print(f'{timestamp()} {k+1} / {n_states} states done') np.save('counted_plaquettes', obs)
def flippables(self, extensive=False): builder = HamiltonianBuilder({'L': self.L}, [], silent=True) self.pflips = self._find_flippable_plaquettes(builder) if extensive: return builder, self.pflips return len(self.pflips)
from gauss_lattice.bit_magic import count_particles def print_path(path): print(' >>> '.join(map(str, path))) param = { 'L': [2, 2, 2], } input_file = 'output/hamiltonian_' + size_tag(param['L']) + '.npz' ham = load_npz(input_file) # Read the GSL states and produce a builder object, this is convenient for later. gsl_states = read_all_states(param['L']) builder = HamiltonianBuilder(param, states=gsl_states) blen = builder.S[-1] * 3 # Here we need to convert the sparse matrix into a list of transitions, since # this is easier to use for the recursion. n_fock = ham.shape[0] transitions = {k: [] for k in range(n_fock)} for i, r in enumerate(ham.row): transitions[r].append((ham.col[i], int(ham.data[i]))) def loop_state(path, ml): if len(path) >= ml: return [] for i, n in enumerate(path[:-1]): if abs(path[-1]) == abs(n):