30 posts tagged with "aleph"

🚀 Highlights​

• JSON files can now be read, edited, and saved directly from Aleph scripts.

---

✨ New Features​

• Added JSONFile for creating, reading, editing, and saving JSON documents. It supports JSON Pointer selection, conversion to primitive values, typed lists, and numeric containers, and compact or pretty output. Changes remain in memory until save() or save_as() is called.

---

🛠 Improvements​

---

🐛 Fixes​

---

⚙️ Internal / Technical Changes​

• Updated internal JSON handling

---

⚠️ Breaking Changes​

---

🧪 Migration Notes​

---

🚀 Highlights​

• Refreshed Aleph's build toolchain and runtime packaging.
• CSV files can now be read, edited, and saved directly from Aleph scripts.
• Editor feedback is more responsive while writing Aleph scripts.

---

✨ New Features​

• Aleph scripts can now create, read, edit, and save CSV files with CSVFile. It supports named or indexed rows, columns, and cells; configurable headers, delimiters, quoting, comments, and line endings; and conversion to primitive values, arrays, matrices, sparse matrices, and tensors.

---

🛠 Improvements​

• Highlighting and hover information stay current as you edit, even when several files are open or included files are loading.

---

🐛 Fixes​

• Removed misleading editor warnings for valid range slicing and matrix indexing.

---

⚙️ Internal / Technical Changes​

---

⚠️ Breaking Changes​

• CSVDocument has been replaced by CSVFile. Constructor options and access methods have been renamed, and changes made through a writable CSVFile remain in memory until save() or save_as() is called.

---

🧪 Migration Notes​

• Replace CSVDocument with CSVFile, pass the file mode before the options map, and remove the get_ prefix from access methods. Use type tags such as as_real when requesting converted values:

  # Before
  var values = CSVDocument("data.csv", ["label_row_index": 0]).get_column("value", real)
  
  # Now
  var values = CSVFile("data.csv", "r", ["row_header_column": 0]).column("value", as_real)
  

  Rename CSV options as follows:

  Previous option	CSVFile option
  label_column_index	column_header_row
  label_row_index	row_header_column
  separator	delimiter
  quoted_linebreaks	allow_quoted_line_breaks
  quote_char	quote_character

  The trim, auto_quote, skip_comment_lines, comment_prefix, and skip_empty_lines names are unchanged. Options are fixed when the file is opened.

  Use column, row, and cell instead of the former get_column, get_row, and get_cell methods. Writable files also provide set_*, insert_*, and remove_* methods. Call save() to persist changes to the current workspace path, or save_as(path) to write them to another path.

---

🚀 Highlights​

• Improved the reliability and scalability of the hosted LSP server under heavy load.

---

🐛 Fixes​

• Fixed issues with the hosted LSP server that could cause excessive memory usage and connection failures under heavy load.

🚀 Highlights​

• Numeric-heavy Aleph code is substantially faster. In benchmarks, range loops run about 59–61% faster, sliced ranges run 83% faster, and common integer loop forms run 52–84% faster, while eliminating almost all loop-temporary allocations.
• Improvements to LSP type analysis.

---

✨ New Features​

• Added dmrg0s, a zero-site DMRG solver, to the tensor-network bindings for both real and complex scalars.
  • Optimizes the orthogonality center while it is on the bond between sites.
  • Supports chains with three or fewer sites, unlike the two-site dmrg.
  • Supports global enrichment heuristics ("none", "power", "lanczos") and local enrichment heuristics ("move_only", "memory").
    • Without an enrichment heuristic, the bond dimension of the input MPS cannot grow, only shrink.
  • In addition to all the options of the base dmrg function, dmrg0s also accepts global_enrichment, lanczos_iterations, local_enrichment, memory_depth, and memory_once_per_sweep to control the enrichment strategies.
  • Zero-site DMRG is still experimental and in need of better heuristics to achieve tangible advantages over the two-site update.
    • While significantly faster, it fails to converge to the same high precision as the two-site update.

---

🛠 Improvements​

• Reduced overhead in numeric loops, range iteration, temporary values, and repeated function calls.
• Expanded LSP type analysis:
  • Joins symbol and return types across control-flow paths, warns about possibly unassigned reads, and narrows recognized is_type branches without executing user code.
  • Composes type narrowing through negated and short-circuit predicates, and recognizes is_var_undef as a safe definite-assignment probe.
  • Infers source-declared and host-registered attributes, nominal dynamic-object constructors, collection literals, numeric ranges, and ranged-for bindings without executing constructors, getters, or iterator functions.
