Skip to content

Latest commit

 

History

History
380 lines (301 loc) · 9.69 KB

INSTALLATION.md

File metadata and controls

380 lines (301 loc) · 9.69 KB

Installation Guide (Pre-release)

Note: This is a pre-release version. The library is currently under active development and does not yet fully compile. This guide describes the intended installation process once the library is complete.

Development Status

  • Core algorithms and architecture: ✅ Complete
  • Documentation: ✅ Complete
  • Compilation: 🚧 In Progress
  • Hardware integration: 🚧 In Progress
  • Testing Framework: 🚧 In Progress

System Requirements

Hardware Requirements

  • CPU: x86_64 or ARM64 processor with AVX2 support
  • Memory: Minimum 16GB RAM (32GB recommended)
  • GPU (optional but recommended):
    • Apple Silicon: M1/M2 with unified memory
    • NVIDIA: CUDA-capable GPU with compute capability 7.0+
  • Storage: 2GB free space (10GB with all examples and tests)

Quantum Hardware Access

  1. IBM Quantum

    • IBM Quantum Account (free tier available)
    • Access to IBM Quantum systems:
      • IBM Eagle (127 qubits)
      • IBM Osprey (433 qubits)
      • IBM Condor (1121 qubits)
  2. Rigetti

    • Rigetti Quantum Cloud Services account
    • Access to Aspen-M/Ankaa processors
    • QCS authentication token
  3. D-Wave

    • D-Wave Leap account
    • Access to Advantage/Advantage2 systems
    • Leap authentication token

Software Requirements

  • Operating System:
    • macOS 12.0+ (for Metal support)
    • Linux with kernel 4.19+ (for CUDA support)
  • Compiler:
    • Clang 13.0+ or GCC 9.0+
    • CUDA Toolkit 11.0+ (for NVIDIA GPUs)
  • Build System:
    • CMake 3.15+
    • Ninja or Make
  • Dependencies:
    • MPI implementation (OpenMPI 4.0+ or MPICH 3.3+)
    • BLAS/LAPACK implementation
    • hwloc 2.0+ (for topology detection)
    • libnuma (for NUMA support)
    • jansson (for JSON parsing)
  • Distributed Training:
    • High-speed network interconnect
    • Shared filesystem for checkpoints
    • RDMA support recommended

Installation Steps

1. Quantum Hardware Setup (In Development)

The following quantum hardware integrations are currently under development:

IBM Quantum Integration (In Progress)

# Note: Hardware integration is not yet complete
# This shows the planned configuration process

# Install IBM Quantum tools
pip install qiskit

# Configure IBM credentials (structure may change)
mkdir -p ~/.quantum_geometric/ibm
cat > ~/.quantum_geometric/ibm/credentials.json << EOL
{
    "api_token": "YOUR_IBM_API_TOKEN",
    "hub": "ibm-q",
    "group": "open",
    "project": "main"
}
EOL

Rigetti Integration (Planned)

# Note: Hardware integration is not yet complete
# This shows the planned configuration process

# Install Rigetti tools
pip install pyquil

# Configure Rigetti credentials (structure may change)
mkdir -p ~/.quantum_geometric/rigetti
cat > ~/.quantum_geometric/rigetti/credentials.json << EOL
{
    "api_key": "YOUR_RIGETTI_API_KEY",
    "qvm_url": "tcp://127.0.0.1:5000",
    "quilc_url": "tcp://127.0.0.1:5555"
}
EOL

D-Wave Integration (Planned)

# Note: Hardware integration is not yet complete
# This shows the planned configuration process

# Install D-Wave tools
pip install dwave-ocean-sdk

# Configure D-Wave credentials (structure may change)
mkdir -p ~/.quantum_geometric/dwave
cat > ~/.quantum_geometric/dwave/credentials.json << EOL
{
    "token": "YOUR_DWAVE_TOKEN",
    "solver": "Advantage_system4.1",
    "region": "na-west-1"
}
EOL

2. Install Dependencies

macOS (using Homebrew)

# Install basic dependencies
brew install cmake ninja

# Install MPI and numerical libraries
brew install open-mpi openblas lapack

# Install system libraries
brew install hwloc jansson

# Install optional dependencies
brew install cuda  # Only if using NVIDIA GPU

Linux (Ubuntu/Debian)

# Install basic dependencies
sudo apt-get update
sudo apt-get install build-essential cmake ninja-build

# Install MPI and numerical libraries
sudo apt-get install libopenmpi-dev libopenblas-dev liblapack-dev

# Install system libraries
sudo apt-get install libhwloc-dev libnuma-dev libjansson-dev

# Install CUDA (if using NVIDIA GPU)
wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/cuda-keyring_1.0-1_all.deb
sudo dpkg -i cuda-keyring_1.0-1_all.deb
sudo apt-get update
sudo apt-get install cuda-toolkit

3. Configure Build (Pre-release)

# Note: Build system is under development
# These are the planned build options

mkdir build && cd build

