15 posts tagged with "aleph"

✨ New Features​

• SSE history can now be extracted and manipulated in Aleph allowing for user-implemented estimators.
• Helper function, sse_order to determine the order from a given SSE configuration.
• Added suite of fermionic operator transformation functions to simplify and manipulate fermionic operators:
  • fermionic_site_reorder(operator): Reorders creation and annihilation operators by site while tracking phase changes from anticommutation relations.
  • converted_to_create_destroy(operator): Converts named fermionic operators to their creation/annihilation form. Handles multi-site interactions like density-density ($n_i n_j = c_i^\dagger c_i c_j^\dagger c_j$), hopping ($c_i^\dagger c_j + c_j^\dagger c_i$), and pair operators ($c_i^\dagger c_j^\dagger c_k c_l$).
  • simplified_create_destroy(operator): Simplifies operator products by reordering and removing invalid terms (e.g., $c_i c_i = 0$ and $c_i^\dagger c_i^\dagger = 0$).
  • fused_into_number(operator): Fuses creation-annihilation pairs into number operators ($c_i^\dagger c_i \to n_i$).
  • reduced_number_power(operator): Reduces powers of number operators to at most 1 ($n_i^2 = n_i$ for fermionic systems).

---

🐛 Fixes​

• Fixed SSE specific heat capacity estimator.

---

⚙️ Internal / Technical Changes​

• Slight speed improvement to SSE sampling.

---

🚀 Highlights​

• Expanded the library of symbolic Fermionic operators in Aleph with new multi-site and parameterized interactions. See the New Features section for details.
• Forge scripts can now declare arguments.

---

✨ New Features​