• set_random now accepts a random number generator, allowing for controlled seeding.

---

🐛 Fixes​

• JSON \uXXXX escapes now decode to UTF-8, including supplementary characters represented by surrogate pairs. Malformed, truncated, and unpaired surrogate escapes now produce a parse error.
• Exceptions that do not match a typed catch now continue propagating after finally runs, instead of being silently replaced with void.
• Excessive script recursion now stops with a controlled recursion-depth error instead of exhausting the native call stack.
• %= with a zero divisor now reports an arithmetic error consistently with division and remainder operations.
• Keys returned from temporary maps, such as keys(["a": 1]), now remain valid after the source map is destroyed.
• Switch comparisons and mutating overload resolution now preserve converted values correctly and prefer an exact receiver over a converted temporary.
• Shutting down an Aleph interpreter now waits for its outstanding async work, preventing queued or running tasks from accessing a destroyed interpreter.

---

⚠️ Breaking Changes​

• Consecutive declarations inside a class must now be separated by a newline or semicolon. Previously, malformed same-line declarations such as var x var y could be accepted.
• Numeric range literals now always use Aleph's built-in range behavior. Redefining generate_range no longer changes [start..stop], and directly sliced range loops use Aleph's built-in slicing behavior.
• Assignments between built-in numeric values now always use Aleph's standard assignment behavior instead of replacement operator functions. Operator overloads for user-defined types are unchanged.

---

🧪 Migration Notes​

• Separate declarations in class bodies:

  # Invalid
  class Point { var x var y }
  
  # Valid
  class Point {
    var x
    var y
  }
  

• Call a custom range-building function explicitly instead of expecting it to replace range-literal behavior:

  # Before: redefining generate_range could affect this literal.
  var built_in_values = [start..stop]
  
  # Now: use an explicit call when custom behavior is wanted.
  var custom_values = generate_range(start, stop)
  

• Store a range before slicing it when the registered [] operator should be used:

  # Uses Aleph's built-in fused range slicing.
  for (value: [start..stop][::2]) {}
  
  # Uses the registered [] operator for values.
  var values = [start..stop]
  for (value: values[::2]) {}
  

• Built-in numeric assignment always has its standard meaning. Put custom assignment behavior on a user-defined type:

  var total = 1
  total += 2  # Always produces 3.
  
  class Total {
    var value
  
    def Total(value) {
      this.value = value
    }
  
    def `+=`(amount) {
      this.value += amount
      this
    }
  }
  
  var wrapped_total = Total(1)
  wrapped_total += 2  # Calls Total.`+=`.
  

---

🚀 Highlights​

• Aleph scripts now have less name-lookup and allocation overhead. Compared with the baseline recorded before this performance work began, the runtime is 3.4% faster across the original 11-benchmark suite, with targeted name-heavy workloads improving by up to 62.2%. Further runtime optimizations are planned as part of this ongoing work.
• Numerical Pauli strings now support systems of $N \leq 256$ qubits through the renamed PauliString and PauliStringSum.

---

✨ New Features​

• Aleph functions, overloads, methods, and constructors can now declare AlephDoc metadata in JSDoc-style /** ... */ comments for editor hovers and generated API documentation.
• Numerical Pauli strings are now more powerful:
  • Renamed PauliTerm → PauliString and PauliSum → PauliStringSum to be more expressive.
  • They support $N \leq 256$ qubits.
  • Added a new constructor PauliString(string, sites, num_qubits) for easier control over Pauli string creation.
  • Printing now displays the string only for the number of qubits in the Hilbert space.
  • Verbose printing is now available via display() for both PauliString and PauliStringSum.

---

🛠 Improvements​

• Reduced temporary allocations in function calls, arithmetic, container operations, and other interpreter hot paths. Targeted benchmarks perform approximately 50–78% fewer allocations.
• Optimized variable, function, global, and type-name lookup. Scripts with wide local scopes run 28.3% faster, with 27.6% fewer allocations and 32.6% fewer allocated bytes; lookup in large engine name tables is 62.2% faster.
• Aleph LSP callable analysis now:
  • Reads typed native and script signatures without executing user code.
  • Infers straightforward function, method, constructor, and overloaded call results for hover.
  • Reports NoMatchingOverload warnings only when every arity-compatible overload is statically impossible.
  • Preserves dynamic any and indeterminate suppression, registered conversions, included callable metadata, and runtime guard behavior.
