Mapping of Triangular structures (varipeps.mapping.triangular)
- class varipeps.mapping.triangular.Triangular_Expectation_Value(horizontal_gates: Sequence[Array], vertical_gates: Sequence[Array], diagonal_gates: Sequence[Array], real_d: int, normalization_factor: int = 1, is_spiral_peps: bool = False, spiral_unitary_operator: Array | None = None)
Bases:
Expectation_ModelClass to calculate expectation values for a mapped triangular PESS structure.
Structure of the triangular lattice with smallest possible unit cell marked by dashed lines.
- Parameters:
horizontal_gates (sequence of
jax.numpy.ndarray) – Sequence with the gates that should be applied to each nearest horizontal neighbor.vertical_gates (sequence of
jax.numpy.ndarray) – Sequence with the gates that should be applied to each nearest vertical neighbor.diagonal_gates (sequence of
jax.numpy.ndarray) – Sequence with the gates that should be applied to each nearest diagonal neighbor.normalization_factor (
int, optional) – Factor which should be used to normalize the calculated values. If for example three sites are mapped into one PEPS site this should be 1.Default:1is_spiral_peps (
bool, optional) – Flag if the expectation value is for a spiral iPEPS ansatz.Default:Falsespiral_unitary_operator (
jax.numpy.ndarray, optional) – Operator used to generate unitary for spiral iPEPS ansatz. Required if spiral iPEPS ansatz is used.Default:None- __call__(peps_tensors: Sequence[Array], unitcell: PEPS_Unit_Cell, spiral_vectors: Array | Sequence[Array] | None = None, *, normalize_by_size: bool = True, only_unique: bool = True, return_single_gate_results: bool = False) Array | List[Array]
Calculate the expectation value for PEPS unitcell depending on the gates set in the class.
- Parameters:
peps_tensors (sequence of
jax.numpy.ndarray) – The sequence of unique PEPS tensors in the unitcell.unitcell (
PEPS_Unit_Cell) – The PEPS unitcell.spiral_vectors (single or sequence of
jax.numpy.ndarray, optional) – If the expectation value is for a spiral iPEPS ansatz, in this argument the wavevectors are expected.Default:None- Keyword Arguments:
normalize_by_size (
bool, optional) – Flag if the expectation value should be normalized by the number of tensors in the unitcell.Default:Trueonly_unique (
bool, optional) – Flag if the expectation value should be calculated just once for each unique PEPS tensor in the unitcell.Default:True- Returns:
The expectation values for all gates. Single tensor if only one gate is applied.
- Return type:
- classmethod load_from_group(grp: Group)
- save_to_group(grp: Group)
- class varipeps.mapping.triangular.Triangular_Map_PESS_To_PEPS(unitcell_structure: Sequence[Sequence[int]], chi: int, max_chi: int | None = None)
Bases:
Map_To_PEPS_ModelMap a triangular iPESS unit cell to a iPEPS structure.
The simplex are expected to be in the upper triangle and for the mapping to PEPS they are contracted with the site tensor sitting left down of it.
Convention for physical site tensors: [up left, up right, down, phys]
Convention for simplex tensors: [up, down left, down right]
- Parameters:
unitcell_structure (sequence of sequence of
intor 2d array) – Two dimensional array modeling the structure of the unit cell. For details see the description ofPEPS_Unit_Cell.chi (
int) – Bond dimension of environment tensors which should be used for the unit cell generated.max_chi (
int, optional) – Maximal allowed bond dimension of environment tensors which should be used for the unit cell generated.Default:None- __call__(input_tensors: Sequence[Array], *, generate_unitcell: bool = True) List[Array] | Tuple[List[Array], PEPS_Unit_Cell]
Calculate the PEPS unitcell out of a list of input tensors depending on the original systems.
- Parameters:
input_tensors (sequence of
jax.numpy.ndarray) – The sequence of input tensors that should be converted.- Keyword Arguments:
generate_unitcell (
bool, optional) – Flag if the only the PEPS tensors or additionally the unitcell should be calculated.Default:True- Returns:
The mapped PEPS tensors and if
generate_unitcell = Truethe unitcell for these tensors.- Return type:
listofjax.numpy.ndarrayortupleoflistofjax.numpy.ndarrayandPEPS_Unit_Cell- classmethod autosave_wrapper(filename: PathLike, tensors: Array, unitcell: PEPS_Unit_Cell, counter: int | None = None, auxiliary_data: Dict[str, Any] | None = None) None
- classmethod load_from_file(path: PathLike, *, return_config: bool = False, return_auxiliary_data: bool = False) Tuple[List[Array], PEPS_Unit_Cell] | Tuple[List[Array], PEPS_Unit_Cell, VariPEPS_Config]
Load Triangular tensors and unit cell from a HDF5 file.
This function read the group “triangular_pess” from the file and pass this group to the method
load_from_groupthen.- Parameters:
path (
os.PathLike) – Path of the HDF5 file.- Keyword Arguments:
return_config (
bool, optional) – Return a config object initialized with the values from the HDF5 files. If no config is stored in the file, just the data is returned. Missing config flags in the file uses the default values from the config object.Default:Falsereturn_auxiliary_data (
bool, optional) – Return dictionary with string indexed auxiliary data which has been should be stored along the other data in the file.Default:False- Returns:
The tuple with the list of the PESS tensors and the PEPS unitcell is returned. If
return_config = True. the config is returned as well. Ifreturn_auxiliary_data = True. the auxiliary data is returned as well.- Return type:
tuple(list(jax.numpy.ndarray),PEPS_Unit_Cell) ortuple(list(jax.numpy.ndarray),PEPS_Unit_Cell,VariPEPS_Config)- static load_from_group(grp: Group, *, return_config: bool = False) Tuple[List[Array], PEPS_Unit_Cell] | Tuple[List[Array], PEPS_Unit_Cell, VariPEPS_Config]
Load the unit cell from a HDF5 group which is be passed to the method.
- Parameters:
grp (
h5py.Group) – HDF5 group object to load the data from.- Keyword Arguments:
return_config (
bool, optional) – Return a config object initialized with the values from the HDF5 files. If no config is stored in the file, just the data is returned. Missing config flags in the file uses the default values from the config object.Default:False- Returns:
The tuple with the list of the PESS tensors and the PEPS unitcell is returned. If
return_config = True. the config is returned as well.- Return type:
tuple(list(jax.numpy.ndarray),PEPS_Unit_Cell) ortuple(list(jax.numpy.ndarray),PEPS_Unit_Cell,VariPEPS_Config)- classmethod random(structure: Sequence[Sequence[int]], d: int, D: int, chi: int | Sequence[int], dtype: Type[number], max_chi: int, *, seed: int | None = None, destroy_random_state: bool = True) Tuple[List[Array], T_Triangular_Map_PESS_To_PEPS]
- classmethod save_to_file(path: PathLike, tensors: List[Array], unitcell: PEPS_Unit_Cell, *, store_config: bool = True, auxiliary_data: Dict[str, Any] | None = None) None
Save Triangular tensors and unit cell to a HDF5 file.
This function creates a single group “triangular_pess” in the file and pass this group to the method
save_to_groupthen.- Parameters:
path (
os.PathLike) – Path of the new file. Caution: The file will overwritten if existing.tensors (
listofjax.numpy.ndarray) – List with the PEPS tensors which should be stored in the file.unitcell (
PEPS_Unit_Cell) – Full unit cell object which should be stored in the file.
- Keyword Arguments:
store_config (
bool, optional) – Store the current values of the global config object into the HDF5 file as attrs of an extra group.Default:Trueauxiliary_data (
dictwithstrto storable objects, optional) – Dictionary with string indexed auxiliary HDF5-storable entries which should be stored along the other data in the file.Default:None- static save_to_group(grp: Group, tensors: List[Array], unitcell: PEPS_Unit_Cell, *, store_config: bool = True) None
Save unit cell to a HDF5 group which is be passed to the method.
- Parameters:
grp (
h5py.Group) – HDF5 group object to store the data into.tensors (
listofjax.numpy.ndarray) – List with the PEPS tensors which should be stored in the file.unitcell (
PEPS_Unit_Cell) – Full unit cell object which should be stored in the file.
- Keyword Arguments:
store_config (
bool, optional) – Store the current values of the global config object into the HDF5 file as attrs of an extra group.Default:True- class varipeps.mapping.triangular.Triangular_Next_Nearest_Expectation_Value(nearest_neighbor_gates: Sequence[Array], next_nearest_neighbor_gates: Sequence[Array], real_d: int, normalization_factor: int = 1, is_spiral_peps: bool = False, spiral_unitary_operator: Array | None = None)
Bases:
Expectation_ModelClass to calculate expectation values for a triangular structure with next-nearest interactions.
- Parameters:
nearest_neighbor_gates (sequence of
jax.numpy.ndarray) – Sequence with the gates that should be applied to each nearest neighbor.next_nearest_neighbor_gates (sequence of
jax.numpy.ndarray) – Sequence with the gates that should be applied to each next-nearest neighbor.real_d (
int) – Physical dimension of a single site before mapping.normalization_factor (
int, optional) – Factor which should be used to normalize the calculated values. For a single layer triangular structure this should be normally 1.Default:1is_spiral_peps (
bool, optional) – Flag if the expectation value is for a spiral iPEPS ansatz.Default:Falsespiral_unitary_operator (
jax.numpy.ndarray, optional) – Operator used to generate unitary for spiral iPEPS ansatz. Required if spiral iPEPS ansatz is used.Default:None- __call__(peps_tensors: Sequence[Array], unitcell: PEPS_Unit_Cell, spiral_vectors: Array | Sequence[Array] | None = None, *, normalize_by_size: bool = True, only_unique: bool = True, return_single_gate_results: bool = False) Array | List[Array]
Calculate the expectation value for PEPS unitcell depending on the gates set in the class.
- Parameters:
peps_tensors (sequence of
jax.numpy.ndarray) – The sequence of unique PEPS tensors in the unitcell.unitcell (
PEPS_Unit_Cell) – The PEPS unitcell.spiral_vectors (single or sequence of
jax.numpy.ndarray, optional) – If the expectation value is for a spiral iPEPS ansatz, in this argument the wavevectors are expected.Default:None- Keyword Arguments: