My qubit hamiltonian

.clang-tidy

@@ -32,6 +32,7 @@ Checks: >
   -readability-magic-numbers,
   -readability-identifier-length,
   -readability-avoid-nested-conditional-operator,
+  -readability-math-missing-parentheses,
 WarningsAsErrors: ""
 HeaderFilterRegex: ".*"
 FormatStyle: none

.clangd

@@ -0,0 +1,13 @@
+# Use the build dir's compile_commands.json (has correct include paths).
+CompilationDatabase: build
+
+# Fallback: clangd does not resolve relative paths in Add; use absolute paths.
+# Disable fmt consteval for clangd so format-string checks are runtime-only;
+# avoids false "not a constant expression" from Clang while the project builds with g++.
+CompileFlags:
+  Add:
+    - -DFMT_CONSTEVAL=
+    - -isystem
+    - /home/zwischen/qsyn/build/_deps/spdlog-src/include
+    - -isystem
+    - /home/zwischen/qsyn/build/_deps/fmt-src/include

.env.default

@@ -0,0 +1 @@
+IBMQ_API_KEY=

.github/workflows/clang-test-macos.yml

@@ -13,12 +13,13 @@ jobs:
     steps:
       - name: Check out Git repository
         uses: actions/checkout@v3
-      - name: Download llvm-clang, parallel and coreutils
+      - name: Download llvm-clang, parallel, coreutils and OpenBLAS
         run: |
-          brew install llvm@18 parallel coreutils
+          brew install llvm@18 parallel coreutils openblas
           echo 'export PATH="$(brew --prefix)/opt/llvm@18/bin:$PATH"' >> /Users/runner/.bash_profile
-          echo 'export LDFLAGS="-L$(brew --prefix)/opt/llvm@18/lib"' >> /Users/runner/.bash_profile
-          echo 'export CPPFLAGS="-I$(brew --prefix)/opt/llvm@18/include"' >> /Users/runner/.bash_profile
+          echo 'export LDFLAGS="-L$(brew --prefix)/opt/llvm@18/lib -L$(brew --prefix)/opt/openblas/lib $LDFLAGS"' >> /Users/runner/.bash_profile
+          echo 'export CPPFLAGS="-I$(brew --prefix)/opt/llvm@18/include -I$(brew --prefix)/opt/openblas/include $CPPFLAGS"' >> /Users/runner/.bash_profile
+          echo 'export CMAKE_PREFIX_PATH="$(brew --prefix)/opt/openblas:$CMAKE_PREFIX_PATH"' >> /Users/runner/.bash_profile
 
       - name: Build and test qsyn
         run: |

.gitignore

@@ -4,6 +4,7 @@ debug/
 qsyn*
 !src/qsyn*
 !src/qsyn/qsyn*
+!src/device/qsyn_device_file.cpp
 
 # for work-in-progress things
 wip/
@@ -26,3 +27,8 @@ docs/doc-coverage.info
 
 perf.data
 perf.data.old
+
+# python environment
+.venv/
+.env
+__pycache__/

CMakeLists.txt

@@ -12,6 +12,13 @@ set(CMAKE_CXX_FLAGS "")
 set(CMAKE_CXX_FLAGS_DEBUG "-g")
 set(CMAKE_CXX_FLAGS_RELEASE "-O3")
 
+# Set BLA_VENDOR before project() so it's available during initialization
+# On macOS, we need to specify OpenBLAS explicitly
+# On Linux, we'll use pkg-config instead (see find_package(BLAS) below)
+if(NOT CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    set(BLA_VENDOR OpenBLAS CACHE STRING "BLAS vendor to search for")
+endif()
+
 include(FetchContent)
 include(CheckCXXCompilerFlag)
 set(FETCHCONTENT_UPDATES_DISCONNECTED TRUE)
@@ -84,9 +91,34 @@ include(scripts/cmake/target_link_libraries_system.cmake)
 
 # find_package(OpenMP REQUIRED)
 
-set(BLA_VENDER OpenBLAS)
-find_package(BLAS REQUIRED)
-find_package(LAPACK REQUIRED)
+# Use pkg-config to find BLAS and LAPACK on Linux where it's available and reliable
+# On macOS, OpenBLAS from Homebrew doesn't provide pkg-config files, so use FindBLAS instead
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    find_package(PkgConfig)
+    if(PKG_CONFIG_FOUND)
+        pkg_check_modules(BLAS IMPORTED_TARGET blas)
+        pkg_check_modules(LAPACK IMPORTED_TARGET lapack)
+        if(BLAS_FOUND AND LAPACK_FOUND)
+            # Set variables expected by the rest of the build
+            set(BLAS_LIBRARIES PkgConfig::BLAS)
+            set(LAPACK_LIBRARIES PkgConfig::LAPACK)
+        endif()
+    endif()
+endif()
+
+# If pkg-config didn't find BLAS/LAPACK (or we're not on Linux), use CMake's find_package
+if(NOT BLAS_FOUND OR NOT LAPACK_FOUND)
+    find_package(BLAS REQUIRED)
+    find_package(LAPACK REQUIRED)
+endif()
+
+# Ensure BLAS_LIBRARIES and LAPACK_LIBRARIES are set
+if(NOT BLAS_LIBRARIES)
+    set(BLAS_LIBRARIES ${BLAS_openblas_LIBRARY})
+endif()
+if(NOT LAPACK_LIBRARIES)
+    set(LAPACK_LIBRARIES ${LAPACK_openblas_LIBRARY})
+endif()
 
 FetchContent_Declare(
     xtl
@@ -109,26 +141,6 @@ FetchContent_Declare(
     GIT_TAG 0.22.0)
 FetchContent_MakeAvailable(xtensor-blas)
 
-# --- libfort (patched for new CMake) ---
-FetchContent_Declare(
-    libfort
-    SYSTEM
-    GIT_REPOSITORY https://github.com/seleznevae/libfort.git
-    GIT_TAG v0.4.2
-    GIT_SHALLOW ON
-)
-
-# turn off libfort's own tests
-set(FORT_ENABLE_TESTING OFF CACHE INTERNAL "")
-
-FetchContent_GetProperties(libfort)
-if(NOT libfort_POPULATED)
-  FetchContent_Populate(libfort)
-endif()
-# Always bump (even if already populated from a previous configure)
-qsyn_bump_min_cmake("${libfort_SOURCE_DIR}" 3.10)
-add_subdirectory("${libfort_SOURCE_DIR}" "${libfort_BINARY_DIR}" SYSTEM)
-
 FetchContent_Declare(
     fmt
     SYSTEM
@@ -185,6 +197,7 @@ FetchContent_Declare(
 FetchContent_MakeAvailable(cadical)
 
 # --- libabc (patched for new CMake) ---
+set(READLINE_FOUND FALSE CACHE BOOL "Disable readline in libabc")
 FetchContent_Declare(
   libabc
   SYSTEM
@@ -265,7 +278,6 @@ target_link_libraries_system(
     xtl
     xtensor
     xtensor-blas
-    libfort::fort
     fmt::fmt
     spdlog::spdlog
     Microsoft.GSL::GSL
@@ -275,7 +287,6 @@ target_link_libraries_system(
 target_link_libraries(
     ${QSYN_LIB_NAME} 
     PRIVATE 
-    lapack 
 # OpenMP::OpenMP_CXX 
     ${BLAS_LIBRARIES}
     ${LAPACK_LIBRARIES})
@@ -302,6 +313,13 @@ target_compile_options(
 target_compile_options(
     ${CMAKE_PROJECT_NAME} PRIVATE -Wno-missing-field-initializers)
 
+# GCC-specific: disable -Wmaybe-uninitialized (has false positives with templates)
+check_cxx_compiler_flag(-Wno-maybe-uninitialized COMPILER_SUPPORTS_WNO_MAYBE_UNINITIALIZED)
+if(COMPILER_SUPPORTS_WNO_MAYBE_UNINITIALIZED)
+    target_compile_options(
+        ${CMAKE_PROJECT_NAME} PRIVATE -Wno-maybe-uninitialized)
+endif()
+
 # GCC 12+ is too strict about restrict warnings in std::string operations
 # Only apply to GCC, as Clang doesn't support this flag
 check_cxx_compiler_flag(-Wno-restrict COMPILER_SUPPORTS_WNO_RESTRICT)
@@ -327,15 +345,14 @@ target_link_libraries_system(
     xtl
     xtensor
     xtensor-blas
-    libfort::fort
     fmt::fmt
     spdlog::spdlog
     Microsoft.GSL::GSL
-    sul::dynamic_bitset)
+    sul::dynamic_bitset
+    nlohmann_json::nlohmann_json)
 target_link_libraries(
     ${CMAKE_PROJECT_NAME} 
     PRIVATE 
-    lapack 
 # OpenMP::OpenMP_CXX 
     ${BLAS_LIBRARIES} 
     ${LAPACK_LIBRARIES})
@@ -368,7 +385,8 @@ target_link_libraries_system(
     PRIVATE
     fmt::fmt
     spdlog::spdlog
-    Microsoft.GSL::GSL)
+    Microsoft.GSL::GSL
+    sul::dynamic_bitset)
 
 target_compile_options(
     ${UNIT_TEST_NAME}
@@ -381,6 +399,14 @@ target_compile_options(
     PRIVATE 
     -Wno-missing-field-initializers)
 
+# GCC-specific: disable -Wmaybe-uninitialized (has false positives with templates)
+if(COMPILER_SUPPORTS_WNO_MAYBE_UNINITIALIZED)
+    target_compile_options(
+        ${UNIT_TEST_NAME}
+        PRIVATE 
+        -Wno-maybe-uninitialized)
+endif()
+
 # GCC 12+ is too strict about restrict warnings in std::string operations
 # Only apply to GCC, as Clang doesn't support this flag
 if(COMPILER_SUPPORTS_WNO_RESTRICT)

Makefile

@@ -93,7 +93,11 @@ test-update:
 
 # run clang-format and clang-tidy on the source code
 lint:
-	./scripts/LINT
+	@if [ -z "$(ARGS)" ]; then \
+		./scripts/LINT; \
+	else \
+		./scripts/LINT $(ARGS); \
+	fi
 .PHONY: lint
 
 clean:

benchmark/fham/convert_fermihedral.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+"""
+Convert fermihedral model files to qsyn fermionic Hamiltonian (.fham) format.
+
+Mapping rules:
+- Input directory (default): ~/fermihedral/model
+- Output directory (default): benchmark/fham
+- Each non-empty, non-comment line in a fermihedral file is a single term.
+- A term is a list of signed integers, e.g.:
+
+    -1 2
+
+    Interpretation:
+    - Sign encodes operator type:
+      k < 0  → creation operator a_{|k|}^†
+      k > 0  → annihilation operator a_{|k|}
+  - Indices are the same in both formats (no off-by-one).
+  - Coefficient is defaulted to (1, 0) (i.e. 1 + 0j) for every term.
+
+Example:
+    fermihedral:  -1 2
+    qsyn (.fham): (1, 0) 0^ 1
+"""
+
+from __future__ import annotations
+
+import argparse
+import pathlib
+from typing import Iterable
+
+
+def parse_line_to_ops(line: str) -> list[tuple[int, bool]]:
+    """Parse a single fermihedral term line into (mode, is_creation) ops.
+
+    - Skips comments after '#'.
+    - Returns an empty list if there are no operator tokens.
+    """
+    # Strip comments
+    line = line.split("#", maxsplit=1)[0].strip()
+    if not line:
+        return []
+
+    tokens = line.split()
+    ops: list[tuple[int, bool]] = []
+    for tok in tokens:
+        try:
+            k = int(tok)
+        except ValueError:
+            raise ValueError(f"Invalid integer token '{tok}' in line: {line!r}")
+
+        is_creation = k < 0
+        mode = abs(k)  # no index shift; 0 is allowed
+
+        ops.append((mode, is_creation))
+    return ops
+
+
+def convert_file(src_path: pathlib.Path, dst_path: pathlib.Path) -> None:
+    """Convert one fermihedral model file to qsyn .fham format."""
+    lines: list[str] = src_path.read_text(encoding="utf-8").splitlines()
+
+    # Some fermihedral model files encode Majorana operators using an "mj"
+    # token on the first line. We currently do not support Majorana terms, so
+    # skip converting such files but emit a clear warning.
+    if lines:
+        first_tokens = lines[0].split()
+        if any(tok == "mj" for tok in first_tokens):
+            print(
+                f"Warning: skipping {src_path} because it uses Majorana operators "
+                "(mj), which are not supported yet."
+            )
+            return
+
+    out_lines: list[str] = []
+
+    # Many fermihedral model files start with a non-operator header line
+    # (e.g., "electronic 10 ac"). We skip the first line unconditionally.
+    for idx, line in enumerate(lines):
+        if idx == 0:
+            continue
+        stripped = line.strip()
+        # Preserve blank and comment-only lines for readability
+        if not stripped or stripped.startswith("#"):
+            out_lines.append(stripped)
+            continue
+
+        try:
+            ops = parse_line_to_ops(line)
+        except ValueError as e:
+            raise ValueError(f"Error in file {src_path}, line {line!r}: {e}") from e
+
+        if not ops:
+            # No operators after stripping comments; skip the line
+            continue
+
+        # Default coefficient (1, 0) as requested
+        pieces: list[str] = ["(1, 0)"]
+        for mode, is_creation in ops:
+            pieces.append(f"{mode}{'^' if is_creation else ''}")
+
+        out_lines.append(" ".join(pieces))
+
+    dst_path.parent.mkdir(parents=True, exist_ok=True)
+    dst_path.write_text("\n".join(out_lines) + "\n", encoding="utf-8")
+
+
+def iter_model_files(src_dir: pathlib.Path) -> Iterable[pathlib.Path]:
+    """Yield all regular files under src_dir (non-recursive)."""
+    if not src_dir.exists():
+        raise FileNotFoundError(f"Source directory does not exist: {src_dir}")
+    for p in sorted(src_dir.iterdir()):
+        if p.is_file():
+            yield p
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Convert fermihedral model files to qsyn .fham format."
+    )
+    parser.add_argument(
+        "--src",
+        type=pathlib.Path,
+        default=pathlib.Path("~").expanduser() / "fermihedral" / "model",
+        help="Source directory containing fermihedral model files "
+        "(default: ~/fermihedral/model)",
+    )
+    parser.add_argument(
+        "--dst",
+        type=pathlib.Path,
+        default=pathlib.Path("benchmark") / "fham",
+        help="Destination directory for converted .fham files "
+        "(default: benchmark/fham)",
+    )
+    parser.add_argument(
+        "--suffix",
+        type=str,
+        default=".fham",
+        help="Suffix to append to converted filenames (default: .fham)",
+    )
+
+    args = parser.parse_args()
+
+    src_dir: pathlib.Path = args.src
+    dst_dir: pathlib.Path = args.dst
+    suffix: str = args.suffix
+
+    for src_file in iter_model_files(src_dir):
+        dst_name = src_file.name + suffix if not src_file.name.endswith(suffix) else src_file.name
+        dst_path = dst_dir / dst_name
+        convert_file(src_file, dst_path)
+        print(f"Converted {src_file} -> {dst_path}")
+
+
+if __name__ == "__main__":
+    main()
+