• Aleph LSP type analysis now:
  • Shows inferred result types in hover for native and Aleph functions, methods, constructors, operators, assignments, indexing, and member access.
  • Warns when known argument types cannot match an overload or when a value cannot be assigned to a variable's established type.
  • Remains permissive for intentionally dynamic or incomplete code.
• Document formatting now normalizes Aleph source documentation blocks, while malformed tags produce non-blocking editor warnings.
• Added hover and API documentation for Aleph-defined standard-library functions.

---

⚙️ Internal / Technical Changes​

• Aleph now resolves names once and uses compact, per-engine identifiers during execution. Human-readable names and portable runtime snapshots are retained for diagnostics, tooling, and interoperability.

---

⚠️ Breaking Changes​

• Replaced the Aleph types PauliTerm and PauliSum with PauliString and PauliStringSum. Constructors and convert_to_pauli_sum(...) now require the number of qubits, while xbits() and zbits() now return lists of 64-bit chunks.

---

🧪 Migration Notes​

• Rename PauliTerm to PauliString and PauliSum to PauliStringSum, then pass the system size explicitly. For example, use PauliString("XZ", [0, 70], 128) and PauliStringSum(128). Update single-chunk bit access such as p.xbits() to p.xbits()[0].

🚀 Highlights​

• NumPy .npy and .npz files can now be read and written.
• Aleph editor hovers now show best-effort inferred types for variables and function parameters.

---

✨ New Features​

• Added NumpyFile support for NumPy .npy and .npz files in Datafiles.
  • .npy files support direct reading and writing of scalars and lists.
  • .npz archives support named datasets, existence checks, dataset listing, and shape, rank, size, and dtype inspection.
  • Supported primitive types include Boolean, integer, real, complex, and string values.
  • Supported data structures include arrays, matrices, sparse matrices, and real and complex tensors.

---

🛠 Improvements​

• Improved Aleph LSP hover information with inferred types for:
  • Variables initialized with literals.
  • References.
  • Typed parameters.
  • Variables whose types are established by their first assignment.
  • Parameters without an explicit Aleph type appear as any in hover information, reflecting their existing dynamic behavior without introducing new Aleph syntax.

🚀 Highlights​

• SSE Monte Carlo Aleph have been dramatically reworked to include customizable abstract loop and cluster update algorithms via the new SSEAlgorithm type.

✨ New Features​

• Added SSEAlgorithm as the primary SSE Monte Carlo binding type, including sse_algorithm(...) factory/read APIs and HDF5 read/write support.
• Added run(...)-based production sweep bindings with optional options maps (flip_probability, estimate_period, record_period, max_loop, estimate_rdm) and count_matrix() access for transition statistics.
• Added parameter based access to SSEAlgorithm allowing for custom abstract loop and cluster update probabilities.

---

🐛 Fixes​

• TextFile(path) and HDF5File(path) now use lazy read/write create mode.
  • Missing default/append-mode files are not created by read-style handle construction or existence/listing checks; parent directories and files are created only by write-like operations that need them.
  • HDF5File query helpers such as exists, is_group, is_dataset, has_attribute, and list methods now return false or an empty list for missing lazy files or missing query targets, while data reads and explicit "r"/"r+" still require the file/object to exist.

---

⚠️ Breaking Changes​

• Renamed the bound SSE type and constructors from SSESimulation / sse_simulation(...) to SSEAlgorithm / sse_algorithm(...).
• Replaced simulate(...) with run(...) for production sweeps, and changed several SSE method overloads from positional parameters to options-map based configuration.

---

🧪 Migration Notes​

• Replace SSESimulation usages with SSEAlgorithm, and update constructor/read calls from sse_simulation(...) to sse_algorithm(...).
• Rename production sweep calls from simulate(...) to run(...), and pass sweep controls (for example record_period and max_loop) via options maps where needed.

---

✨ New Features​

• Quality of life improvements for numerical Pauli strings:
  • Added * overloads for PauliTerm and PauliSum.
  • Can now compute the expectation value $\\langle S \\rangle$ of a PauliSum with a Qbit.
  • The Pauli string of a PauliTerm or PauliSum can now be printed in a more readable format using display.
  • Added a transform_coefficients method for PauliSum that applies a function to each element of the sum.
  • Added adjoint and adjointed methods, which perform the Hermitian conjugate in-place and out-of-place on a PauliSum, respectively.