# Configure with quantum hardware support
# Note: Not all options are currently functional
cmake .. \
    -GNinja \
    -DCMAKE_BUILD_TYPE=Release \
    -DQGT_USE_MPI=ON \
    -DQGT_USE_OPENMP=ON \
    -DQGT_USE_METAL=ON \        # For Apple Silicon (in development)
    -DQGT_USE_CUDA=ON \         # For NVIDIA GPUs (in development)
    -DQGT_USE_IBM=ON \          # IBM Quantum (planned)
    -DQGT_USE_RIGETTI=ON \      # Rigetti (planned)
    -DQGT_USE_DWAVE=ON \        # D-Wave (planned)
    -DQGT_USE_DISTRIBUTED=ON    # Distributed training (in development)

4. Build and Install (Pre-release)

# Note: Full compilation is not yet supported
# These are the planned build steps

# Build core components (partial functionality)
ninja

# Run available tests
ninja test

# Installation not yet supported
# sudo ninja install

Configuration

1. Quantum Hardware Configuration

Create /etc/quantum_geometric/quantum_config.json:

{
  "quantum": {
    "default_backend": "ibm",
    "error_mitigation": true,
    "topology_aware": true,
    "geometric_optimization": true
  },
  "hardware": {
    "ibm": {
      "preferred_systems": ["ibm_manhattan", "ibm_brooklyn"],
      "max_jobs": 5,
      "optimization_level": 3
    },
    "rigetti": {
      "preferred_systems": ["Aspen-M-3"],
      "compiler_timeout": 60,
      "max_trials": 100
    },
    "dwave": {
      "preferred_solvers": ["Advantage_system4.1"],
      "annealing_time": 20,
      "num_reads": 1000
    }
  }
}

2. Environment Setup

Add to your shell configuration (~/.bashrc, ~/.zshrc):

# Library path
export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH

# Quantum configuration
export QGT_QUANTUM_CONFIG=/etc/quantum_geometric/quantum_config.json
export QGT_QUANTUM_CREDENTIALS=~/.quantum_geometric

# MPI configuration
export OMPI_MCA_btl_vader_single_copy_mechanism=none
export OMPI_MCA_btl_tcp_if_include=eth0
export OMPI_MCA_oob_tcp_if_include=eth0

# GPU configuration
export QGT_GPU_MEMORY_FRACTION=0.75

# Distributed training
export QGT_DISTRIBUTED_CONFIG=/etc/quantum_geometric/distributed_config.json
export QGT_CHECKPOINT_DIR=/tmp/quantum_geometric/checkpoints

3. System Optimization

NUMA Settings

# Enable NUMA balancing
sudo sysctl -w kernel.numa_balancing=1

# Configure huge pages
HUGE_PAGES=$((4 * 1024 * 1024 * 1024 / 2048 / 1024))
sudo sysctl -w vm.nr_hugepages=$HUGE_PAGES

Verification (Pre-release)

1. System Check (Limited Functionality)

# Note: Most verification tools are under development
# These commands show the planned verification process

# Basic system checks (partial functionality)
quantum_geometric-diagnose

# Hardware backend tests (not yet available)
# quantum_geometric-test-backend all

# GPU support verification (in development)
# quantum_geometric-test-gpu

# Distributed setup (planned)
# sudo ./tools/setup_distributed_env.sh
# mpirun -np 4 quantum_geometric-test-distributed

2. Quantum Hardware Test (In Development)

# Note: Hardware integration is not yet complete
# These are the planned test procedures

# Run available quantum tests
cd tests/quantum
./test_quantum_hardware.sh

# Current test status:
# [🚧] IBM Quantum connection - In development
# [🚧] Rigetti QCS connection - In development
# [🚧] D-Wave connection - In development
# [🚧] Quantum circuit execution - In development
# [🚧] Error mitigation - In development
# [🚧] Geometric optimization - In development

3. Performance Verification (In Development)

# Note: Performance benchmarks are not yet available
# These are the target performance metrics

# Run available benchmarks
cd benchmarks
./run_benchmarks.sh --quantum

# Target metrics:
# Quantum Hardware Performance:
# - Circuit optimization: 95% efficiency (In development)
# - Error mitigation: 85% reduction (In development)
# - Geometric advantage: 70% speedup (In development)
# - Resource utilization: 90% optimal (In development)

Development Troubleshooting

Current Limitations

  1. Compilation Issues
# Common compilation errors:
# - Hardware integration modules not yet complete
# - Some dependencies may be missing or incompatible
# - Test suite may fail due to incomplete features

# For development assistance:
# - Check GitHub issues for known problems
# - Join the developer mailing list
# - Review the development roadmap
  1. Hardware Integration
# Note: Hardware backends are not yet functional
# Development status:
# - IBM Quantum: Integration in progress
# - Rigetti: Planning phase
# - D-Wave: Planning phase
  1. Performance Optimization
# Performance monitoring tools are under development
# Current focus areas:
# - Core algorithm optimization
# - Memory management
# - Hardware acceleration

References

  1. Quantum Hardware Documentation

  2. System Configuration

  3. Performance Optimization