• Significant expansion of symbolic Fermionic operators in Aleph, adding standardized factory functions for several interactions:
  • NumberNumber(i, j): Two-site density-density interaction $n_{i} n_{j} = f_{i}^\dagger f_{i} f_{j}^\dagger f_{j}$.
  • TransferNumber(i, j, k): $f_{i}^\dagger f_{j} n_{k}$ interaction.
  • HopNumber(i, j, k): $(f_{i}^\dagger f_{j} + f_{j}^\dagger f_{i}) n_{k}$ interaction.
  • NumberSum(sites): Total occupancy on a set of sites $\sum_{i \in \mathrm{sites}} n_{i}$.
  • NearestNumberSum(sites): Nearest-neighbor density interaction $\sum_{i} n_{i} n_{i+1}$.
  • NextNearestNumberSum(sites): Next-nearest-neighbor density interaction $\sum_{i} n_{i} n_{i+2}$.
  • PairTransfer(i, j, k, l): Directed pair transfer operator $f_{i}^\dagger f_{j}^\dagger f_{k} f_{l}$.
  • PairHop(i, j, k, l): Pair hopping operator $f_{i}^\dagger f_{j}^\dagger f_{k} f_{l} + \mathrm{h.c.}$.
  • PhaseHop(angle, i, j): Complex phase-hop operator $e^{i \phi} f_{i}^\dagger f_{j} + e^{-i \phi} f_{j}^\dagger f_{i}$.
  • NumberPhase(angle, i): Site-specific phase operator $\exp(i \phi n_i)$.
  • NumberNumberPhase(angle, i, j): Two-site phase operator $\exp(i \phi n_{i} n_{j})$.
  • ModeRotation(angle, i, j): Givens rotation operator $\exp(i \theta (f_{i}^\dagger f_{j} + f_{j}^\dagger f_{i}))$.
  • PairRotation(angle, i, j): Bogoliubov rotation operator $\exp(i \theta (f_{i}^\dagger f_{j}^\dagger + f_{j} f_{i}))$.
  • NumberPotential(coefficients [, sites]): Efficient representation of weighted density sums $\sum_{i \in \mathrm{sites}} \alpha_i n_i$.
  • CoulombSum(tensor): General Coulomb interaction $\sum_{i,j,k,l,\sigma,\sigma'} V_{ijkl} a_{i\sigma}^\dagger a_{j\sigma'}^\dagger a_{k\sigma'} a_{l\sigma}$ on interleaved spin-orbitals.
• Unified Fermionic operator naming conventions and added legacy aliases (FourBody, DoubleExcitation, NumberN, NumberNumberNN, NumberNumberNNN) for backward compatibility.
• Added Discrete Cosine Transform (DCT) and Discrete Sine Transform (DST) functions with support for types I-IV, custom normalization, and orthonormal scaling. Both transforms support 1D and 2D operations on Matrix and Array types.
• Forge scripts can now declare arguments and retrieve them with get_arg(name, type[, default]), enabling typed inputs to be provided when launching executions or scheduling jobs.
• Added function to compute the specific heat from the order estimator sse_specific_heat(order).
• The history of an SSE simulation can now be recorded and read/written from/to an HDF5 file allowing for checkpointing of simulations and for post processing.

---

🐛 Fixes​

• Added string parsing support for complex conversion in Aleph, so expressions like complex("2 + 1i") and "2 + 1i".complex() now work.
• Fixed LSP semantic token locations for interpolated member access (for example ${ab.first}), avoiding invalid and overlapping semantic tokens in editors.
• Mixed-complexity operator expressions that previously caused errors now work correctly. For example, 2.0 * X(0) + 3.0i * Y(1) is now a valid expression.
• Fbit and Qbit can faithfully represent BasisStates with up to 64 sites, and will throw an error if an attempt is made to create a BasisState with more than 64 sites. This prevents silent truncation of states that was previously occurring.

---

⚠️ Breaking Changes​

• Failed string-to-number conversions now throw an error instead of defaulting to 0. This affects conversions like real("abc") and integer("abc"). Loss-of-precision conversions still behave as before, e.g. integer("5.3") -> 5.

---

✨ New Features​

• Added Figure.visual_map(...) options in the Plotting module.
• Automatically add a default visual_map when none specified when a figure has a heatmap.
• MPS and MPO operator "+" perform the exact addition, with output bond dimension equal to the sum of that of each tensor network.
  • Repeated addition cause a linear increase in bond dimension.
  • use .compress to control the growth for MPS.
• MPS and MPO operator "*" perform the exact operator-state and operator-operator mulitplication. Output bond dimension is the product of that of each tensor network.
  • Repeated multiplication causes an exponential increase in bond dimension.
  • use .compress to control the growth for MPS.
• explicit management of boundary condition for MPS and MPO. Important to set it correctly for full compression.
  • .open_boundary() to open the boundary condition, .periodic_boundary() for periodic boundary condition.
  • .set_boundary_like(mps | mpo) to set the boundary condition like another TN.
  • DMRG only works with open boundary condition MPS and MPO. 

---

🐛 Fixes​

• Fixed LSP semantic tokenization of interpolated strings where the implicit string(...) call could mark the start of a literal as a function.
• Added correct semantic token locations inside ${...} interpolation spans.

---

🚀 Highlights​

• Restored LSP diagnostics

---

🐛 Fixes​

• Re-enabled Language Server Protocol (LSP) diagnostics that were accidentally disabled.
• Diagnostics (errors, warnings, hints) are now properly reported again in supported editors and in Kai.

🚀 Highlights​

• Rewrite of HDF5File support in Datafiles to enable reading/updating platform-stored files, in addition to writing new files.
• HDF5File now supports reading/writing HDF5 files up to version 2.0 and provides compression options.
• HDF5File supports many Aleph types (lists, arrays, tensors, and more).
• Added TextFile support for reading/writing files as strings.

---

✨ New Features​

• Rewrote HDF5File support in Data Files to allow reading and updating platform-stored files, in addition to writing new files.
• HDF5File now supports reading/writing HDF5 files up to version 2.0 and includes compression options.
• HDF5File supports many Aleph types, including lists, arrays, and tensors.
• Added TextFile for reading/writing files as strings.

---

⚠️ Breaking Changes​

• operator_function API has changed to support both Hermitian and non-Hermitian operators; it now accepts an option map similar to that of iterative_eigensolver. See the New Features section for details.
• HDF5File types and functions have been substantially updated and may break code written prior to this release; this binding is expected to be stable moving forward.

---

🚀 Highlights​

---

✨ New Features​

• Introduced the Plotting module to create figures in Aleph for data analysis, including bar, line, scatter, and heatmap plots.
  • Supports legends, multiple series, multiple plots in the same figure, and a ton of customization options.
• Functions for the computation of matrix elements and expectation values with MPS and MPO.
  • matrix_element(bra,operator,ket) to compute the matrix element $\bra{\phi} O \ket{\psi}$ of an operator.
  • expval(operator,ket) to compute the expected value $\bra{\psi} O\ket{\psi}$ of the operator.
• Added accumulators for binning analysis of time series and markov chain data. Currently support accumulator("no_binning") and accumulator("binning"). The bin size can be set via accumulator("binning" ["bin_size" : 1024 ]).
• Added a FourBody symbolic fermionic operator: $c^{\dag}_{i}c^{\dag}_j c_k c_l$. An operator can be created via FourBody(i,j,k,l) where i,j,k,l are the sites where the operator acts.
• Added a DoubleExcitation fermionic operator: $c^{\dag}_{i}c^{\dag}_j c_k c_l + h.c.$. An operator can be created via DoubleExcitation(i,j,k,l) where i,j,k,l are the sites where the operator acts.
• The array and matrix factories now accept array and matrix objects together with a type tag. For example: array(my_matrix, as_complex) will create a complex array from my_matrix even if it is of real type.
• MPS compression routine. mps.compress(tol) to compress a MPS to specified error tolerance.
• operator_function now supports both Hermitian and non-Hermitian matrices and operators. The appropriate Krylov method (Lanczos or Arnoldi) is automatically selected based on the input. The API can be summarized as:
  • operator_function(H, dim, fun(real){real}, ["is_real":true]) for real-valued functions and Hermitian operators. Note that the ["is_real":true] option is required to indicate that the function is real-valued.
  • operator_function(H, dim, fun(complex){complex}) for other Hermitian operators.
  • operator_function(H, dim, fun(complex, integer){complex}) for non-Hermitian operators. The integer argument stands for the order of the derivative of the function, which is required for non-Hermitian operators.
  • Any of the above can also be called with a matrix Hmat instead of an operator H and a dimension dim.
  • Any of the above also accepts an optional dictionary of options as last argument, e.g. ["krylov_dimension": 32].
• The PhaseHop(angle,i,j) factory function has been added to create fermionic hopping operators with an associated phase factor: $e^{i \cdot angle} c^{\dag}_i c_j + \mathrm{h.c.}$.

---

🐛 Fixes​

• Assigning complex arrays or matrices to real arrays or matrices used to silently fail, it now raises an error.

---

⚙️ Internal / Technical Changes​

• Adds internal support for handling sparse matrix operations with free fermion objects.

• Real arrays and matrices are not implicitly convertible to complex arrays and matrices anymore. An explicit conversion is now required using as_complex.

• Cmake presets to help manage compilation with IDE/VScode.

  • Presets for qbitpp
  • Presets for chaiqpp

• VScode devcontainer mount the user's .ssh for syncing with gitlab.

  • no further setup required for syncing git, if the user already has set his ssh keys in $HOME/.ssh

⚠️ Breaking Changes​

• operator_function API has changed to support both Hermitian and non-Hermitian operators; it now accepts an option map similar to that of iterative_eigensolver. See the New Features section for details.

---

🧪 Migration Notes​

---

Development​

🚀 Highlights​

---

✨ New Features​

• Introduced the Plotting module to create figures in Aleph for data analysis, including bar, line, scatter, and heatmap plots.
  • Supports legends, multiple series, multiple plots in the same figure, and a ton of customization options.
• Functions for the computation of matrix elements and expectation values with MPS and MPO.
  • matrix_element(bra,operator,ket) to compute the matrix element $\bra{\phi} O \ket{\psi}$ of an operator.
  • expval(operator,ket) to compute the expected value $\bra{\psi} O\ket{\psi}$ of the operator.
• Added accumulators for binning analysis of time series and markov chain data. Currently support accumulator("no_binning") and accumulator("binning"). The bin size can be set via accumulator("binning" ["bin_size" : 1024 ]).
• Added a FourBody symbolic fermionic operator: $c^{\dag}_{i}c^{\dag}_j c_k c_l$. An operator can be created via FourBody(i,j,k,l) where i,j,k,l are the sites where the operator acts.

---

🐛 Fixes​

---

⚙️ Internal / Technical Changes​

---

⚠️ Breaking Changes​

---

🧪 Migration Notes​

---

🐛 Known Issues​

• Saving a figure file in a subfolder throws an error if the subfolder does not exists during the execution process.

---

🚀 Highlights​

---

✨ New Features​

• Functions for the computation of matrix elements and expectation values with MPS and MPO.
  • matrix_element(bra,operator,ket) to compute the matrix element $\bra{\phi} O \ket{\psi}$ of an operator.
  • expval(operator,ket) to compute the expected value $\bra{\psi} O\ket{\psi}$ of the operator.
• Added accumulators for binning analysis of time series and markov chain data. Currently support accumulator("no_binning") and accumulator("binning"). The bin size can be set via accumulator("binning" ["bin_size" : 1024 ]).

---

🛠 Improvements​

---

`

🐛 Fixes​

---

⚙️ Internal / Technical Changes​

---

⚠️ Breaking Changes​

---

🧪 Migration Notes​

---

v0.29.1​

🚀 Highlights​

---

✨ New Features​

---

🛠 Improvements​

---

🐛 Fixes​

• Fixed lattice factories for oblique, rectangular and honeycomb geometries which were throwing errors for incorrectly defining the basis vectors.

---

⚙️ Internal / Technical Changes​

---

⚠️ Breaking Changes​

---

🧪 Migration Notes​

---

🚀 Highlights​

• Significant improvements to Aleph’s parallel-execution story: async now runs on a shared worker pool, and await_all, parallel_map, plus sleep round out the toolkit for structured concurrency.
• Model class has been revamped. Now as opposed to adding general functions via add_term(XX, neighbourhood) we have add(term([X, X], neighbourhood)). The add method is also more general, allowing for add(neighbourhood_rule(...)) and add(coefficient(...)).
• Model's add_observable method has been replaced with measure which takes a name and a term, (e.g.my_model.measure("name", Term(...)).
• Term and Coefficient have been introduced as helper types when defining model, with associated factories term and coefficient.
• Added new fermionic operators: NumberNumber which is a fused version of Number * Number, Number(List) a fused sum of number operators, NumberNumberNN a fused sum of NumberNumber operators for nearest-neighbours, and NumberNumberNNN a fused sum of NumberNumber operators for next nearest neighbours.

---

✨ New Features​

• await_all(futures) waits for each Future in a list, consuming the inputs and returning the resolved values in submission order.
• parallel_map(values, mapper) applies the mapper concurrently across the shared async pool, keeping results aligned with the original list.
• sleep(seconds) pauses execution for a positive duration, throwing if a negative value is supplied.
• We added an eigensolver factory that picks the appropriate eigenvalue solver based on the properties of the input matrices, solves the eigenvalue problem and returns an object representing the solution. It currently supports standard and generalized eigenvalue problems for dense matrices (real, complex, Hermitian or not). The returned object has methods eigenvalues and eigenvectors to retrieve the eponymous quantities.
• We added an svd factory that computes the SVD decomposition of any dense matrix. It supports two algorithms: Jacobi and BDC. The default is Jacobi, which is more accurate for small and medium sized matrices, while BDC is faster for large matrices. The returned object has methods singular_values, matrix_u, and matrix_v to retrieve the eponymous quantities.
• We added a cholesky factory that computes the Cholesky decomposition of symmetric (Hermitian) matrices. It supports two algorithms: standard (LLT) and robust (LDLT). The default is standard, which requires the matrix to be positive definite. The robust algorithm (LDLT) can handle positive or negative semidefinite matrices. The returned object has methods matrix_l and matrix_u to retrieve the factors.
• We added an lu factory that computes the LU decomposition of any dense matrix. It supports two pivoting strategies: partial and full. The default is partial pivoting. The returned object has methods matrix_l, matrix_u, and matrix_p (and matrix_q for full pivoting) to retrieve the factors.
• We added a qr factory that computes the QR decomposition of any dense matrix. It supports three pivoting strategies: none, partial (column pivoting), and full. The default is no pivoting. The returned object has methods matrix_q, matrix_r, and matrix_p (if pivoting is used) to retrieve the factors.
• Add fast fourier transform (FFT) support with real-to-complex (r2c) and complex-to-complex (c2c) transforms
  • Support for 1D and 2D FFT operations via configurable axes parameter
  • Complex-to-complex transforms support forward and backward modes via fft and ifft functions
  • Real-to-complex transforms provide forward FFT only
• Added mpo(model) function to convert lattice models to finite MPO representations. This enables direct MPO construction from a Model definitions for use in DMRG and tensor network algorithms.
• Added observables_to_mpo(model) function to convert observables defined in a Model to MPO form, returning a map of observable names to their MPO representations.

---

🛠 Improvements​

---

🐛 Fixes​

• Container methods resize, insert, insert_at, replicate, replicated, extend and extended now clone inserted elements to match existing push_back, assignment, and constructor behavior.
• Restores the missing documentation for List::push_back in the API reference.
• Fixed a documentation bug regarding the factory functions make_random_mps and make_random_mpo, they were wrongly classified as functions and the first argument was missing from the documentations.

---

⚙️ Internal / Technical Changes​

• Added copy constructors for BoundaryCondition types.

---

⚠️ Breaking Changes​

• All container insertion methods now clone their inputs, so scripts that relied on resize, insert, insert_at, replicate, replicated, extend or extended mutating the original values will behave differently.

---

🧪 Migration Notes​

---

🚀 Highlights​

---

✨ New Features​

• Added a new fermionic operator: NumberNumber which is a fused version of Number * Number.

---

🛠 Improvements​

---

🐛 Fixes​

• Prints Aleph's registered type names and the underlying exception message when an unhandled boxed exception escapes, restoring meaningful runtime error messages.

---

⚙️ Internal / Technical Changes​

• Boundary conditions are now bound through a similar pattern to other enum types, appearing as static member of a global boundary_condition variable.

---

⚠️ Breaking Changes​

• Boundary conditions are now denoted with the pattern boundary_condition.open, boundary_condition.periodic etc... as opposed to the old syntax, open_bc, periodic_bc etc...

---

🧪 Migration Notes​

---

v0.27.1​

🚀 Highlights​

---

✨ New Features​

---

🐛 Fixes​

• Fixed a bug whereby two-element lists were implicitly converted to interval objects. This issue could lead to unexpected behavior.
  • Example: >>> [1,2] //-> Interval(lower=1.000000, upper=2.000000).

---

⚙️ Internal / Technical Changes​

---

⚠️ Breaking Changes​

• The Chebyshev series factories and fit function no longer accepts two-element lists as interval specifications. Users must now explicitly use the interval factory to define intervals.
  • Example: Instead of chebyshev_series_delta(10, [a, b]), use chebyshev_series_delta(10, interval(a, b)).

---

🧪 Migration Notes​

---

🚀 Highlights​

• Added Model class which can be used to represent arbitrary lattice Hamiltonians and construct associated observables.
• The function chebyshev_series_delta and operator_chebyshev_series can be used together with iterative_eigensolver to compute interior eigenvalues and eigenvectors of operators. This is particularly useful for large-scale problems where traditional matrix representations are infeasible.
• Linear Algebra now has sparse matrices.
• Tensor multithreaded operations.

---

✨ New Features​

• The matrix factory (which returns the matrix representation of an operator) now supports the as_sparsematrix type tag as an optional argument. This allows users to directly obtain a sparse matrix representation of an operator. Note that the type tag can be combined with other type tags such as as_real to specify the desired scalar type of the resulting sparse matrix (i.e. as_real | as_sparsematrix).
• The Model class can be used to represent a Hamiltonian and observables in terms of lattice coordinates.
• A new overload for operator_sum that takes an instance of Model and returns either a complex (default) or real OperatorSum depending on the type specifier (as_complex or as_real)
• The chebyshev_series_delta function creates a Chebyshev series that approximate the delta function over a specified interval. This is useful for spectral filtering and other applications requiring delta function approximations.
• The operator_chebyshev_series factory has been added to create operators based on Chebyshev series. This allows for efficient representation and manipulation of operators using Chebyshev polynomial expansions.
• Added more count methods to Fbit that help in counting the number of occupied sites on subsets and linear cuts of the system.
• Sparse matrices can be specified as a list of lists of numbers, similar to dense matrices but with the as_sparsematrix flag. One can also convert arrays and dense matrices directly to sparse matrices with the matrix factory. One can also create sparse matrices is by initializing them with the zeros, identity, uninitialized factory. Yet another way is to use insert which accepts three arguments: an array of row indices, an array of column indices, and an array of values. Lastly, one can of course use [] to extract elements or assign to them.
• Sparse matrices support addition, subtraction, multiplication (including with dense matrices), transposition, and conversion to dense matrices.
• Tensor multithreaded operations.
• Set to the detected hardware concurrency by default.
• The function set_tensor_threads(thread_number) can be invoked to control the thread count for tensor operations.
• Aleph global's control will override the tensor threadcount whenever it is called.
• Add extended for lists, an out-of-place extension of a list by an input list.
• Add as_real variants for TimerDuration conversion methods: hours, microseconds, milliseconds, minutes, seconds to retrieve more precise values when needed.

---

🛠 Improvements​

• Add operator multiplication between OperatorSum and scalars with mixed coefficient types, enabling operations; real * ComplexOperatorSum and complex * RealOperatorSum.

---

🐛 Fixes​

• stdout is now forced into line-buffered mode when Aleph runs without a TTY, ensuring CI/job executions emit work-in-progress logs immediately.
• time, benchmark_for and benchmark_for are now marked standalone, bringing the documentation to the Module Functions section.

---

⚙️ Internal / Technical Changes​

---

⚠️ Breaking Changes​

• The Polynomial class eval method has been renamed to evaluate for improved clarity and consistency.
• The Polynomial class evaluate method returns objects of the same type as the input argument. For example, if the input is a list, the output will also be a list.

---

🧪 Migration Notes​

🚀 Highlights​

---

• Scalar-type-independent factory function names for improved ergonomics when building tensors.
• New tensor shape manipulation methods: transpose, flatten, and squeeze.
• Element-wise tensor-scalar operations: addition, subtraction, multiplication, and division.
• Unified API: random_tensor, filled_tensor, zero_tensor, delta_tensor, uninitialized_tensor.

✨ New Features​

---

• Real and complex tensors now support .conjugate().
• Tensor Method transpose(tensor, permutation): permutes tensor dimensions with validation.
• Tensor Method flatten(tensor): reshapes tensor into a order 1 tensor.
• Tensor Method squeeze(tensor): removes all dimensions of size 1 from a tensor.
• Tensor-Scalar Operations: tensor + scalar, scalar + tensor, tensor - scalar, scalar - tensor for element-wise arithmetic.

🛠 Improvements​

---

🐛 Fixes​

---

• Improved numerical stability of DMRG with large numbers of sites.

⚙️ Internal / Technical Changes​

---

• Re-implement tensor contraction to reduce compile times.

⚠️ Breaking Changes​

---

• Tensor factory functions renamed: random_real_tensor → random_tensor, filled_complex_tensor → filled_tensor, etc...
  • All factory calls can specify the scalar type by parameters: as_real or as_complex (e.g., random_tensor([2, 3], as_complex)).
  • Default scalar type is complex; You must use as_real for real-valued tensors.

🧪 Migration Notes​

🚀 Highlights​

• Random number generation and random distributions are now in Aleph.
• Aleph now supports creating random matrices using user specified distributions. Additionally, the default interval for randomly generated matrices is $[0,1]$ not $[-1,1]$.
• Native and binding-level exceptions now produce proper Aleph call-stack traces, making errors far easier to understand and debug.

---

✨ New Features​

• random function can be used to generate random numbers on the fly.
• random_distribution factory can produce user specified distributions.
• random_generator allows users to seed their own random number generators.
• set_random and random_like can now take a Distribution specified by the user.
• Add functionality to extract the reduced density matrix of a many-body state.
• Add von Neumann and Rényi entropies functions.
• Automatic call-stack capture for any std::exception escaping AST evaluation.
• Consistent error formatting between native errors and script-level EvalError.
• Real and Complex tensor now support .conjugate() and conjugated() methods for complex conjugation. Leave the tensors unchanged in the real case.

---

🛠 Improvements​

• Improved Library Reference: Operator types now appear consistently in the Types section with proper documentation, while constructors and internal operations are hidden from the Functions section.

---

🐛 Fixes​

• Improved numerical stability of DMRG with large number of sites.