• Aleph fermionic operators are now unified under a shared FermionOperator type. Factory functions such as Create, Destroy, Number, TransferSum, PairingSum, QuadraticSum, and the tensor-based fermion operator factories now all return FermionOperator values.
• Fermionic operators in Aleph now support consistent introspection through name(), sites(), and parameters():
  • name() returns the operator kind as a string.
  • sites() returns the operator sites in definition order.
  • parameters() returns the operator payload when present, such as a parameter list, a rank-4 tensor, or a quadratic sparse matrix.

---

🛠 Improvements​

• Quadratic fermion helper methods such as get_bdg_matrix() and get_bdg_shift() now work through the shared FermionOperator binding surface.

---

🐛 Fixes​

• Fixed MPO generation from lattice models and operators in more than one dimension.

---

⚠️ Breaking Changes​

• Aleph fermionic operator values now report the unified FermionOperator type instead of older binding-specific concrete type names.

---

🧪 Migration Notes​

• If your code compared fermionic operator type_name() results against older binding-specific names, update those checks to use FermionOperator.
• If you were inspecting fermionic operators through binding-specific type distinctions, switch to the shared name(), sites(), and parameters() accessors.

✨ New Features​

• Added New classes PauliTerm and PauliSum to speed up operations involving pauli strings.
  • PauliTerm represents a Pauli string $P = c \prod_n O_n , \quad O_n \in \{ I, X, Y, Z \}$. They can be scaled, multiplied in and out of place with eachother, and can check if they commute.
  • PauliSum represents a sum of PauliTerms. The sum can be truncated by the weight of the strings or by the norm of their coefficient. Explicit commutators between a single Pauli string or a sum of them as a PauliSum can be computed. The sums can also be conjugated by Pauli rotations $U^{\dag} S U$ where $U = \exp(i \theta Q)$ and Q is a Pauli string.
  • Conversions between this numerically efficient type and the Operator framework can be done via the convert_to_paulisum and convert_to_operatorsum functions.

---

🚀 Highlights​

• Aleph editor support now provides better assistance for function and method calls, including hover details, signature information and clearer call-related warnings.
• Sparse eigensolver bindings now expose a cleaner options and status API through EigsOptions, EigsStatus and the shared EigsBase binding.

---

✨ New Features​

• Sparse eigensolver bindings now expose EigsOptions as a first-class Aleph type.
• Iterative solver objects now provide grouped get_options() and get_status() accessors through a shared EigsBase binding.
• Sparse eigensolver option validation now treats krylov_dimension = 0 as "use the solver default" while still rejecting negative values.
• Aleph operator_function(...) now defaults to an implicit Krylov dimension based on the input operator dimension when no explicit krylov_dimension is provided.
• Aleph editor support now warns about unknown function or method calls and calls with the wrong number of arguments.
• Hovering over a function or method call now shows its signature and documentation when available.
• Note: method checks are not type-aware yet, so some method warnings or hover results may still be broader than expected.

---

🐛 Fixes​

• Improved Aleph formatting for multiline list and map literals, block argument commas, reference bindings, include module paths, numeric suffixes and unary operator spacing.
• Fixed Aleph to_throw_message expectations so they correctly match messages from Aleph-thrown exceptions such as RuntimeError.
• Failed to_throw_message expectations now report the actual thrown message.
• Fixed Aleph LSP semantic highlighting for indented nested test_section declarations.

---

⚠️ Breaking Changes​

• Sparse eigensolver status inspection in Aleph has been simplified: EigsStatus.status now returns a readable string such as "successful" instead of the previous enum-style helper surface.
• The sparse eigensolver base binding is now the non-generic EigsBase type.
• EigsBase now exposes grouped EigsOptions and EigsStatus objects instead of many per-field getters and setters.

---

🧪 Migration Notes​

• If you were comparing eigensolver status values against the old enum helper objects, switch those checks to string comparisons using EigsStatus.status.
• If you were reading solver metadata through the old EigsBase<...> field-style accessors, migrate to get_options() and get_status() and inspect the returned EigsOptions and EigsStatus objects.

🚀 Highlights​

• Polynomial and ChebyshevSeries bindings in Aleph now expose clearer typed names and richer editing APIs, including explicit real/complex variants and mutable coefficient/interval setters.
• Spin-half symbolic operators are now easier to inspect from Aleph. In addition to the existing dynamic parameters() accessor, you can now ask for common payload kinds explicitly, which makes scripts clearer and gives documentation and LSP more useful return types.
• Example:
  • var angles = RotEuler(0.1, 0.2, 0.3, 0).parameters(as_list)
  • var dense = operator_dense(matrix([[0, 1], [1, 0]], as_real), [0]).parameters(as_matrix | as_real)
  • var word = pauli_string("XYZ", [0, 2, 4]).parameters(as_string)
• Introduced quadratic operators which can be used to efficiently represent and manipulate quadratic fermionic Hamiltonians.

---

✨ New Features​

• operator_function's options now include mode, which can be set to 0 (default) or 1 for Hermitian operators. 0 is usually more efficient, because multi-threaded, but 1 is more robust.

• Added typed Aleph bindings for polynomial and ChebyshevSeries objects:

  • RealPolynomial and ComplexPolynomial
  • RealChebyshevSeries and ComplexChebyshevSeries

• Added typed Aleph bindings for operator-valued polynomial and ChebyshevSeries constructions:

  • RealOperatorPolynomial and ComplexOperatorPolynomial
  • RealOperatorChebyshevSeries and ComplexOperatorChebyshevSeries

• Polynomial and ChebyshevSeries bindings now expose setter-style editing APIs:

  • set_coefficients(...) for both polynomials and ChebyshevSeries objects
  • set_interval(...) for ChebyshevSeries objects

• Polynomial bindings now expose scalar division and unary plus consistently in Aleph.

• Added typed parameter inspection for symbolic spin-half operators in Aleph.

• You can still use parameters() for a generic dynamic result, but you can now request specific payload forms when you know what kind of operator you have:

  • parameters(as_list) for parameter lists such as rotation angles or permutation data
  • parameters(as_matrix | as_real) and parameters(as_matrix | as_complex) for dense operator payloads
  • parameters(as_sparsematrix | as_real) and parameters(as_sparsematrix | as_complex) for sparse operator payloads
  • parameters(as_string) for Pauli strings

• Quadratic operators

  • TransferSum represents the sum $\sum_{i,j}A_{i,j}f_i^{\dagger}f_j$.
  • PairingSum represents the sum $\sum_{i<j}P_{i,j}f_i^{\dagger}f_j^{\dagger} + \sum_{i>j}P_{i,j}f_if_j$.
  • QuadraticSum represents the sum $\sum_{i,j}S_{i,j}^{+,-}f_i^{\dagger}f_j + S_{i,j}^{-,+}f_if_j^{\dagger} + S_{i,j}^{+,+}f_i^{\dagger}f_j^{\dagger} + S_{i,j}^{-,-}f_if_j$.
  • Quadratic operators implement get_bdg_matrix and get_bdg_shift to extract the Bogoliubov-De Gennes matrix and constant energy shift respectively.
  • Quadratic operators can be constructed directly from valid operator sums, avoiding the manual bookkeeping usually required to build the Bogoliubov-De Gennes matrix.

• New fermionic operators

  • The CreateCreate(i,j) operator which represents the operator $f_i^{\dagger}f_j^{\dagger}$.
  • The DestroyDestroy(i,j) operator which represents the operator $f_if_j$.

---

🐛 Fixes​

• Fixed Aleph formatter edge cases around numeric literals, complex-number suffixes and if headers.
• Fixed Aleph exception stack trace collection so exceptions thrown from Aleph code, including values passed through throw(...), retain their source locations and stack frames.
• Fixed operator_function which would throw when the right-hand-side vector was an eigenstate of the input operator.

---

⚙️ Internal / Technical Changes​

• Unified the internal implementation of spin-half operator payload inspection so the same Aleph API works consistently across parameterized operators, dense and sparse matrix operators, and Pauli-string operators.
• Added native integrated test support to the Aleph language core, including test, test_section, hooks, parameterized cases, options, expectations, test discovery, and structured test results. This is the foundation for first-class Aleph testing; Workshop integration and full user documentation are still in progress.

---

⚠️ Breaking Changes​

• Aleph polynomial and ChebyshevSeries type names have changed from generic/template-style names to explicit typed names:
  • Polynomial([ ... ]) should now be written as RealPolynomial([ ... ]) or ComplexPolynomial([ ... ])
  • ChebyshevSeries(...) should now be written as RealChebyshevSeries(...) or ComplexChebyshevSeries(...)
• Aleph operator-valued ChebyshevSeries construction now uses the typed wrapper names such as RealOperatorChebyshevSeries(...) instead of the previous generic form.
• Some polynomial and ChebyshevSeries member names have been cleaned up in Aleph:
  • get_degree() -> degree()
  • get_coeffs() -> get_coefficients()
  • polynomial composition is now exposed as compose(...) instead of overloading evaluate(...)
• Qbit and Fbit's insert(position, value) method now accepts any integral value instead of just 0 and 1. integers are converted to bool internally, so 0 is treated as false and any non-zero value is treated as true.
• Spin-half operator classes (OperatorNamed, OperatorDense, OperatorSparse, etc.) have been unified into a single class: SpinHalfOperator. The specific operator kind is now visible via the payload returned by parameters().

---

🧪 Migration Notes​

• Update any generic polynomial and ChebyshevSeries construction calls to use the typed variants that match your scalar type.
• Update any Aleph code that still calls get_degree() or get_coeffs() to use degree() and get_coefficients().
• If you were previously using polynomial-on-polynomial evaluate(...), switch those call sites to compose(...).
• If you construct operator-valued ChebyshevSeries or polynomial wrappers in Aleph, migrate to the new typed wrapper names.

🚀 Highlights​

• This patch release reduces diagnostic noise in the Aleph LSP by downgrading function-shadowing reports from warnings to hints. The information is still available in the Workshop, but it should no longer distract from actionable issues.

---

🐛 Fixes​

• Aleph LSP now reports variables shadowing functions as hints instead of warnings, reducing noise while keeping the information available in the Workshop.

---

🚀 Highlights​

• Improvements to the Figure API: additional precision and data sampling
• Better language server diagnostics for variable shadowing and redeclarations

---

✨ New Features​

• Reworked the simplify_paulis function to be more performant and memory conscious. Now the input operator is modified in-place. Performs merging and pruning if desired.
• Updated the Library Reference documentation to include base and derived types.
• Quantum operators are now easier to find in the documentation, with a dedicated Operators section.
• Improved language server diagnostics: now warns when variables redeclare names in the same scope or shadow visible variables, parameters, globals, functions, and class declarations
• Added figure-level pre-serialization sampling in the Plotting module to reduce .figure payload sizes.
  • Sampling is enabled by default with Figure.sampling(...) controls.
  • auto export warns when large series are sampled or when no automatic sampling strategy is available.
  • Removed built-in ECharts sampling from plotting option docs to avoid confusion with figure-level sampling.
• Initial support for Symbolic operator (SpinHalf) to Linear tensor networks, matrix product operator (MPO) and matrix product state (MPS).
  • SpinHalf operators can be converted to MPO with mpo(operator,length,[as_(complex|real)])
  • SpinHalf operator can be multiplied into a MPO, operator >> mpo
  • SpinHalf operator can be multiplied with MPS, inplace with operator >> mps and out of place with new_mps = operator*mps.

---

🐛 Fixes​

• Fixed CNOT operator so that the first argument is correctly the control qubit and the second is the target qubit (previously the second argument incorrectly acted as the control).
• Corrected documentation for XYZ and Floquet to align their phase signs with the implementation.
• Fixed Aleph type_name() and is_type() results for derived types stored through a base type.
• Fixed Aleph language server formatting for array and map access so expressions such as my_array[index] and map["key"] stay attached.
• Enhanced precision in plotting JSON output for integer and real values.

---

⚙️ Internal / Technical Changes​

• Improve runtime performance on call sites that create many scalar objects.

---

⚠️ Breaking Changes​

• The mps and mpo factory functions have been renamed:
  • make_random_mps → random_mps
  • make_random_mpo → random_mpo
• Fixed-number-of-sites quantum operators (XX, YY, ZZ, CNOT, SWAP, UnitaryXYZ, Floquet, DualUnitary, etc.) no longer accept lists for site indices. Explicit scalar indices must be passed instead (e.g., XX(0, 1) instead of XX([0, 1])). This guarantees consistent behavior across all operators and prevents silent errors from unintended array inputs. Note that you may still use lists with the call method as follows: XX.call([0, 1]).
• Figures output may change for existing scripts because integer and real values are now serialized with higher precision.
• In the API for Model, Term (term) has been changed to Interaction (interaction for the factory), as in model.add(interaction("J", [Z, Z], "nn")).
• In the API for Model, measure has been changed to add_observable, as in model.add_observable("name", interaction("coefficient", [Z, Z], "neighbourhood")).
• In simplify_paulis the operation is now done in-place on the pauli product rather than returning an ComplexOperatorSum. The return type is the phase of the pauli product in the case where the input is an OperatorProduct whereas for any other type the output is set to 1.0.

---

✨ New Features​

• New mathematical functions for arithmetic types: bessel_j, bessel_y, bessel_i, and bessel_k for computing Bessel functions of the first kind, second kind, modified Bessel functions of the first kind, and modified Bessel functions of the second kind, respectively.
• The Fermionic operator PairHopSum(tensor) represents a Hermitian sum of pair hopping terms: $\sum_{i,j,k,l} V_{ijkl} a_{i}^\dagger a_{j}^\dagger a_{k} a_{l}$. It differs from CoulombSum in that the pair hopping terms do not include spin indices (which introduces an additional constraint).
• Added adjointed() member function to quantum Operators to dynamically compute the Hermitian conjugate.
• Quantum Operators support .is_hermitian(), .is_unitary(), and .is_real() dynamic introspection properties.
• Expanded the library of symbolic SpinHalf operators in Aleph, adding standardized factory functions for new parameter interactions:
  • PhaseShift(angle, i): Single-qubit phase gate operator.
• Model can now be initialized from .lattice_model files by passing the path to the file to the model constructor (e.g. model("path/to/model.lattice_model")).
• the Model class now has a method to inspect labels that need to be registered model.unregistered_labels().
• The set_coefficient method can now also take an aleph function that takes a coordinate and returns a complex number.

---

🐛 Fixes​

• Fixed data service downloads and uploads for files whose paths contain spaces or other URL-special characters.
• Fixed an error in PairRotation where sparse vectors were not correctly multiplied, causing incorrect results.

---

⚠️ Breaking Changes​

• To align with the standard for CoefficientFunction, Model::set_coefficient now expects a complex number instead of a real number.

---

🚀 Highlights​

---

✨ New Features​

• Add language server support for formatting Aleph code files (beta).

• Added logarithmic binning accumulators to statistics support. These can be used to estimate auto correlation times and can be constructor by calling accumulator("logarithmic"). Includes parameters base and initial_depth to set the bin size of each level of the logarithmic accumulation and the initial depth of the levels.

• MPS and MPO arithmetic operations now support integer, real and complex scalar types.

  • In-place product and division with scalar: mps *= scalar and mps /= scalar, mpo *= scalar and mpo /= scalar.
  • Symmetric scalar multiplication: scalar * mps, scalar * mpo, mps * scalar and mpo* scalar.
  • Division by scalar: mps / scalar and mpo / scalar.
  • Tensors now support in-place element-wise scalar arithmetic operations: +=, -=, *=, /=.

• Integrated aliased discrete distribution into Aleph which offers O(1) sampling speed as opposed to O(N) from a standard discrete distribution. Can be built using random_distribution("aliased_discrete", ["probabilities" : [...]]).

• Universal operator identity and zero factories: Identity() and Zero().

• More fermionic operator transformations have been added:

  • anticommuted : anticommutes two fermionic operators $A,B$ and returns $\{ A , B \} - BA$ while respecting the canonical commutation relations of $f,f^{\dag}$. Supported for Create, Destroy, and Number operators.
  • site_canonicalized : orders a a fermionic operator into site canonical order $\prod_k (f^{\dag}_k)^{m_k} (f_k)^{n_k}$ with $m_k,n_k \in \{ 0,1 \}$.
  • canonicalize : orders a site-canonical product into complete canonical order $\prod_k f^{\dag}_{k} \prod_l f_l$.

• Added a size() method to OperatorProducts to enable easier for looping over terms.

---

🐛 Fixes​

• Fixed an error that prevented creating or writing HDF5 files in subfolders.

---

⚙️ Internal / Technical Changes​

• Aleph now uses the Xoshiro256 algorithm as the default random number generator as opposed to Mersenne Twister. Xoshiro offers generally superior performance in terms of both time and space requirements.

---

⚠️ Breaking Changes​

• Removed ID and FermiId in favor of the unified Identity() operator factory. Use Identity() for universal identity operators across all operator types.

---

✨ 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.