From d99e13816d164e024481800657e822c4dd219304 Mon Sep 17 00:00:00 2001 From: tjkessler Date: Wed, 5 Aug 2026 13:11:57 -0400 Subject: [PATCH 1/2] Release KoopmanGraph 0.12.0 Ship Kronecker-sum exact spectrum for eligible graph operators, Scale and topology-criticality honesty docs, and release metadata for the 0.12.0 tag. Co-authored-by: Cursor --- CHANGELOG.md | 41 + CITATION.cff | 4 +- README.md | 10 +- docs/source/architecture.rst | 53 +- docs/source/capabilities.rst | 20 +- docs/source/faq.rst | 36 +- docs/source/installation.rst | 4 +- docs/source/limitations.rst | 80 +- ...8_networked_koopman_dynamic_topology.ipynb | 1886 +++++++++-------- examples/29_large_graph_block_diagonal.ipynb | 1817 ++++++++-------- paper.bib | 14 + src/koopman_graph/__init__.py | 2 +- src/koopman_graph/operators/__init__.py | 10 + .../operators/continuous_graph.py | 41 +- src/koopman_graph/operators/graph.py | 50 +- .../operators/kronecker_spectrum.py | 545 +++++ tests/test_continuous_graph.py | 236 ++- tests/test_graph_operator.py | 253 +++ tests/test_kronecker_spectrum.py | 440 ++++ 19 files changed, 3724 insertions(+), 1818 deletions(-) create mode 100644 src/koopman_graph/operators/kronecker_spectrum.py create mode 100644 tests/test_kronecker_spectrum.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 65e8a96..bb18f17 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,47 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## [Unreleased] +## [0.12.0] - 2026-08-05 + +Scale-and-honesty release on the 0.11 stack: Kronecker-sum exact spectrum +for eligible networked graph operators, and docs-only topology-criticality +honesty. Homogeneous scientific defaults and the linear latent operator +contract are unchanged. + +### Added + +- Exact Kronecker-sum spectrum path for eligible discrete and continuous + graph operators (`koopman_graph.operators.kronecker_spectrum`; + `GraphKoopmanOperator.spectrum` / + `ContinuousGraphKoopmanOperator.spectrum`). Eligibility requires a + shared self factor, `diffusion` in `{"symmetric", "random_walk"}`, and + `sparsity` in `{"dense", "block_diagonal"}`. Eigenvalues and ambient + eigenvectors match the dense assembly oracle within float tolerance on + path/ring fixtures. +- Three-path spectrum contract: distributed leading-modulus Arnoldi + (discrete / multiplex hetero), Kronecker-sum exact reduction when + eligible, otherwise dense assembly. Continuous `distributed` has no + Arnoldi spectrum path and uses dense `L_eff`. +- Sphinx Scale / architecture / FAQ prose distinguishing the three + spectrum paths and residual dense ceilings for exact inverse, Jacobi / + Richardson, and eig-regularization hinges. Tutorial + `examples/29_large_graph_block_diagonal.ipynb` records a dense vs + Kronecker spectrum timing probe at the existing probe \(N\). +- Topology-criticality honesty in limitations (cross-linked from + architecture / capabilities), with `paper.bib` entry `Ghosh2025`. + Tutorial `examples/18_networked_koopman_dynamic_topology.ipynb` notes + that dynamic topology remains mechanical (no spectral-degeneracy / + early-warning diagnostic API). + +### Notes + +- Kronecker reduction applies to **spectrum only**. Exact inverse / + Jacobi / Richardson and eig-regularization hinges remain dense + \((N\cdot d)\) ceilings. +- No Kronecker-style spectrum for hetero / hypergraph ambient operators + in this release. +- Homogeneous training defaults are unchanged relative to 0.11.0. + ## [0.11.0] - 2026-08-02 Domain-and-structure release on the 0.10 stack: measured topology transfer, diff --git a/CITATION.cff b/CITATION.cff index 400e6a9..607ff59 100644 --- a/CITATION.cff +++ b/CITATION.cff @@ -13,8 +13,8 @@ authors: repository-code: "https://github.com/tjkessler/KoopmanGraph" url: "https://koopmangraph.readthedocs.io/" license: Apache-2.0 -version: 0.11.0 -date-released: 2026-08-02 +version: 0.12.0 +date-released: 2026-08-05 doi: 10.5281/zenodo.21763908 identifiers: - type: doi diff --git a/README.md b/README.md index 20b90a3..e0587f2 100644 --- a/README.md +++ b/README.md @@ -136,10 +136,10 @@ Featured tutorials: [01 synthetic](https://github.com/tjkessler/KoopmanGraph/blo - [Architecture](https://koopmangraph.readthedocs.io/en/latest/architecture.html) — public vs power-user API layers - [FAQ / troubleshooting](https://koopmangraph.readthedocs.io/en/latest/faq.html) — install, imports, checkpoints - [Installation](https://koopmangraph.readthedocs.io/en/latest/installation.html) — dependencies and install paths -- What’s new in 0.11.0: measured topology transfer, directed hypergraph - incidence, Ray Train model DDP, presence-mask churn, teaching traffic / - GraphCast ports, sheaf / cell-complex MVPs, GraphVAMP + synthetic molecular - path, and isotypic self-block ties — see [CHANGELOG.md](CHANGELOG.md). +- What’s new in 0.12.0: Kronecker-sum exact spectrum for eligible discrete + and continuous graph operators (three-path spectrum contract), Scale / + architecture honesty for residual dense inverse and eig-reg ceilings, and + docs-only topology-criticality honesty — see [CHANGELOG.md](CHANGELOG.md). ## Related software @@ -164,7 +164,7 @@ If you use KoopmanGraph in research, please cite: publisher = {Zenodo}, doi = {10.5281/zenodo.21763908}, url = {https://github.com/tjkessler/KoopmanGraph}, - version = {0.11.0}, + version = {0.12.0}, } ``` diff --git a/docs/source/architecture.rst b/docs/source/architecture.rst index f9b0e7c..f74b9c9 100644 --- a/docs/source/architecture.rst +++ b/docs/source/architecture.rst @@ -401,13 +401,17 @@ power-user losses stay package imports outside root ``__all__``. * ``graph_inverse`` — block-diagonal / Jacobi approximate inverse helpers for ``GraphKoopmanOperator`` / ``HypergraphKoopmanOperator`` with ``sparsity="block_diagonal"`` (no ``operators/graph/`` subtree) +* ``kronecker_spectrum`` — exact Kronecker-sum spectrum helpers for eligible + discrete / continuous graph operators (power-user; not in package + ``__all__``; auto-routed from ``.spectrum`` — see spectrum routing below) * ``continuous_graph`` — :class:`~koopman_graph.operators.continuous_graph.ContinuousGraphKoopmanOperator` (continuous networked generator ``I⊗L_self + Â⊗L_nbr``; select via ``koopman="graph"`` + ``dynamics_mode="continuous"`` or ``koopman="continuous_graph"``). Dense advance uses an ``N·d`` matrix exponential; ``sparsity="block_diagonal"`` is the self-dominated - approximate path + approximate path. ``.spectrum`` may Kronecker-route when eligible (see + spectrum routing below); that does not shrink the matrix-exp ceiling * ``hypergraph`` — :class:`~koopman_graph.operators.hypergraph.HypergraphKoopmanOperator` (discrete hyperedge-coupled advance; select via ``koopman="hypergraph"``; @@ -1140,7 +1144,10 @@ Topology capability matrix Dynamic topology is first-class in the data container and neural model path, but not every consumer supports it. Callers must not assume silent freeze/flatten -behavior. Optional static hyperedge incidence (``hyperedge_index`` / +behavior. Mid-horizon rewiring is **mechanical** support for changing +``edge_index`` schedules; it is not criticality-aware forecasting or +spectral-degeneracy analysis (see :ref:`limitations-topology-criticality`). +Optional static hyperedge incidence (``hyperedge_index`` / ``hyperedge_weight`` on each ``Data`` snapshot; PyG bipartite format) is accepted by :class:`~koopman_graph.data.GraphSnapshotSequence`. Hypergraph encoder/decoder peers and ``koopman="hypergraph"`` consume the incidence; @@ -1300,8 +1307,9 @@ spectral analysis uses the explicit helpers ``effective_matrix`` / ``dual_random_walk``); advance applies ``exp(L_eff Δt)``. Dense realization forms an ``N·d`` matrix exponential (prefer modest ``N`` or ``sparsity="block_diagonal"`` for the self-dominated approximation, which - ignores neighbor coupling). Checkpoint kind is always ``continuous_graph`` - (including when selected via ``koopman="graph"`` + + ignores neighbor coupling). ``.spectrum`` follows the graph / + continuous-graph spectrum routing below. Checkpoint kind is always + ``continuous_graph`` (including when selected via ``koopman="graph"`` + ``dynamics_mode="continuous"``). * Hypergraph — assemble ``I_N ⊗ K_self + Ĥ ⊗ K_hedge`` on a supplied ``hyperedge_index`` / ``hyperedge_weight`` (Zhou ``Ĥ`` semantics as advance). @@ -1342,8 +1350,9 @@ always the sparse message-passing matvec (pairwise ``Â`` or Zhou ``Ĥ``). - Notes * - ``"dense"`` (default) - Exact dense ``N·d`` inverse (pseudoinverse fallback) - - Suitable for modest ``N``; ``effective_matrix`` / ``spectrum`` still - assemble the dense map + - Suitable for modest ``N``; ``effective_matrix`` still assembles the + dense map. Graph / continuous-graph ``.spectrum`` may Kronecker-route + when eligible (see below) * - ``"block_diagonal"`` - Approximate per-node ``d×d`` Jacobi inverse (exact when the coupling factor is zero or the topology is empty — @@ -1352,18 +1361,46 @@ always the sparse message-passing matvec (pairwise ``Â`` or Zhou ``Ĥ``). - For backward-consistency / imputation at scale; **not** an exact whole-network inverse. ``inverse_matrix=`` is rejected. Shared by :class:`~koopman_graph.operators.GraphKoopmanOperator` and - :class:`~koopman_graph.operators.HypergraphKoopmanOperator` + :class:`~koopman_graph.operators.HypergraphKoopmanOperator`. + Eligible graph / continuous-graph ``.spectrum`` may still use + Kronecker reduction of the full coupled factors * - ``"distributed"`` - Matrix-free Richardson inverse and Arnoldi leading-modulus spectrum (discrete graph / multiplex hetero); forward stays the sparse matvec. Hypergraph / continuous peers may still assemble + for inverse; continuous spectrum has no Arnoldi path - Operator math only — **not** trainer DDP / - ``[distributed]`` extras + ``[distributed]`` extras and **not** Kronecker exact spectrum The stored checkpoint field is ``config.sparsity`` (format 1). Continuous-graph ``block_diagonal`` remains the self-dominated advance / inverse shortcut documented under that peer (not the Jacobi path above). +**Graph / continuous-graph spectrum routing.** Discrete +:meth:`~koopman_graph.operators.graph.GraphKoopmanOperator.spectrum` and +continuous +:meth:`~koopman_graph.operators.continuous_graph.ContinuousGraphKoopmanOperator.spectrum` +auto-route (no path-selection kwarg): + +1. ``sparsity="distributed"`` — discrete graph / multiplex hetero use + matrix-free Arnoldi leading-modulus Ritz values; continuous graph falls + through to dense :math:`L_{\mathrm{eff}}` eigendecomposition (no Arnoldi + spectrum path). +2. Else if Kronecker-sum eligible — shared self factor, + ``adjacency`` in ``{"symmetric", "random_walk"}``, + ``sparsity`` in ``{"dense", "block_diagonal"}`` — exact reduction via + :mod:`koopman_graph.operators.kronecker_spectrum` + (:math:`I\otimes M_{\mathrm{self}} + \widehat{A}\otimes M_{\mathrm{nbr}}` + for discrete :math:`K` or continuous generator :math:`L`). +3. Else — dense assembled eigendecomposition + (``dual_random_walk``, discrete orbit / isotypic self banks, helper + fall-back, hetero / hypergraph as applicable). + +This routing covers **spectrum only**. Exact inverse, continuous +:math:`\Phi=\exp(\Delta t\, L_{\mathrm{eff}})`, and eigenvalue-regularization +hinges keep their dense :math:`(N\cdot d)` ceilings where documented. +Ceilings and eligibility details: :doc:`limitations` (Scale). + **Graph / continuous-graph adjacency (``adjacency``).** Neighbor-coupling normalization for pairwise networked operators: diff --git a/docs/source/capabilities.rst b/docs/source/capabilities.rst index 4bc7873..c9fd568 100644 --- a/docs/source/capabilities.rst +++ b/docs/source/capabilities.rst @@ -65,7 +65,9 @@ Topology-aware learning * ``DelayEmbeddingEncoder`` / ``n_delays`` for Hankel-style partial observability * Per-snapshot ``edge_index`` (dynamic topology) and end-to-end - ``edge_weight`` support + ``edge_weight`` support — mechanical rewiring only; not + criticality / spectral-degeneracy analysis (see + :ref:`limitations-topology-criticality`) * Opt-in fixed-union node churn: ``allow_node_churn=True`` with :math:`N_{\max}` capacity and ``presence_masks`` ``(T, N_{\max})`` (losses ignore inactive nodes; matvecs stay at capacity — see @@ -91,7 +93,10 @@ Dynamics :math:`I_N \otimes K_{\mathrm{self}} + \widehat{A} \otimes K_{\mathrm{nbr}}` (factorized blocks inspired by compositional / networked Koopman constructions; cross-topology transfer is measured, not assumed — see - :doc:`limitations` and ``examples/37_cross_topology_transfer.ipynb``) + :doc:`limitations` and ``examples/37_cross_topology_transfer.ipynb``). + ``.spectrum`` auto-routes Kronecker-sum reduction when eligible (shared + self; ``symmetric`` / ``random_walk``); see :doc:`limitations` (Scale) + for distributed Arnoldi, dense fall-backs, and inverse ceilings * Pairwise ``adjacency`` modes on graph / continuous-graph operators: ``"symmetric"`` (default), ``"random_walk"`` (:math:`D_{\mathrm{out}}^{-1}A`), and ``"dual_random_walk"`` (forward plus @@ -117,8 +122,11 @@ Dynamics * Continuous networked generator ``ContinuousGraphKoopmanOperator`` (``koopman="graph"`` + ``dynamics_mode="continuous"`` or ``koopman="continuous_graph"``; ``adjacency`` modes match discrete - ``GraphKoopmanOperator``; dense ``N·d`` matrix-exp cost caveat — - prefer modest ``N`` or ``sparsity="block_diagonal"`` self-only shortcut) + ``GraphKoopmanOperator``). ``.spectrum`` uses the same Kronecker + eligibility as discrete graph when applicable; dense ``N·d`` + matrix-exp (:math:`\Phi=\exp(\Delta t\, L_{\mathrm{eff}})`) remains a + separate ceiling — prefer modest ``N`` or ``sparsity="block_diagonal"`` + self-only shortcut for advances (see :doc:`limitations`) * Continuous hetero generators on ``koopman="hetero_graph"`` + ``dynamics_mode="continuous"`` (dense stacked :math:`\Phi` cost; see :doc:`limitations`) @@ -248,6 +256,10 @@ Analysis ~~~~~~~~ * ``KoopmanSpectrum`` / ``compute_spectrum`` with mode decoding helpers +* Networked graph / continuous-graph ``.spectrum`` paths: distributed + Arnoldi (discrete / multiplex hetero), Kronecker-sum exact reduction + when eligible, or dense assembled eigendecomposition — see + :doc:`limitations` (Scale); continuous graph has no Arnoldi spectrum path * ``attribute_mode_energy`` / ``ModeEnergyAttribution`` — interpretive type / relation energy fractions on assembled ``K_eff`` (not causal; not a ResDMD residual on relation-attributed modes) diff --git a/docs/source/faq.rst b/docs/source/faq.rst index 5f7a34b..b1c849c 100644 --- a/docs/source/faq.rst +++ b/docs/source/faq.rst @@ -170,13 +170,17 @@ Several training paths still assemble or multiply dense structures whose size grows with :math:`N` (or :math:`N\cdot d`), even when latents and supports are cached within an evaluation: -* Exact spectrum / inverse and continuous dense +* Exact **inverse** and continuous dense :math:`\Phi=\exp(\Delta t\, L_{\mathrm{eff}})` on :math:`(N\cdot d)\times(N\cdot d)` matrices +* Exact **spectrum** when the Kronecker path does not apply (dense + :math:`(N\cdot d)` eigendecomposition, or discrete distributed Arnoldi + surrogate); eligible graph / continuous-graph spectrum uses Kronecker-sum + reduction instead — see below and :doc:`limitations` (Scale) * DiffConv diffusion supports and hypergraph Zhou :math:`\hat{H}` as dense :math:`N\times N` tensors * Eigenvalue hinge on dense / ODO networked operators - (:math:`O((N\cdot d)^3)` eigendecomposition) + (:math:`O((N\cdot d)^3)` eigendecomposition of the assembled map) * Self-adaptive topology materializing full :math:`N^2` COO Shared pair latents, inverse / support / :math:`\hat{H}` / :math:`\Phi` @@ -184,14 +188,38 @@ reuse, and PDE/worst-case prediction sharing reduce repeated work; they do not change those representation sizes. See :doc:`limitations` (Scale) and :doc:`capabilities` (Training performance). +Does spectrum still assemble :math:`N\cdot d`? +---------------------------------------------- + +Not always for discrete ``GraphKoopmanOperator`` / +``ContinuousGraphKoopmanOperator``. ``.spectrum`` auto-routes: + +* ``sparsity="distributed"`` — Arnoldi leading-modulus surrogate on discrete + graph / multiplex hetero; continuous graph has no Arnoldi spectrum path + and uses dense :math:`L_{\mathrm{eff}}` +* Else if eligible (shared self; ``adjacency`` in + ``{"symmetric", "random_walk"}``; ``sparsity`` in + ``{"dense", "block_diagonal"}``) — Kronecker-sum exact spectrum + (order :math:`O(N^3 + N d^3)` via dense :math:`N\times N` + :math:`\widehat{A}` plus :math:`N` blocks of size :math:`d\times d`) +* Else — dense :math:`(N\cdot d)` eigendecomposition + (``dual_random_walk``, discrete orbit / isotypic self banks, hetero / + hypergraph, helper fall-back) + +Exact inverse and eigenvalue-regularization hinges are unchanged (still +dense assembled ceilings where documented). Details: +:doc:`limitations` (Scale) and :doc:`architecture` (spectrum routing). + When should I use ``sparsity="block_diagonal"``? ------------------------------------------------ Use ``sparsity="block_diagonal"`` on graph / hypergraph / continuous-graph operators when the dense :math:`N\cdot d` path dominates wall time and a self-dominated (Jacobi-style) approximation is acceptable for your -advance / inverse / spectrum use case. Prefer ``sparsity="dense"`` when you -need the full coupled effective map. Tutorial: +advance / inverse use case. Prefer ``sparsity="dense"`` when you need the +full coupled effective map for advance / inverse. Eligible graph / +continuous-graph ``.spectrum`` may still Kronecker-route the full coupled +factors under ``block_diagonal``. Tutorial: ``examples/29_large_graph_block_diagonal.ipynb``. How do I enable automatic mixed precision (AMP)? diff --git a/docs/source/installation.rst b/docs/source/installation.rst index bf9969d..49a2e6f 100644 --- a/docs/source/installation.rst +++ b/docs/source/installation.rst @@ -201,8 +201,8 @@ version with the tag you intend; see PyPI and ``CHANGELOG.md``): .. code-block:: bash - pip install koopman-graph==0.11.0 - # or: uv pip install koopman-graph==0.11.0 + pip install koopman-graph==0.12.0 + # or: uv pip install koopman-graph==0.12.0 Releases are published automatically when a maintainer creates a GitHub Release (see ``CONTRIBUTING.md`` in the repository). For the latest in-tree development diff --git a/docs/source/limitations.rst b/docs/source/limitations.rst index 570c7d4..24cdc19 100644 --- a/docs/source/limitations.rst +++ b/docs/source/limitations.rst @@ -159,6 +159,25 @@ Operator and theory invariant scalar latents for linear :math:`K` — not an equivariant operator. +.. _limitations-topology-criticality: + +Topology criticality (non-goal) +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +* **Dynamic topology is mechanical, not criticality-aware.** Mid-horizon + rewiring (``allow_dynamic_topology`` / per-snapshot ``edge_index``) is + supported in the networked linear step so forecasts can consume changing + graphs. The library does **not** analyze or mitigate spectral degeneracy, + spectral-gap closure, defective spectra, or forecast-horizon collapse near + graph-topology criticality (connectivity / load / epidemic-threshold-style + regimes discussed for infrastructure Koopman forecasting by Ghosh, + *Intelligent Systems with Applications*, 2025; ``Ghosh2025``). Held-out + ``spectral_residuals`` and finite-dictionary ResDMD remain diagnostics, + not certificates (see Spectral analysis). Continuous matrix-log / + Van Loan helpers do not handle non-diagonalizable (Jordan) generators + (:mod:`koopman_graph.operators.continuous_van_loan`). No early-warning + score or spectral-gap monitor is shipped. + Spectral analysis ----------------- @@ -190,21 +209,51 @@ Scale Training reuses shared latents and several ephemeral operator / support caches (see :doc:`capabilities` and :doc:`architecture`), but those -optimizations do **not** remove the dense representation ceilings below. +optimizations do **not** remove the representation ceilings below. For large :math:`N`, prefer ``sparsity="block_diagonal"`` where applicable, modest latent width, and optional CUDA automatic mixed precision (``use_amp=True`` on ``fit`` / ``run_fit_loop``); see :doc:`faq`. -* **Exact spectrum and exact inverse** of networked operators (including - relational ``hetero_graph``) assemble an effective dense matrix of size +* **Exact spectrum (graph / continuous-graph).** Discrete + ``GraphKoopmanOperator.spectrum`` and continuous + ``ContinuousGraphKoopmanOperator.spectrum`` auto-route (no path-selection + kwarg): + + 1. ``sparsity="distributed"`` — on discrete graph and multiplex hetero, + matrix-free Arnoldi returns leading-modulus Ritz values (placeholder + eigenvectors of size ``num_modes``). Continuous graph has **no** + Arnoldi spectrum path and falls through to dense + :math:`L_{\mathrm{eff}}` eigendecomposition. + 2. Else if Kronecker-sum eligible — shared self factor, + ``adjacency`` in ``{"symmetric", "random_walk"}``, and + ``sparsity`` in ``{"dense", "block_diagonal"}`` — exact reduction of + :math:`I\otimes M_{\mathrm{self}} + \widehat{A}\otimes M_{\mathrm{nbr}}` + (discrete :math:`K` or continuous generator :math:`L`). Cost is + dominated by a dense :math:`N\times N` eigendecomposition of + :math:`\widehat{A}` plus :math:`N` blocks of size :math:`d\times d` + (order :math:`O(N^3 + N d^3)`), not a full ambient + :math:`O((N\cdot d)^3)` factorization when the helper succeeds. + 3. Else — dense :math:`(N\cdot d)\times(N\cdot d)` eigendecomposition + of the assembled effective map (``dual_random_walk``, discrete + orbit / isotypic self banks, helper fall-back, and other ineligible + cases). + + Hetero / hypergraph spectrum remains under the dense assembled + :math:`(N\cdot d)` (or stacked typed) ceiling. Kronecker spectrum does + **not** imply a Kronecker inverse or cheaper eig-regularization. + +* **Exact inverse** of networked operators (including relational + ``hetero_graph``) still assembles an effective dense matrix of size :math:`(N \cdot d) \times (N \cdot d)` (typed / rectangular: - stacked :math:`\sum_\tau N_\tau d_\tau`). Prefer modest :math:`N` or + stacked :math:`\sum_\tau N_\tau d_\tau`), unless an approximate + Jacobi / Richardson / Neumann path applies. Prefer modest :math:`N` or ``sparsity="block_diagonal"`` (approximate Jacobi / self-dominated path) when that cost dominates. Static topology may reuse a precomputed dense inverse within a training-loss evaluation; the assembly size is unchanged. Multi-GPU *trainer* orchestration (DDP / Fabric / Lightning / Ray Train) shards data and synchronizes gradients; it does **not** shrink this dense - ceiling. Presence-mask churn still matvecs at :math:`N_{\max}` capacity. + inverse ceiling. Presence-mask churn still matvecs at :math:`N_{\max}` + capacity. * **Hetero × trainers.** Multiplex / typed models compose with native DDP (``strategy="ddp"``), Lightning Fabric, optional Lightning ``Trainer``, and Ray helpers under :mod:`koopman_graph.distributed`. @@ -212,21 +261,24 @@ modest latent width, and optional CUDA automatic mixed precision Single-process windowed ``run_fit_loop`` accepts windowed hetero sequences (parity with world-size-1 DDP window sampling). Do not confuse trainer orchestration with the operator flag ``sparsity="distributed"`` - (matrix-free inverse / spectrum; see below). + (matrix-free inverse / Arnoldi spectrum on discrete graph and multiplex + hetero; see below). * **Eigenvalue regularization** with a non-zero ``LossWeights.eigenvalue`` on dense or ODO networked operators runs an - :math:`O((N \cdot d)^3)` eigendecomposition of the effective map unless - ``sparsity="distributed"`` (Arnoldi surrogate on discrete graph / + :math:`O((N \cdot d)^3)` eigendecomposition of the assembled effective map + unless ``sparsity="distributed"`` (Arnoldi surrogate on discrete graph / multiplex hetero; zero hinge on hypergraph / continuous distributed). - Prefer structural parameterizations (``schur`` / ``lyapunov`` / + The Kronecker spectrum path does **not** change this training-hinge + ceiling. Prefer structural parameterizations (``schur`` / ``lyapunov`` / ``dissipative``) or modest :math:`N` when the assembled term is enabled. * **``sparsity="distributed"``** is the *operator* matrix-free path (Richardson / Neumann inverse and Arnoldi spectrum for discrete graph and - multiplex hetero; hypergraph / continuous kinds may still assemble). It is - **not** multi-GPU training. Optional *trainer* orchestration under - :mod:`koopman_graph.distributed` shards data and synchronizes gradients; - it does **not** shrink the dense :math:`N\cdot d` representation ceilings - above. + multiplex hetero; hypergraph / continuous kinds may still assemble for + inverse and for continuous spectrum). It is **not** multi-GPU training + and is **not** the Kronecker exact-spectrum reduction. Optional + *trainer* orchestration under :mod:`koopman_graph.distributed` shards + data and synchronizes gradients; it does **not** shrink the dense + :math:`N\cdot d` representation ceilings above. * **Trainer taxonomy (DDP / Fabric / Ray).** Native DDP and Lightning Fabric remain the **recommended** multi-GPU *model* paths. :func:`~koopman_graph.distributed.run_ray_train_fit_loop` (optional diff --git a/examples/18_networked_koopman_dynamic_topology.ipynb b/examples/18_networked_koopman_dynamic_topology.ipynb index bfff062..c307768 100644 --- a/examples/18_networked_koopman_dynamic_topology.ipynb +++ b/examples/18_networked_koopman_dynamic_topology.ipynb @@ -1,959 +1,977 @@ { - "cells": [ - { - "cell_type": "markdown", - "id": "18-0", - "metadata": {}, - "source": [ - "# Networked Koopman Operator and Dynamic Topology\n", - "\n", - "This notebook shows how a networked Koopman operator couples graph topology into\n", - "the **linear** latent step. It assumes the encode → Koopman step → decode workflow\n", - "from [`01_synthetic_graph.ipynb`](01_synthetic_graph.ipynb); here topology enters\n", - "that linear step via `koopman=\"graph\"`.\n", - "\n", - "Dynamic-topology support in KoopmanGraph already lets `predict(..., future_topologies=...)`\n", - "change the **decode** graph mid-horizon. With the default per-node operator, though,\n", - "the **linear** step is still `z @ K.T` independently at every node — so rewiring never\n", - "touches latent advance itself.\n", - "\n", - "Related work uses block structure inside the linear map itself. Li et al. (2020) learn\n", - "compositional / object-centric Koopman models whose relation-typed blocks `K_ij`\n", - "share parameters across equivalent interactions (off-diagonal blocks carry coupling;\n", - "their `Diag` ablation zeros those blocks). Mukherjee et al. (2022) learn distributed\n", - "geometric Koopman operators on sparse networks, with agent-level blocks and\n", - "`A_ij = 0` for non-neighbors. This notebook studies a simpler shared self/neighbor\n", - "factorization, `I ⊗ K_self + Â ⊗ K_nbr`, and asks whether topology still enters the\n", - "**linear** step under mid-horizon rewiring.\n", - "\n", - "> **Primary question:** under a mid-horizon path→ring rewire, does `koopman=\"graph\"`\n", - "> change **latent advance** in a way that `koopman=\"pernode\"` cannot?\n", - "\n", - "We train matched Schur-parameterized models with a conservative factor radius so\n", - "rollouts stay finite, then use latent `|Δz|` as the decisive check. Physical\n", - "panels are a **sanity check** (no blow-up; coarse RMSE), not a claim of accurate\n", - "long-horizon path forecasting. Spectrum panels show how the effective networked\n", - "operator depends on `Â` (often modestly when `K_nbr` is small).\n" - ] - }, - { - "cell_type": "markdown", - "id": "18-1", - "metadata": {}, - "source": [ - "## Method: per-node vs networked `K` under rewiring\n", - "\n", - "Train matched Schur-parameterized models and ask whether mid-horizon path→ring\n", - "rewiring changes **latent advance** for `koopman=\"graph\"` in a way\n", - "`koopman=\"pernode\"` cannot. Physical panels are a sanity check, not a long-horizon\n", - "forecast claim.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "18-2", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-21T02:11:04.712419Z", - "iopub.status.busy": "2026-07-21T02:11:04.712341Z", - "iopub.status.idle": "2026-07-21T02:11:06.252323Z", - "shell.execute_reply": "2026-07-21T02:11:06.251866Z" - } - }, - "outputs": [], - "source": [ - "import os\n", - "import random\n", - "import warnings\n", - "\n", - "from tqdm.std import TqdmWarning\n", - "\n", - "warnings.filterwarnings(\"ignore\", category=TqdmWarning)\n", - "\n", - "import matplotlib\n", - "\n", - "if os.environ.get(\"PYTEST_CURRENT_TEST\"):\n", - " matplotlib.use(\"Agg\")\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import torch\n", - "from torch_geometric.data import Data\n", - "\n", - "try:\n", - " from IPython import get_ipython\n", - "\n", - " if get_ipython() is not None and not os.environ.get(\"PYTEST_CURRENT_TEST\"):\n", - " get_ipython().run_line_magic(\"matplotlib\", \"inline\")\n", - "except (ImportError, NameError):\n", - " pass\n", - "\n", - "from koopman_graph import GNNDecoder, GNNEncoder, GraphKoopmanModel\n", - "from koopman_graph.datasets import SyntheticDynamicGraphBenchmark\n", - "from koopman_graph.graph_utils import dense_symmetric_normalized_adjacency\n", - "\n", - "CI = bool(os.environ.get(\"PYTEST_CURRENT_TEST\"))\n", - "SEED = 0\n", - "random.seed(SEED)\n", - "np.random.seed(SEED)\n", - "torch.manual_seed(SEED)\n", - "\n", - "NUM_NODES = 12\n", - "IN_CHANNELS = 2\n", - "LATENT_DIM = 8\n", - "SPLIT = 15\n", - "FEATURE = 0\n", - "NODE_ID = NUM_NODES // 2\n", - "PARAM = \"schur\"\n", - "# Factor bounds do not certify ρ(I⊗K_self + Â⊗K_nbr). Keep a margin so the\n", - "# interactive (40-epoch) demo stays contractive on the path adjacency.\n", - "MAX_RHO = 0.7\n", - "EPOCHS = 8 if CI else 40\n", - "\n", - "seq = SyntheticDynamicGraphBenchmark.generate(\n", - " num_nodes=NUM_NODES,\n", - " num_timesteps=30,\n", - " in_channels=IN_CHANNELS,\n", - " topology=\"path\",\n", - " seed=SEED,\n", - " noise_std=0.0,\n", - ")\n", - "\n", - "ring_edges: list[list[int]] = []\n", - "for i in range(NUM_NODES):\n", - " j = (i + 1) % NUM_NODES\n", - " ring_edges.extend([[i, j], [j, i]])\n", - "ring_edge_index = torch.tensor(ring_edges, dtype=torch.long).t().contiguous()\n", - "path_edge_index = seq[0].edge_index\n", - "\n", - "origin = seq[SPLIT - 1]\n", - "targets = list(seq[SPLIT:])\n", - "horizon = len(targets)\n", - "future_topologies = [\n", - " Data(x=seq[t].x, edge_index=ring_edge_index) for t in range(SPLIT, len(seq))\n", - "]\n", - "\n", - "plt.rcParams.update(\n", - " {\n", - " \"figure.facecolor\": \"white\",\n", - " \"axes.facecolor\": \"white\",\n", - " \"axes.titlesize\": 11,\n", - " \"axes.labelsize\": 10,\n", - " \"font.size\": 10,\n", - " }\n", - ")\n" - ] - }, - { - "cell_type": "markdown", - "id": "18-2b", - "metadata": {}, - "source": [ - "## Helper functions\n", - "\n", - "Notebook-local helpers used below.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "18-2c", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-21T02:11:06.253770Z", - "iopub.status.busy": "2026-07-21T02:11:06.253628Z", - "iopub.status.idle": "2026-07-21T02:11:06.258624Z", - "shell.execute_reply": "2026-07-21T02:11:06.258209Z" - } - }, - "outputs": [], - "source": [ - "def draw_graph(ax, edge_index: torch.Tensor, *, title: str, layout: str) -> None:\n", - " \"\"\"Draw a simple undirected graph without networkx.\"\"\"\n", - " if layout == \"path\":\n", - " y0 = 0.0\n", - " pos = {i: (float(i), y0) for i in range(NUM_NODES)}\n", - " label_xy = {i: (float(i), y0 - 0.22) for i in range(NUM_NODES)}\n", - " label_va = \"top\"\n", - " else:\n", - " # Labels sit inside the ring so they cannot collide with the title.\n", - " radius = 0.82\n", - " label_radius = 0.52\n", - " angles = np.linspace(0.0, 2.0 * np.pi, NUM_NODES, endpoint=False)\n", - " pos = {\n", - " i: (radius * np.cos(theta), radius * np.sin(theta))\n", - " for i, theta in enumerate(angles)\n", - " }\n", - " label_xy = {\n", - " i: (label_radius * np.cos(theta), label_radius * np.sin(theta))\n", - " for i, theta in enumerate(angles)\n", - " }\n", - " label_va = \"center\"\n", - "\n", - " seen: set[tuple[int, int]] = set()\n", - " for src, dst in edge_index.t().tolist():\n", - " edge = (min(src, dst), max(src, dst))\n", - " if edge in seen:\n", - " continue\n", - " seen.add(edge)\n", - " x0, y0_ = pos[src]\n", - " x1, y1_ = pos[dst]\n", - " ax.plot([x0, x1], [y0_, y1_], color=\"0.55\", linewidth=1.4, zorder=1)\n", - "\n", - " xs = [pos[i][0] for i in range(NUM_NODES)]\n", - " ys = [pos[i][1] for i in range(NUM_NODES)]\n", - " ax.scatter(xs, ys, s=70, c=\"#4C78A8\", zorder=2, edgecolors=\"white\", linewidths=0.6)\n", - " for i in range(NUM_NODES):\n", - " lx, ly = label_xy[i]\n", - " ax.text(lx, ly, str(i), ha=\"center\", va=label_va, fontsize=8, clip_on=True)\n", - "\n", - " if layout == \"path\":\n", - " # Auto aspect: path is 1-D, equal-aspect was collapsing title headroom.\n", - " ax.set_xlim(-0.6, NUM_NODES - 0.4)\n", - " ax.set_ylim(-0.95, 0.95)\n", - " ax.set_aspect(\"auto\")\n", - " else:\n", - " ax.set_xlim(-1.2, 1.2)\n", - " ax.set_ylim(-1.2, 1.2)\n", - " ax.set_aspect(\"equal\", adjustable=\"box\")\n", - "\n", - " ax.set_title(title, pad=12)\n", - " ax.axis(\"off\")\n", - "\n", - "def make_model(kind: str) -> GraphKoopmanModel:\n", - " return GraphKoopmanModel(\n", - " encoder=GNNEncoder(IN_CHANNELS, 16, LATENT_DIM, num_layers=2),\n", - " decoder=GNNDecoder(LATENT_DIM, 16, IN_CHANNELS, num_layers=2),\n", - " latent_dim=LATENT_DIM,\n", - " time_step=0.1,\n", - " koopman=kind,\n", - " koopman_parameterization=PARAM,\n", - " koopman_max_spectral_radius=MAX_RHO,\n", - " )\n", - "\n", - "def mean_rmse(preds, target_snaps) -> float:\n", - " errors = [\n", - " (pred.x - target.x).pow(2).mean().sqrt()\n", - " for pred, target in zip(preds, target_snaps, strict=True)\n", - " ]\n", - " return float(torch.stack(errors).mean())\n", - "\n", - "def field_matrix(snaps) -> np.ndarray:\n", - " \"\"\"Stack node values for one feature into shape (num_nodes, time).\"\"\"\n", - " return torch.stack([snap.x[:, FEATURE] for snap in snaps], dim=1).detach().numpy()\n", - "\n", - "@torch.no_grad()\n", - "def latent_gap_curve(model: GraphKoopmanModel) -> np.ndarray:\n", - " \"\"\"Per-step mean |z_path - z_ring| under fixed-topology latent rollouts.\"\"\"\n", - " z_path = model.encode(origin)\n", - " z_ring = z_path.clone()\n", - " gaps = []\n", - " for _ in range(horizon):\n", - " z_path = model.koopman.advance(z_path, edge_index=path_edge_index)\n", - " z_ring = model.koopman.advance(z_ring, edge_index=ring_edge_index)\n", - " gaps.append(float((z_path - z_ring).abs().mean().detach()))\n", - " return np.asarray(gaps)\n", - "\n", - "# Set distance: for each path eigenvalue, nearest ring eigenvalue (and vice versa).\n", - "def _eigset_hausdorff(a: np.ndarray, b: np.ndarray) -> float:\n", - " d_ab = np.max([np.min(np.abs(a_i - b)) for a_i in a])\n", - " d_ba = np.max([np.min(np.abs(b_j - a)) for b_j in b])\n", - " return float(max(d_ab, d_ba))\n" - ] - }, - { - "cell_type": "markdown", - "id": "18-3", - "metadata": {}, - "source": [ - "## Path and ring topologies\n", - "\n", - "Confirm the shared setup from the first code cell: path training sequence,\n", - "mid-horizon ring rewire, and evaluation fields.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "18-4", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-21T02:11:06.259602Z", - "iopub.status.busy": "2026-07-21T02:11:06.259538Z", - "iopub.status.idle": "2026-07-21T02:11:06.261450Z", - "shell.execute_reply": "2026-07-21T02:11:06.260990Z" - } - }, - "outputs": [ + "cells": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "sequence length=30, origin t=14, forecast horizon=15, train topology=path, shock=ring\n", - "operator parameterization=schur, max_spectral_radius=0.7, epochs=40\n" - ] - } - ], - "source": [ - "print(\n", - " f\"sequence length={len(seq)}, origin t={SPLIT - 1}, \"\n", - " f\"forecast horizon={horizon}, train topology=path, shock=ring\"\n", - ")\n", - "print(f\"operator parameterization={PARAM}, max_spectral_radius={MAX_RHO}, epochs={EPOCHS}\")\n" - ] - }, - { - "cell_type": "markdown", - "id": "18-5", - "metadata": {}, - "source": [ - "### Visualize the topology shock\n", - "\n", - "Path (training / hold-last) vs ring (known future). The adjacency heatmaps show how\n", - "normalized coupling `Â` changes when the contacts close into a loop — including\n", - "renormalization of the old endpoint edges.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "18-6", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-21T02:11:06.262233Z", - "iopub.status.busy": "2026-07-21T02:11:06.262162Z", - "iopub.status.idle": "2026-07-21T02:11:06.553632Z", - "shell.execute_reply": "2026-07-21T02:11:06.553273Z" - } - }, - "outputs": [ + "cell_type": "markdown", + "id": "18-0", + "metadata": {}, + "source": [ + "# Networked Koopman Operator and Dynamic Topology\n", + "\n", + "This notebook shows how a networked Koopman operator couples graph topology into\n", + "the **linear** latent step. It assumes the encode → Koopman step → decode workflow\n", + "from [`01_synthetic_graph.ipynb`](01_synthetic_graph.ipynb); here topology enters\n", + "that linear step via `koopman=\"graph\"`.\n", + "\n", + "Dynamic-topology support in KoopmanGraph already lets `predict(..., future_topologies=...)`\n", + "change the **decode** graph mid-horizon. With the default per-node operator, though,\n", + "the **linear** step is still `z @ K.T` independently at every node — so rewiring never\n", + "touches latent advance itself.\n", + "\n", + "Related work uses block structure inside the linear map itself. Li et al. (2020) learn\n", + "compositional / object-centric Koopman models whose relation-typed blocks `K_ij`\n", + "share parameters across equivalent interactions (off-diagonal blocks carry coupling;\n", + "their `Diag` ablation zeros those blocks). Mukherjee et al. (2022) learn distributed\n", + "geometric Koopman operators on sparse networks, with agent-level blocks and\n", + "`A_ij = 0` for non-neighbors. This notebook studies a simpler shared self/neighbor\n", + "factorization, `I ⊗ K_self + Â ⊗ K_nbr`, and asks whether topology still enters the\n", + "**linear** step under mid-horizon rewiring.\n", + "\n", + "> **Primary question:** under a mid-horizon path→ring rewire, does `koopman=\"graph\"`\n", + "> change **latent advance** in a way that `koopman=\"pernode\"` cannot?\n", + "\n", + "We train matched Schur-parameterized models with a conservative factor radius so\n", + "rollouts stay finite, then use latent `|Δz|` as the decisive check. Physical\n", + "panels are a **sanity check** (no blow-up; coarse RMSE), not a claim of accurate\n", + "long-horizon path forecasting. Spectrum panels show how the effective networked\n", + "operator depends on `Â` (often modestly when `K_nbr` is small).\n" + ] + }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "markdown", + "id": "9aa8fd85", + "metadata": {}, + "source": [ + "### Scope honesty\n", + "\n", + "This notebook demonstrates **mechanical** mid-horizon rewiring:\n", + "`future_topologies` / path→ring changes enter the linear networked step under\n", + "`koopman=\"graph\"`. It is **not** a study of graph-topology criticality,\n", + "spectral degeneracy, gap closure, defective spectra, or early-warning scores.\n", + "Those failure modes are out of scope here; see Sphinx\n", + "[Scope and limitations — Topology criticality](https://koopmangraph.readthedocs.io/en/latest/limitations.html#topology-criticality-non-goal)\n", + "(source: `docs/source/limitations.rst`).\n" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "adj_path = dense_symmetric_normalized_adjacency(\n", - " path_edge_index, NUM_NODES, dtype=torch.float32\n", - ").numpy()\n", - "adj_ring = dense_symmetric_normalized_adjacency(\n", - " ring_edge_index, NUM_NODES, dtype=torch.float32\n", - ").numpy()\n", - "\n", - "fig, axes = plt.subplots(2, 2, figsize=(9.5, 8.0))\n", - "draw_graph(axes[0, 0], path_edge_index, title=\"Train / hold-last: path\", layout=\"path\")\n", - "draw_graph(axes[0, 1], ring_edge_index, title=\"Known future: ring\", layout=\"ring\")\n", - "\n", - "im0 = axes[1, 0].imshow(adj_path, cmap=\"viridis\", vmin=0.0, vmax=1.0)\n", - "axes[1, 0].set_title(r\"Normalized adjacency $\\hat{A}$ (path)\", pad=10)\n", - "axes[1, 0].set_xlabel(\"node\")\n", - "axes[1, 0].set_ylabel(\"node\")\n", - "fig.colorbar(im0, ax=axes[1, 0], fraction=0.046)\n", - "\n", - "im1 = axes[1, 1].imshow(adj_ring - adj_path, cmap=\"coolwarm\", vmin=-1.0, vmax=1.0)\n", - "axes[1, 1].set_title(r\"$\\hat{A}_{\\mathrm{ring}} - \\hat{A}_{\\mathrm{path}}$\", pad=10)\n", - "axes[1, 1].set_xlabel(\"node\")\n", - "axes[1, 1].set_ylabel(\"node\")\n", - "fig.colorbar(im1, ax=axes[1, 1], fraction=0.046)\n", - "fig.tight_layout(h_pad=2.4, w_pad=1.2)\n", - "plt.show()\n" - ] - }, - { - "cell_type": "markdown", - "id": "18-7", - "metadata": {}, - "source": [ - "## Train\n", - "\n", - "Fit per-node and networked operators under the shared protocol.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "18-8", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-21T02:11:06.554633Z", - "iopub.status.busy": "2026-07-21T02:11:06.554564Z", - "iopub.status.idle": "2026-07-21T02:11:08.438515Z", - "shell.execute_reply": "2026-07-21T02:11:08.438056Z" - } - }, - "outputs": [], - "source": [ - "models = {\n", - " \"pernode\": make_model(\"pernode\"),\n", - " \"graph\": make_model(\"graph\"),\n", - "}\n", - "histories = {\n", - " name: model.fit(seq, epochs=EPOCHS, lr=1e-2) for name, model in models.items()\n", - "}\n", - "\n", - "predictions: dict[str, dict[str, list]] = {}\n", - "gap_curves: dict[str, np.ndarray] = {}\n", - "rows: list[dict[str, float | str]] = []\n", - "\n", - "for name, model in models.items():\n", - " hold = model.predict(origin, steps=horizon)\n", - " rewire = model.predict(\n", - " origin, steps=horizon, future_topologies=future_topologies\n", - " )\n", - " predictions[name] = {\"hold\": hold, \"ring\": rewire}\n", - " gap_curves[name] = latent_gap_curve(model)\n", - "\n", - " with torch.no_grad():\n", - " z0 = model.encode(origin)\n", - " z_path = model.koopman.advance(z0, edge_index=path_edge_index)\n", - " z_ring = model.koopman.advance(z0, edge_index=ring_edge_index)\n", - " one_step_gap = float((z_path - z_ring).abs().mean().detach())\n", - "\n", - " rows.append(\n", - " {\n", - " \"model\": name,\n", - " \"final_train_loss\": float(histories[name].loss[-1]),\n", - " \"rmse_hold_path\": mean_rmse(hold, targets),\n", - " \"rmse_known_ring\": mean_rmse(rewire, targets),\n", - " \"latent_advance_gap\": one_step_gap,\n", - " }\n", - " )\n", - "\n", - "graph_model = models[\"graph\"]\n", - "spec_path = graph_model.koopman.spectrum(path_edge_index, NUM_NODES)\n", - "spec_ring = graph_model.koopman.spectrum(ring_edge_index, NUM_NODES)\n", - "truth_field = field_matrix(targets)\n", - "\n", - "row_by_name = {str(row[\"model\"]): row for row in rows}\n", - "assert float(row_by_name[\"pernode\"][\"latent_advance_gap\"]) < 1e-6\n", - "assert float(row_by_name[\"graph\"][\"latent_advance_gap\"]) > 1e-6\n", - "assert gap_curves[\"pernode\"].max() < 1e-6\n", - "assert gap_curves[\"graph\"].max() > 1e-6\n", - "# Stable demo: both models should track path targets under hold-last.\n", - "hold_pernode = float(row_by_name[\"pernode\"][\"rmse_hold_path\"])\n", - "hold_graph = float(row_by_name[\"graph\"][\"rmse_hold_path\"])\n", - "assert hold_pernode < 0.25, f\"pernode hold RMSE too high: {hold_pernode:.4f}\"\n", - "assert hold_graph < 0.25, f\"graph hold RMSE too high: {hold_graph:.4f}\"\n" - ] - }, - { - "cell_type": "markdown", - "id": "18-9", - "metadata": {}, - "source": [ - "## Evaluate and results\n" - ] - }, - { - "cell_type": "markdown", - "id": "18-10", - "metadata": {}, - "source": [ - "### Aggregate metrics\n", - "\n", - "Left: one-step latent gap (primary claim). Right: forecast RMSE vs path targets\n", - "(sanity check that both models stayed finite — not a coupling test).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "18-11", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-21T02:11:08.439647Z", - "iopub.status.busy": "2026-07-21T02:11:08.439579Z", - "iopub.status.idle": "2026-07-21T02:11:08.555459Z", - "shell.execute_reply": "2026-07-21T02:11:08.554984Z" - } - }, - "outputs": [ + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "model train_loss RMSE hold RMSE ring |Δz| 1-step\n", - "pernode 0.0038 0.0814 0.0835 0.000e+00\n", - "graph 0.0039 0.0584 0.0629 1.774e-03\n" - ] + "cell_type": "markdown", + "id": "18-1", + "metadata": {}, + "source": [ + "## Method: per-node vs networked `K` under rewiring\n", + "\n", + "Train matched Schur-parameterized models and ask whether mid-horizon path→ring\n", + "rewiring changes **latent advance** for `koopman=\"graph\"` in a way\n", + "`koopman=\"pernode\"` cannot. Physical panels are a sanity check, not a long-horizon\n", + "forecast claim.\n" + ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "code", + "execution_count": 1, + "id": "18-2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-21T02:11:04.712419Z", + "iopub.status.busy": "2026-07-21T02:11:04.712341Z", + "iopub.status.idle": "2026-07-21T02:11:06.252323Z", + "shell.execute_reply": "2026-07-21T02:11:06.251866Z" + } + }, + "outputs": [], + "source": [ + "import os\n", + "import random\n", + "import warnings\n", + "\n", + "from tqdm.std import TqdmWarning\n", + "\n", + "warnings.filterwarnings(\"ignore\", category=TqdmWarning)\n", + "\n", + "import matplotlib\n", + "\n", + "if os.environ.get(\"PYTEST_CURRENT_TEST\"):\n", + " matplotlib.use(\"Agg\")\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import torch\n", + "from torch_geometric.data import Data\n", + "\n", + "try:\n", + " from IPython import get_ipython\n", + "\n", + " if get_ipython() is not None and not os.environ.get(\"PYTEST_CURRENT_TEST\"):\n", + " get_ipython().run_line_magic(\"matplotlib\", \"inline\")\n", + "except (ImportError, NameError):\n", + " pass\n", + "\n", + "from koopman_graph import GNNDecoder, GNNEncoder, GraphKoopmanModel\n", + "from koopman_graph.datasets import SyntheticDynamicGraphBenchmark\n", + "from koopman_graph.graph_utils import dense_symmetric_normalized_adjacency\n", + "\n", + "CI = bool(os.environ.get(\"PYTEST_CURRENT_TEST\"))\n", + "SEED = 0\n", + "random.seed(SEED)\n", + "np.random.seed(SEED)\n", + "torch.manual_seed(SEED)\n", + "\n", + "NUM_NODES = 12\n", + "IN_CHANNELS = 2\n", + "LATENT_DIM = 8\n", + "SPLIT = 15\n", + "FEATURE = 0\n", + "NODE_ID = NUM_NODES // 2\n", + "PARAM = \"schur\"\n", + "# Factor bounds do not certify ρ(I⊗K_self + Â⊗K_nbr). Keep a margin so the\n", + "# interactive (40-epoch) demo stays contractive on the path adjacency.\n", + "MAX_RHO = 0.7\n", + "EPOCHS = 8 if CI else 40\n", + "\n", + "seq = SyntheticDynamicGraphBenchmark.generate(\n", + " num_nodes=NUM_NODES,\n", + " num_timesteps=30,\n", + " in_channels=IN_CHANNELS,\n", + " topology=\"path\",\n", + " seed=SEED,\n", + " noise_std=0.0,\n", + ")\n", + "\n", + "ring_edges: list[list[int]] = []\n", + "for i in range(NUM_NODES):\n", + " j = (i + 1) % NUM_NODES\n", + " ring_edges.extend([[i, j], [j, i]])\n", + "ring_edge_index = torch.tensor(ring_edges, dtype=torch.long).t().contiguous()\n", + "path_edge_index = seq[0].edge_index\n", + "\n", + "origin = seq[SPLIT - 1]\n", + "targets = list(seq[SPLIT:])\n", + "horizon = len(targets)\n", + "future_topologies = [\n", + " Data(x=seq[t].x, edge_index=ring_edge_index) for t in range(SPLIT, len(seq))\n", + "]\n", + "\n", + "plt.rcParams.update(\n", + " {\n", + " \"figure.facecolor\": \"white\",\n", + " \"axes.facecolor\": \"white\",\n", + " \"axes.titlesize\": 11,\n", + " \"axes.labelsize\": 10,\n", + " \"font.size\": 10,\n", + " }\n", + ")\n" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "print(\n", - " f\"{'model':8s} {'train_loss':>12s} {'RMSE hold':>12s} \"\n", - " f\"{'RMSE ring':>12s} {'|Δz| 1-step':>14s}\"\n", - ")\n", - "for row in rows:\n", - " print(\n", - " f\"{row['model']:8s} \"\n", - " f\"{row['final_train_loss']:12.4f} \"\n", - " f\"{row['rmse_hold_path']:12.4f} \"\n", - " f\"{row['rmse_known_ring']:12.4f} \"\n", - " f\"{row['latent_advance_gap']:14.3e}\"\n", - " )\n", - "\n", - "labels = [str(row[\"model\"]) for row in rows]\n", - "gaps = [float(row[\"latent_advance_gap\"]) for row in rows]\n", - "hold_rmse = [float(row[\"rmse_hold_path\"]) for row in rows]\n", - "ring_rmse = [float(row[\"rmse_known_ring\"]) for row in rows]\n", - "\n", - "fig, axes = plt.subplots(1, 2, figsize=(9.5, 3.6), constrained_layout=True)\n", - "axes[0].bar(labels, gaps, color=[\"#4C78A8\", \"#F58518\"])\n", - "axes[0].set_ylabel(r\"mean $|z_{\\mathrm{path}} - z_{\\mathrm{ring}}|$\")\n", - "axes[0].set_title(\"One-step latent advance gap (primary)\")\n", - "axes[0].set_yscale(\"symlog\", linthresh=1e-8)\n", - "\n", - "x = np.arange(len(labels))\n", - "width = 0.35\n", - "axes[1].bar(x - width / 2, hold_rmse, width, label=\"hold path\", color=\"#4C78A8\")\n", - "axes[1].bar(x + width / 2, ring_rmse, width, label=\"known ring\", color=\"#F58518\")\n", - "axes[1].set_xticks(x, labels)\n", - "axes[1].set_ylabel(\"mean RMSE vs path targets\")\n", - "axes[1].set_title(\"Forecast RMSE (sanity check, not coupling)\")\n", - "axes[1].legend(frameon=False)\n", - "plt.show()\n" - ] - }, - { - "cell_type": "markdown", - "id": "18-12", - "metadata": {}, - "source": [ - "### Latent advance gap over the horizon (decisive evidence)\n", - "\n", - "Encode once at the origin, then advance two latent copies — one under path edges,\n", - "one under ring edges — with **no** decode. `pernode` must stay at numerical zero;\n", - "`graph` must separate. This is the direct answer to the notebook question.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "18-13", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-21T02:11:08.556605Z", - "iopub.status.busy": "2026-07-21T02:11:08.556511Z", - "iopub.status.idle": "2026-07-21T02:11:08.728213Z", - "shell.execute_reply": "2026-07-21T02:11:08.727822Z" - } - }, - "outputs": [ + }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "markdown", + "id": "18-2b", + "metadata": {}, + "source": [ + "## Helper functions\n", + "\n", + "Notebook-local helpers used below.\n" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "steps = np.arange(1, horizon + 1)\n", - "fig, ax = plt.subplots(figsize=(7.5, 3.4), constrained_layout=True)\n", - "ax.plot(\n", - " steps,\n", - " gap_curves[\"pernode\"],\n", - " marker=\"o\",\n", - " markersize=3,\n", - " color=\"#4C78A8\",\n", - " label=\"pernode\",\n", - ")\n", - "ax.plot(\n", - " steps,\n", - " gap_curves[\"graph\"],\n", - " marker=\"s\",\n", - " markersize=3,\n", - " color=\"#F58518\",\n", - " label=\"graph\",\n", - ")\n", - "ax.set_xlabel(\"latent advance step\")\n", - "ax.set_ylabel(r\"mean $|z^{\\mathrm{path}} - z^{\\mathrm{ring}}|$\")\n", - "ax.set_title(\"Topology sensitivity of the linear step\")\n", - "ax.set_yscale(\"symlog\", linthresh=1e-8)\n", - "ax.legend(frameon=False)\n", - "plt.show()\n" - ] - }, - { - "cell_type": "markdown", - "id": "18-14", - "metadata": {}, - "source": [ - "### Physical forecasts: finite rollouts under hold-path\n", - "\n", - "These panels are a **sanity check**, not the coupling test. With the conservative\n", - "Schur factor bound, both models stay finite and pass a coarse mean-RMSE gate, but\n", - "they typically **damp faster** than the true path diffusion over the forecast horizon.\n", - "\n", - "The `|ring − hold|` maps are mostly **endpoint-dominated** (decoder sees the rewire\n", - "at nodes 0/11). A small gap for `pernode` is expected from decode-only topology\n", - "changes. A somewhat larger / more persistent gap for `graph` is consistent with\n", - "decode **plus** linear coupling — still secondary to the latent `|Δz|` curve above.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "18-15", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-21T02:11:08.729358Z", - "iopub.status.busy": "2026-07-21T02:11:08.729284Z", - "iopub.status.idle": "2026-07-21T02:11:09.259221Z", - "shell.execute_reply": "2026-07-21T02:11:09.258715Z" - } - }, - "outputs": [ + }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "code", + "execution_count": 2, + "id": "18-2c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-21T02:11:06.253770Z", + "iopub.status.busy": "2026-07-21T02:11:06.253628Z", + "iopub.status.idle": "2026-07-21T02:11:06.258624Z", + "shell.execute_reply": "2026-07-21T02:11:06.258209Z" + } + }, + "outputs": [], + "source": [ + "def draw_graph(ax, edge_index: torch.Tensor, *, title: str, layout: str) -> None:\n", + " \"\"\"Draw a simple undirected graph without networkx.\"\"\"\n", + " if layout == \"path\":\n", + " y0 = 0.0\n", + " pos = {i: (float(i), y0) for i in range(NUM_NODES)}\n", + " label_xy = {i: (float(i), y0 - 0.22) for i in range(NUM_NODES)}\n", + " label_va = \"top\"\n", + " else:\n", + " # Labels sit inside the ring so they cannot collide with the title.\n", + " radius = 0.82\n", + " label_radius = 0.52\n", + " angles = np.linspace(0.0, 2.0 * np.pi, NUM_NODES, endpoint=False)\n", + " pos = {\n", + " i: (radius * np.cos(theta), radius * np.sin(theta))\n", + " for i, theta in enumerate(angles)\n", + " }\n", + " label_xy = {\n", + " i: (label_radius * np.cos(theta), label_radius * np.sin(theta))\n", + " for i, theta in enumerate(angles)\n", + " }\n", + " label_va = \"center\"\n", + "\n", + " seen: set[tuple[int, int]] = set()\n", + " for src, dst in edge_index.t().tolist():\n", + " edge = (min(src, dst), max(src, dst))\n", + " if edge in seen:\n", + " continue\n", + " seen.add(edge)\n", + " x0, y0_ = pos[src]\n", + " x1, y1_ = pos[dst]\n", + " ax.plot([x0, x1], [y0_, y1_], color=\"0.55\", linewidth=1.4, zorder=1)\n", + "\n", + " xs = [pos[i][0] for i in range(NUM_NODES)]\n", + " ys = [pos[i][1] for i in range(NUM_NODES)]\n", + " ax.scatter(xs, ys, s=70, c=\"#4C78A8\", zorder=2, edgecolors=\"white\", linewidths=0.6)\n", + " for i in range(NUM_NODES):\n", + " lx, ly = label_xy[i]\n", + " ax.text(lx, ly, str(i), ha=\"center\", va=label_va, fontsize=8, clip_on=True)\n", + "\n", + " if layout == \"path\":\n", + " # Auto aspect: path is 1-D, equal-aspect was collapsing title headroom.\n", + " ax.set_xlim(-0.6, NUM_NODES - 0.4)\n", + " ax.set_ylim(-0.95, 0.95)\n", + " ax.set_aspect(\"auto\")\n", + " else:\n", + " ax.set_xlim(-1.2, 1.2)\n", + " ax.set_ylim(-1.2, 1.2)\n", + " ax.set_aspect(\"equal\", adjustable=\"box\")\n", + "\n", + " ax.set_title(title, pad=12)\n", + " ax.axis(\"off\")\n", + "\n", + "def make_model(kind: str) -> GraphKoopmanModel:\n", + " return GraphKoopmanModel(\n", + " encoder=GNNEncoder(IN_CHANNELS, 16, LATENT_DIM, num_layers=2),\n", + " decoder=GNNDecoder(LATENT_DIM, 16, IN_CHANNELS, num_layers=2),\n", + " latent_dim=LATENT_DIM,\n", + " time_step=0.1,\n", + " koopman=kind,\n", + " koopman_parameterization=PARAM,\n", + " koopman_max_spectral_radius=MAX_RHO,\n", + " )\n", + "\n", + "def mean_rmse(preds, target_snaps) -> float:\n", + " errors = [\n", + " (pred.x - target.x).pow(2).mean().sqrt()\n", + " for pred, target in zip(preds, target_snaps, strict=True)\n", + " ]\n", + " return float(torch.stack(errors).mean())\n", + "\n", + "def field_matrix(snaps) -> np.ndarray:\n", + " \"\"\"Stack node values for one feature into shape (num_nodes, time).\"\"\"\n", + " return torch.stack([snap.x[:, FEATURE] for snap in snaps], dim=1).detach().numpy()\n", + "\n", + "@torch.no_grad()\n", + "def latent_gap_curve(model: GraphKoopmanModel) -> np.ndarray:\n", + " \"\"\"Per-step mean |z_path - z_ring| under fixed-topology latent rollouts.\"\"\"\n", + " z_path = model.encode(origin)\n", + " z_ring = z_path.clone()\n", + " gaps = []\n", + " for _ in range(horizon):\n", + " z_path = model.koopman.advance(z_path, edge_index=path_edge_index)\n", + " z_ring = model.koopman.advance(z_ring, edge_index=ring_edge_index)\n", + " gaps.append(float((z_path - z_ring).abs().mean().detach()))\n", + " return np.asarray(gaps)\n", + "\n", + "# Set distance: for each path eigenvalue, nearest ring eigenvalue (and vice versa).\n", + "def _eigset_hausdorff(a: np.ndarray, b: np.ndarray) -> float:\n", + " d_ab = np.max([np.min(np.abs(a_i - b)) for a_i in a])\n", + " d_ba = np.max([np.min(np.abs(b_j - a)) for b_j in b])\n", + " return float(max(d_ab, d_ba))\n" ] - }, - "metadata": {}, - "output_type": "display_data" }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "markdown", + "id": "18-3", + "metadata": {}, + "source": [ + "## Path and ring topologies\n", + "\n", + "Confirm the shared setup from the first code cell: path training sequence,\n", + "mid-horizon ring rewire, and evaluation fields.\n" ] - }, - "metadata": {}, - "output_type": "display_data" }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "code", + "execution_count": 3, + "id": "18-4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-21T02:11:06.259602Z", + "iopub.status.busy": "2026-07-21T02:11:06.259538Z", + "iopub.status.idle": "2026-07-21T02:11:06.261450Z", + "shell.execute_reply": "2026-07-21T02:11:06.260990Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sequence length=30, origin t=14, forecast horizon=15, train topology=path, shock=ring\n", + "operator parameterization=schur, max_spectral_radius=0.7, epochs=40\n" + ] + } + ], + "source": [ + "print(\n", + " f\"sequence length={len(seq)}, origin t={SPLIT - 1}, \"\n", + " f\"forecast horizon={horizon}, train topology=path, shock=ring\"\n", + ")\n", + "print(f\"operator parameterization={PARAM}, max_spectral_radius={MAX_RHO}, epochs={EPOCHS}\")\n" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hold_fields = {\n", - " \"Truth (path targets)\": truth_field,\n", - " \"pernode · hold path\": field_matrix(predictions[\"pernode\"][\"hold\"]),\n", - " \"graph · hold path\": field_matrix(predictions[\"graph\"][\"hold\"]),\n", - "}\n", - "vmax = max(float(np.abs(field).max()) for field in hold_fields.values())\n", - "vmax = max(vmax, 1e-3)\n", - "\n", - "fig, axes = plt.subplots(1, 3, figsize=(11.5, 3.4), constrained_layout=True)\n", - "for ax, (title, field) in zip(axes, hold_fields.items(), strict=True):\n", - " im = ax.imshow(\n", - " field,\n", - " aspect=\"auto\",\n", - " origin=\"lower\",\n", - " cmap=\"viridis\",\n", - " vmin=-vmax,\n", - " vmax=vmax,\n", - " )\n", - " ax.set_title(title)\n", - " ax.set_xlabel(\"forecast lead\")\n", - " ax.set_ylabel(\"node\")\n", - " fig.colorbar(im, ax=ax, fraction=0.046)\n", - "fig.suptitle(\n", - " f\"Feature {FEATURE}: hold-path fields from t={SPLIT - 1} \"\n", - " \"(sanity check — expect damping, not perfect tracking)\",\n", - " y=1.05,\n", - ")\n", - "plt.show()\n", - "\n", - "diff_pernode = np.abs(\n", - " field_matrix(predictions[\"pernode\"][\"ring\"])\n", - " - field_matrix(predictions[\"pernode\"][\"hold\"])\n", - ")\n", - "diff_graph = np.abs(\n", - " field_matrix(predictions[\"graph\"][\"ring\"])\n", - " - field_matrix(predictions[\"graph\"][\"hold\"])\n", - ")\n", - "dmax = max(float(diff_pernode.max()), float(diff_graph.max()), 1e-3)\n", - "\n", - "fig, axes = plt.subplots(1, 2, figsize=(9.5, 3.4), constrained_layout=True)\n", - "im0 = axes[0].imshow(diff_pernode, aspect=\"auto\", origin=\"lower\", cmap=\"magma\", vmin=0.0, vmax=dmax)\n", - "axes[0].set_title(r\"pernode $|\\mathrm{ring}-\\mathrm{hold}|$ (decode-only)\")\n", - "axes[0].set_xlabel(\"forecast lead\")\n", - "axes[0].set_ylabel(\"node\")\n", - "fig.colorbar(im0, ax=axes[0], fraction=0.046)\n", - "\n", - "im1 = axes[1].imshow(diff_graph, aspect=\"auto\", origin=\"lower\", cmap=\"magma\", vmin=0.0, vmax=dmax)\n", - "axes[1].set_title(r\"graph $|\\mathrm{ring}-\\mathrm{hold}|$ (decode + linear)\")\n", - "axes[1].set_xlabel(\"forecast lead\")\n", - "axes[1].set_ylabel(\"node\")\n", - "fig.colorbar(im1, ax=axes[1], fraction=0.046)\n", - "fig.suptitle(\"Physical topology-policy differences (often decode-dominated)\", y=1.05)\n", - "plt.show()\n", - "\n", - "lead = np.arange(1, horizon + 1)\n", - "fig, ax = plt.subplots(figsize=(8.0, 3.4), constrained_layout=True)\n", - "ax.plot(lead, truth_field[NODE_ID], color=\"0.2\", linewidth=2.2, label=\"truth\")\n", - "ax.plot(\n", - " lead,\n", - " field_matrix(predictions[\"pernode\"][\"hold\"])[NODE_ID],\n", - " marker=\"o\",\n", - " markersize=3,\n", - " color=\"#4C78A8\",\n", - " label=\"pernode hold\",\n", - ")\n", - "ax.plot(\n", - " lead,\n", - " field_matrix(predictions[\"graph\"][\"hold\"])[NODE_ID],\n", - " marker=\"s\",\n", - " markersize=3,\n", - " color=\"#F58518\",\n", - " label=\"graph hold\",\n", - ")\n", - "ax.set_xlabel(\"forecast lead\")\n", - "ax.set_ylabel(f\"node {NODE_ID}, feature {FEATURE}\")\n", - "ax.set_title(\"Single-node hold-path rollout (coarse fidelity; not the coupling test)\")\n", - "ax.legend(frameon=False)\n", - "plt.show()\n" - ] - }, - { - "cell_type": "markdown", - "id": "18-16", - "metadata": {}, - "source": [ - "### Effective spectrum of `GraphKoopmanOperator`\n", - "\n", - "Eigenvalues of `I ⊗ K_self + Â ⊗ K_nbr`. Path and ring spectra are often nearly\n", - "coincident when `K_nbr` is modest, so the overlay uses open ring markers with\n", - "filled path markers plus a zoom inset. The **sorted-magnitude difference** is the\n", - "honest quantitative visual; latent `|Δz|` remains the decisive coupling check.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "18-17", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-21T02:11:09.260957Z", - "iopub.status.busy": "2026-07-21T02:11:09.260678Z", - "iopub.status.idle": "2026-07-21T02:11:09.439406Z", - "shell.execute_reply": "2026-07-21T02:11:09.438960Z" - } - }, - "outputs": [ + }, + { + "cell_type": "markdown", + "id": "18-5", + "metadata": {}, + "source": [ + "### Visualize the topology shock\n", + "\n", + "Path (training / hold-last) vs ring (known future). The adjacency heatmaps show how\n", + "normalized coupling `Â` changes when the contacts close into a loop — including\n", + "renormalization of the old endpoint edges.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "18-6", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-21T02:11:06.262233Z", + "iopub.status.busy": "2026-07-21T02:11:06.262162Z", + "iopub.status.idle": "2026-07-21T02:11:06.553632Z", + "shell.execute_reply": "2026-07-21T02:11:06.553273Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6IAAAMVCAYAAABtN0lKAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAsZxJREFUeJzs3Qd8U2X3wPGTlkJLadmbMgRliAoKCAKKIqKI4sKFAyfurYgLNzgQ90bxdfOqKCoqDkRR2S72kFH2pi3QAm3+n/P4v3nT0jbJbXIz7u/r51qa5OaOpHly7nOe83i8Xq9XAAAAAABwSJJTGwIAAAAAQBGIAgAAAAAcRSAKAAAAAHAUgSgAAAAAwFEEogAAAAAARxGIAgAAAAAcRSAKAAAAAHAUgSgAAAAAwFGVnN0c4tXkyZNl2bJl5T6mbdu20r1795Cf+++//zbL+eefL+Gya9cuee+99+Tcc8+VatWq7Xf/nDlzzPEMHDiwwtsKZv/37dsnY8eOlb59+0pWVlaFnisRhfP1AIBY98UXX0hKSoppE/z9+uuvMn/+fDn++OOlefPmEs82bNggv/zyi2zbtk169+4d98cTyI4dO+S///2vnHbaaVKnTp1o7w4QF+gRRVCWLFki06ZN8y333HOPPPDAA8VuW758ua2z+c0338gtt9wS1lfiyy+/lPvuu0/S09NLvX/ChAkybNiwsGwrmP3Pz8+XK664Qv78888KP1eo/vrrL3n//fclFpS1L+F8PQAg1o0cOVJGjx5d7LZx48ZJr1695Pfff5dmzZpJPJs7d660bNlSxowZI7/99pts2bIl6HU/+ugjmT17tsSbdevWmXZ+xYoV0d4VIG7QI4qgXHnllWax9OjRw/Q0vv766xU+g4ceeqgMGjQorK/E+PHjzVVJj8cjbjdx4kR5/vnn5bzzzov2rsTUvgBArHjzzTdNEHP77bfLiBEjJN598MEH0qpVK3NROFR6ofuss86SI444QuJJjRo15LLLLpO6detGe1eAuEEgirCmVmrwN2XKFFm9erUce+yxJiVV03pV5cqVTWpO165dzb8tDRs2LNbgWM91xhlnyIwZM8zVxRYtWpj1grFnzx4T8GiKTCCFhYVBbUMfs2jRIsnMzJRjjjnGNDiBnvfHH3+UNWvWmKvChx12mNih5yHQ+VN6vmfOnClFRUXSqVMn39V0TfPV2zVV2bpooPujr83u3bvl3XfflW7dusnBBx9c5j5Yr8eAAQPMc+m5OvDAA6VLly4h7Wt5++J/3uy85gAQr5577jm58cYb5eGHH5a77rqr2H0ffvihtG7dWpo0aSKzZs2SvLw8OfLII0sd4qH3afurvY8HHHCAGSpjXYydPn266bHTNtryn//8xwRNJ510ku+2N954w7Rx+tkcyrb9adbL1KlTTRujn/WVKlWSwYMHy1tvvWU+0/U5LfPmzTOZQtZwlE8++cSkuP7xxx++duLEE080+xDM+v7nrEGDBiY1WNucCy+80Ny3detW+fnnnyU3N1c6dOgg7du3L7bvn332mWmz/M9JSZs3b5ZPP/3UDCXRTDDt/dX27pBDDjH7Z2Vi+T9u/fr1JiMoIyNDjj76aKlatep+z6vHoY+pVauWaRe1PdXvGnaGPAHxgkAUYaGplS+88IJJN9JgTRtB/ZDXlFRN21X6b23MNFj66quvTENnpaM++eSTvobEeq4nnnjCPFft2rXN40855RQTOAXy/fffm8ZXU5zKo42dBmHlbUMbsFNPPdWkSmnDoAGSNmj6GH1sabSBO+GEE0wDpQ3OwoULpX79+mLHpk2bAp6/F1980VxF1y8P2shpiusFF1xgUpP1i0d2drYUFBT4nkfX12PR49cr8JoeVl4gar0ejzzyiFSvXl1q1qwp3377rblQ8Pbbbwe9r+XtS7CvBwAkEu39vPvuu00weu211+53/9ChQ6Vx48YmkDn88MPN56y2QZrG698GaeB3+umnmwu7bdq0kZ9++skEjPo5quMVtR265pprTCBWpUoV0z5dfPHF5r6NGzeaNlODIO3R0+AulG2XpO2ljg/Nyckxn/U6FlYDUT2+p59+ulggqW2Jfm+w2n8NxjSA1Yu4Vjuh7YIGosGsb+13o0aNzHN07tzZ/Fv3WwNbDfg1+NRzc91115nb9dxbHnroIRP8lReI6vcAbTv1POhFYL34q2Ng9Vzq7frdR/9tPU5TjXVfNFDVC61er9dcGPAfR3rTTTfJyy+/LH369DEX02+++WZzIV+/SxCIIqF5ARu6d+/u7du3r+/34cOHe/Xt9Oqrr5a7XmFhoXfAgAHes846y3fbE0884a1fv/5+z/Xhhx/6bvvpp5/MbbNnzw64b1dccYX3ggsuKPcxwW7jrrvu8tauXdu7atUq321XX321t06dOt6tW7eWuv/Dhg3zNmrUyLthwwbfMZ955pnmuT///PNy96vkcwVz/ho0aOB9+umniz3mq6++8v0+YsQIb+PGjfd7rh07dngvu+wy77fffhvUuXr44Yd9t82aNcubnJxc7PwFs69l7UtFX3MAiLc2NC0tzXzGPfvss2U+rlmzZt6srCzvpk2bfLddeuml3kMOOcT3e35+vveAAw7wnnvuueZzV23cuNHbtGlT81i1Zs0as60ffvjB/P7yyy97Dz/8cG+1atV8n7FPPvmkabtC2XZZhgwZ4j3mmGOK3Zaenu597bXXit02evTo/dq81q1be+++++79njPY9XW/tY1eu3at77bp06d7k5KSvPfee6/vtvnz53urVKni/eabb3y3PfTQQ95Ro0aVe2wzZ8405/KMM87w7tu3z3f7ggULzO16v//jLrroIt/rsnPnTm/Dhg29DzzwgG+9KVOmmMf5t8Vjx441t+l5BBIZxYoQNpqOcvnll+93u17d/OGHH+Sdd94xaT/aa6dXA8ujqSlnn32273e9IpicnCyLFy8udz3tYdMePL0yHEgw29AUI71q7J+KpONXNOXmu+++K/V5dZ1LL71U6tWrZ35PSkoyV2j9aYqTXp21Fk1HKkug86e9lJryqpUJre1pKlMg2vOo29bqjIFoatWtt97q+11TqXU9HQcUyr5G4jUHgHjUtGlT0yumKafbt28v83Ga2unfe6aZNv6fi/oZ+88//5i0Xv38V5pyO2TIEJOmqrRXsF27dr52S3sSTz75ZJNJo/+2bivZHgTadqzS/dbeYYtWrdc2T9tv/0r/mqr82muv+W7T+4MtGKg9tNpGBXLVVVf5XhdNydX20/8cas9qx44di537iy66qNj+A4mK1FyEjaafliwOpGMctEHQRlA/9DUwWbVqlUnxKY+mf/rTD3ENhjTlszw6HkTTgYIJxAJtQ9NndF91rKI/PRZNbSqtMp6uo+mnJcvUl3wO//RUpelPmupaUjDnT6ep0SBRGy1NsdXG7PrrrzepTOGiY21SU1OL3abHqGlGoexrJF5zAIhH+hmqQchxxx1nUjA1ENQLi4E+G7X90TbEYrVFJdsZHSKzc+dO8xmsgammfeo2NP1ULxhqmqoOg/j8889NaqiOndT00FC2HatKBnF6jvRip46LLTmUZu3atWHZRllKO4f+7Zq2kyWrJOt3Kb1QASQ6AlGETWkVavXKovZO+l9x1PEcwfaS2amWqw16aYUA7ByP9mqWDKS04dKGWIOz0tbRBr/kOiV/18Y/mIrDwZw/HbujQaD2suocdDreVsfFLF26tMzpa0KlxS80yPZ/jbVX2P8cOP1aA0C806rx2kupYwytYFR77kJhfQ5rO+M/b7b+roV3NABTGojqeMhJkyaZ8YdaWEfbIs3Y0X3QmgjBZMjYpb2HWpDOn24zEuuX/D6iwWDJC8BWMKljN+0IV1V+/Z6hxRBL0jYWSHSk5iKi9IPU/yrt3r17TQ9epGiFumDScoNlpZ9q8QCLplFp465T2JRGv1DoOtrQ+68TifOn27Dmb9UvIPpFRq92a3EJ7ZlV+qWmtMbaqmhoFaYojz72448/LvYFR4tM6bEGu6/l7QsAuJUWt9FAUOfr7tu3r7nYGQotlqM9qf7tjAZsOkRCi/ZZ6aPWv7U4kv5biwhpuq6m3g4fPtxk1EQyHVR7+ObPn+/7XS9uajGlkspqJ4JdvzT6vUDbMS265z8s5tVXXy02NZ1WzQ32OcNFe8T1gq1/lpVmG2kleiDR0SOKiNL5QbVXTNNQtHHR8ZNaTS8StFKfBl/lVfOzU9FQy9Vr0HnOOeeYhkJTl7TMfsk0KIvepz2SWg1WGz8N9KwxOOE+f/plQ6v76RcZ/TKiDbN+GdH9Peigg3xjLXX8kfZY6pcOa8qUYKvmWkHuDTfcYMai6tV1naRcj9+/ymMwr3VZ+wIAbqZjBDUY1YufOrREL/T5926WRz+T9XNcP8+1Oqt+tmpApVkxWk3XohkyWoFWK+pecsklvtt1m9puaHpuJGl7oenAGgDrcBRNCV65cuV+j+vZs6cZ26qBp54Da/qWYNcvjc5LqplDOj5Tq8rr82lKrAad+rw6jjPYqrnhdu6558orr7xixt/qfuiFbw2StbeaudCR6AhEYYsGezrOwT891L/X0D+Q0w9+HbupqaM6tYiOJfXvKdPUJA1iAj2XNpxWcFVWWq5+kFtpSOUJdhva2OkcYTquRMvfa4Cl84P6l1Mvuf867kdL0Guwpl8E9EvBY489JnfeeWfAMR8lnyvQ+dPXQPdPix1pkKiNlhZb0PGmVnEEncNU91nnVtWrrtaUKZq+rKX6S86jVhrdpo4p0vFMGoxrw63r+o8bDea1Lmtf7L7mAJAIbajSz0FNm9WLnTrlh055okGKBqn+9AKefv6W/KzUC5LaFmjPav/+/U0wV3LqML2gqPNA6/3+6+p4fP8pUFSw2y6NXgy1phizaJClFzA14NbhHtozW1qvpvZa6hQ02rbpGFdr+pZg1y9tv5VOQ6bTtWj7o+25Ppdm+vi3MVq8KNDQHh1+o+eg5Hzi+rverveX97iS6c/aVuvrrgWV9LuDfofRYzzzzDNLHTMMJBKPls6N9k4A4aDBngZVWgkQ4XP//febFC8NqgEAQHjpPNv+adGaSaUXbjVQHjBgAKcbCYseUSSMklOkAAAAxDrNmNIMIR1iozUedOyqpiT791wDiYhAFEC5ykqbBQAAFadDeTQde9asWZKWliZvvvmmnHrqqZxaJDxScwEAAAAAjmL6FgAAAACAowhEAQAAAACOIhAFAAAAADiKQBQAAAAA4CgCUQAAAACAowhEAQAAAACOIhAFAAAAADiKQBQAAAAA4CgCUQAAAACAowhEAQAAAACOIhAFAAAAADiKQBQAAAAA4CgCUQAAAACAowhEAQAAAACOIhAFAAAAADiKQBQAAAAA4CgCUQAAAACAowhEAQAAAACOIhAFAAAAADiKQBQAAAAA4CgCUQAAAACAowhEAQAAAACOIhAFAAAAADiKQBQAAAAA4CgCUQAAAACAowhEAQAAAACOIhAFAAAAADiKQBQAAAAA4CgCUQAAAACAowhEAQAAAACOIhAFAAAAADiKQBQAAAAA4CgCUQAAAACAowhEAQAAAACOIhAFAAAAADiKQBQAAAAA4CgCUQAAAACAowhEAQAAAACOIhAFAAAAADiKQBQAAAAA4CgCUQAAAACAowhEAQAAAACOIhAFAAAAADiKQBQAAAAA4CgCUQAAAACAowhEAQAAAACOIhAFAAAAADiKQBQAAAAA4CgCUQAAAACAowhEAQAAAACOIhAFAAAAADiKQBQAAAAA4CgCUQAAAACAowhEAQAAAACOIhAFAAAAADiKQBQAAAAA4KhKzm4OAAAA+J+iIq/k7d4jRV6vJHk8Ui2tsiQleThFQIIjEAUAAIDjCouKZFf+Xpk+f61MnL5UduTlS/VqqdLvyFZyZLtGkp5KQAokMo/X6/VGeycAAADgriB047ZdMvSV72Vbbv5+99fMSJXHhvSW+jXT6R0FEhRjRAEAAOAo7QktKwhVervevzN/D68MkKAIRAEAAODomFBNxy0rCLXo/TMWrDWPB5B4CEQBAADgGC1MpGNCg/HltKWSu7sg4vsEwHkEogAAAHCElibZs3evKUwUjJydBSJ0iAIJiaq5AAAAiJjc3FxZuXKlWVatWiXdj+ltquNu3L4r4LqZ6VVk46aNsmzxZmnWrJnUqlVLPB6mdgESAYEoAAAAwqagoEBWr17tCz63bt1a7P7N69fICZ2ay5LVxW8vzfEds2TB33/IkiVLzO/VqlUzAakuTZs2lfT0dF45IE4RiAIAAMC2wsJCWb9+vS/wXLdunUnBtVStWtUXOOrPjIwMyd1VIO99P7/cgkW1MlKlx2HNZcPaZPMc+tzbt2+XefPmmUXVqVPHF5g2adJEUlJSeCWBOME8ogAAAAiaBpnay2kFntr7uWfP/6ZZqVSpkgkKrQBRg8WS6bSB5hHVIHRkKfOI7tixo1iab37+/9ZNSkqSRo0a+bZbv359cxuA2EQgCgAAgHLt3LnTBH5WEJiXl/e/L5Mejwn6rACwYcOGJhgNRKdl0XlCpy9YKxOnLTWFiXRM6MldW0mXto0kPbVysSC0tIB448aNvn1as2aN6Z21VKlSxfTCWj2xNWrUYHwpEEMIRAEAAFDM3r17i43z3Lx5c7H7NaizAs+srCxJTU21fQY1IDVTtGg2r0ckI61KuQFoefu8du1a3z5rkOovMzOz2D5rui+A6CEQBQAAcLmioiLZsGGDL+VVAzr/3kUNNK2eRV2qV68usW7Xrl3FenG1eq+/evXq+Y6ncePGQfXiAggfAlEAAACX0bRWLfxjBWr6U6vdWpKTk01wZgVqGrTF87Qp1vFaQWl2dnax49Ug1H98abwfLxAPCEQBAABinKav5u3eI0VeryR5PFItrfzxk6XZvXt3sR7CnJycYvdr8GX1emoQmsgVaP17gHXRHmC9zZKWluYbX9q8eXOT1huN1wxIZASiAAAAMUqry+7K3yvT56+VidOXyo68fKleLVX6HdlKjmxXfkGfffv2mQI+ZY2Z1GlU/OfkdPOYSa36q2NirUC95JjYmjVr+oL0QGNiK/KaAW5CIAoAABCDAk1xUjMjVR7zm+LEv4qsBlQahGow6l9FVoMoK/ikimzZtCqwnkMrMC1ZJbhBgwa+AF5TejWV2c5rBrgZgSgAAEAMyt1VINc+/XWpAY1/YPPMdcfLrz//aAImTb8tbV5NDZg0eGJezYrPm6rjS7VCr//4UivAb9W6nVz/7KSAr9kLN50oGVWr2NgbIHFQHgwAACDG6PhCTe0sL6BRev9vc7NNhVsNQuvUqeNLIW3SpIlUrlzZsX1OVNoDWrt2bbMcfvjh5lyvW7fO1/Os/16+fLlUqpQiGwrSg3rNZixYK8d2bE6vKFyNHlEAAIAYk7OzQO4f+5MsWb014GMPbFJLbjvrcMlMryLVqlVzZP/wP1p9V3tJk6uky3MT5gb9mg0f3FOqp9uffxWId/SIAgAAxBittKpFboINWtPT06VaNYKaaNCxt61atZLtefkhvWbijfiuATEtKdo7AAAAgOJ0ug+ttBoM7QkV6t5EHa8ZEBoCUQAAgBijc07qdB/BOLlrK8lIo/BNtPGaAaEhEAUAAIgxOrXH4QfWNRVWy1MrI1W6tG1E0ZsYec10ntBgXrPOvGYAgSgAAECsmTlzpvzw7dfy4ODuZQY2GtCMHNJb0lOpjBsrqqammHlCy3vNHhjcXRb8/YcUFRU5vn9ALKFqLgAAQIwFoT/99JOZ8/Oss86SGrXryfQFa2XitKWmyI2OCdV0XO0J1SBUe+IQW1Pv7MzfU+pr1ql1A5nyw7eyZMkSadOmjZx00knM7QrXIhAFAACIwSD05JNPloMOOsgX3OTu/v9Kqx4xY0IJQGNbWa/Zpk2bZNy4cZKfn08wClcjEAUAAIjhIBSJh2AUYIwoAABA1BGEukvdunXl7LPPltTUVFm4cKF89dVXjBmF61A1FwAAIIoIQt2JYBRuRyAKAAAQJQSh7kYwCjcjEAUAAIgCglAoglG4FYEoAACAwwhC4Y9gFG5EIAoAAOAgglCUhmAUbkMgCgAA4BCCUJSHYBRuQiAKAADgAIJQBINgFG5BIAoAABBhBKEIBcEo3IBAFAAAIIIIQmEHwSgSHYEoAABAhBCEoiIIRpHICEQBAAAigCAU4UAwikRFIAoAABBmBKHB+e2336Rbt26Smpoq7dq1k88//5z3YikIRpGICEQBAADCiCA0eB999JG88MILkpubK/fdd58MGjRIioqKeD+WgmAUiYZAFAAAIEwIQkMzatQo6dChg+zbt88EoI0aNZKkJL6eloVgFImEv3QAAIAwIAi157zzzpP09HS59tprZcyYMbwXAyAYRaLweL1eb7R3AgAAIJ4RhFbMnj17TJruTTfdJMuWLZOMjIwwvTKJa9OmTTJu3DjJz8+XNm3ayEknnURvMuIKPaIAAAAVQBBacZUrV5bzzz9fPB6PCUQRGD2jiHcEogAAADYRhNq3c+dOGTJkiAk8t2/fLi+99JIUFhbKQQcdxPsxSASjiGcEogAAADYQhFaMjgvt2bOn9O/fX1q0aGHSTL/88kupWrUq78cQEIwiXjFGFAAAIEQEoYg1jBlFvKFHFAAAwKVB6LBhw6R9+/bidjk5OXL33XfLUUcdJWeccYZMnz5d4g09o4g3BKIAAAAuDEJ/+OEH+euvv2TevHnidjfeeKOp1Kvzmmow2qdPH9mwYYPEG4JRxBNScwEAAFwWhObm5krfvn3lrbfeMsfh9tn8dPoYrdxrOfDAA+WNN94wY1jjEWm6iAf0iAIAALgoCFW33XabScutWbNmtHclJvgHoXPnzjWBeocOHSRe0TOKeEAgCgAA4KIgdNKkSZKfny+nnHJKtHcl5qxcuVIGDhwo7733nknVjWcEo4h1pOYCAACISFGRV/J275Eir1eSPB6pllZZ5syZLVOmTEmYIFSdeuqpptdPp0nReTsXLlwoBx98sHz11VeSlZUlbrVkyRIzlcwLL7wgxx9/vCSK0tJ0RTz7vdeTkjzR3lW4DIEoAABwtcKiItmVv1emz18rE6cvlR15+VK9Wqr07dRCOrSsLVOnTJZDDmmfEEGoWrVqlakSq7Zv327GQf7999/m+PxTVN1kwYIFJgh99dVXpXfv3pJorGC0fv360qt3X/lj2SaZOH2Z773e78hWcmS7RpKeSkAK5xCIAgAAVwehG7ftkqGvfC/bcvP3u79mRqqMuLyXNKyTmZA9Rps3bzYpnG4vVqQ9oLNnz5bGjRv7bhs9erSpnpsotm3bLjt275P7xv5S5nv9sSG9pX7N9IR8ryP2EIgCAADXyt1VINc+/XWpX8z9v6C/cNOJklG1iiQaTc3V3kC3zyW6fPly2blzZ7HbmjZtKpmZmZIo3P5eR+ypFO0dAAAAiNaYUE3HLe+LudL7ZyxYK8d2bJ5wPUXJycmuD0JVixYtJJHxXkcsomouAABwJS3WomNCg/HltKWSu7sg4vsERALvdcQiAlEAAOBKWjFUi7UEI2dngYi7h1EijvFeRywiEAUAAK6k01ZoxdBgZKZX0RkvgLjEex2xiEAUAAC4ks6dqNNWBOPkrq0kI40CLohPvNcRiwhEAQCAK2nhIZ07USuFlqdWRqp0adso4QoVwT14ryMWEYgCAADXqpqaYuZOLCsY1SB05JDekp5a2fF9A8KJ9zpiDfOIAgAAV9OpLbZsz5GZC9fJd79nm8JEOiZU03G1J1SDUHpDkSjv9Z35e2T6grUycdpS33u9z+FZ0v3QFiaFl/c6nEIgCgAAXC0/P19efvllOfDAg6THMcf9e6NHzJhQvpQjUQNSMx2RV2T9+vWyaP5f0rFjR8nKyor2rsFFKkV7BwAAAKIpOztbCgsLZc+egqCr6ALxTC+wVE//970+b+NaWbJkidSqVYtAFI5ijCgAAHC1lStXmp/NmjWL9q4AjrPe99bfAeAUAlEAAOBqq1atMj8JROFGDRo0kMqVK8uGDRtMmjrgFAJRAADgWjk5ObJt2zapVq2aSU0E3CY5Odmk5Hq9XpOmDjiFQBQAALiWlY7YtGlT8XiYJxTupO9/RXounEQgCgAAXIvxoQDjRBEdBKIAAMCVNBWR8aGAmLR0TU/fvn277Nixg1MCRzB9CwAAcKWNGzfK7t27pU6dOpKeni6xYPny5XLzzTcXu+3tt9+WjIyMqO0TwmPx4sVyxx13mH+3atVKnnzyyZg5tZqWrsW65s2bZ7IEDj300GjvElyAQBQAALhSLKblam/Un3/+KaNHj/bdVqVKlajuE8Kjbt26MnjwYPn999/lyy+/jLnTSiAKpxGIAgAAcXuholhSvXp1Oe2006K9GwizmjVrmtc1NTU1JgNR6+9A09U1bZ3iXYg0xogCAADX2bt3r6xZs0aSkpLM1BWxZN26dTJo0CC59tprZdq0adHeHbiEpqdrr63OJapp60CkEYgCAADXWbt2rRQWFkqjRo0kJSVFYkWLFi3klVdekTPOOEPq168vJ5xwgvz444/R3i24BNO4wEmk5gIAANeJxfGhJdNyzzzzTNm3b5+MGzdOevXqFe1dgwvo38Ps2bPN30eXLl2ivTtIcPSIAgAA14nVQNSfjtPTKqY6tQbghCZNmkhycrJJW9f0dSCS6BEFAACusmvXLjMGTqvRavprLNGpWj7++GMpKiqS+fPnm7kdNVUX8W/nzp1m7K++95YtW2Z6vk855RS57LLLJFZomrqmq2dnZ5tgtHnz5tHeJSQwAlEAAOAq+iVbaZEiLVYUS4444ggzZ6j2SmnvVIcOHahemiAqV65spm/x17JlS4k1miWgfyNaPZdAFJFEIAoAAFwlltNy27VrZxYkHu1tjIdpeShYBKfE1mVAAACACI+7jOVAFIg2TVfXtHVNIdY0diBSCEQBAIBrbN++XXJyciQzM1Nq1KgR7d0BYo6mq1u9opqeC0QKgSgAAHANqzdUv2h7PJ5o7w4Qk6xsAevvBYgEAlEAAOAaVg8PablAcONENZ0diAQCUQAA4Ao6JYoViFpftAHsT9PWNX09NzfXpLMDkUAgCgAAXGHDhg1SUFAg9erVk6pVq0Z7d4CYpWnrpOci0ghEAQCAK1AtFwgegSgijUAUAAC4rlARgPJlZWWZn9nZ2SatHQg3AlEAAJDw9u7dK2vXrpXk5GRp3LhxtHcHiHmavq5p7JrOrmntQLgRiAIAgIS3evVq06ujQWhKSkq0dweIC6TnIpIIRAEAQMJjfCgQOgJRRBKBKAAASHgEokDoNIOgUqVKJq19z549nEKEFYEoAABIaDt37pTNmzdLamqqGfMGIDgahGowqmntmt4OhBOBKAAASGirVq3yVcvV+REBBM+qMm39HQHhQiAKAAASGmm5gH2ME0WkEIgCAICE5fV6CUSBCtB09rS0NJPermnuQLgQiAIAgIS1detWycvLkxo1akj16tWjvTtA3NF0dis918ouAMKBQBQAACQs0nKBiiM9F5FAIAoAABIWgSgQvkBUCxZpujsQDgSiAAAgIRUWFpopJzS1MCsrK9q7A8StzMxMqVmzpklz13R3IBwIRAEAQEJav3697NmzR+rXr2/mEAVgH+NEEW4EogAAICGRlguED+NEEW4EogAAICERiALho+ntmuaenZ1t0t6BiiIQBQAACaegoEDWrVsnlSpVkoYNG0Z7d4C4p+ntDRo0kL1795q/LaCiKkkcKSrySt7uPVLk9UqSxyPV0ipLUpIn4bft9u27+dijvX2O3Z2veyxsH6joe3d3fr4cf2J/2ZWz1QSjsWTu3LmycOFC2bdvn/Tt29cUgQH8zZgxwwR7Rx11lNStWzdmTk7z5s2lWrUMKfKkyPa8fNoHVEhsfTKXobCoSHbl75Xp89fKxOlLZUdevlSvlir9jmwlR7ZrJOmpkfuCFM1tu337bj72aG+fY3fn6x4L2wfC/d7t26mF5O4qiJn37iWXXCJfffWVdOvWTapUqSJdunQhEEUxV199tXz++efStm1bufTSS+WHH36Qww47LCb+xtod0lF+/XulPP3pX7QPqDCPN8YnA9I3/cZtu2ToK9/Lttz8/e6vmZEqjw3pLfVrpoe9gYnmtt2+fTcfe7S3z7G783WPhe0Dif7eHT9+vNx2220yc+ZMqVWrVtT2A7FryZIl0qlTJ1m6dKnpCR05cqR5v3z88cdR3a94+RtDfIn5MaJ6dbOsN73S2/X+nfl7Emrbbt++m4892tvn2N35usfC9oFEf+9++OGHcsUVV5hg4+uvv5bt27dHdX8Qe37++Wc5+uijfem4AwcOlClTpkR7t+LmbwzxJSnWx3loik1Zb3qL3j9jwVrz+ETYttu37+Zjj/b2OXZ3vu6xsH3ADe9dreL75Zdfyk033SSPP/64HHTQQTJv3ryo7Q9iz4YNG6RevXq+3/XfW7ZsMQWCoiWe/sYQX2J6jKgWG9BxHsH4ctpSqZe2V76fNDEs2+7dt59MnL4yKtt2+/bdfOzR3j7H7s7X3c72O7VpKNXTU8O2fcCp7wrRfO9mZmZK7dq15b333jO/33rrrTJq1Ch54403orI/iD3Vq1eXvLw83+/676pVq0pKSkrU9ime/sYQX2K7R9TrNQOhg5Gzs0AqV6kStm1XqZIatW27fftuPvZob59jd+frbmf7wgVvxOl3hWi+d9u3by+NGzcuNi+jf9ABtGvXzlTMtUq4TJs2TQ4++OConph4+htDfInpHlGdMkAr3m3cvivgYzPTq0iDBvVNuks46B9StLbt9u27+dijvX2O3Z2vu53tC7UoEKffFaL53tVqqDodR506dSQtLU0effRReeWVV6K3Q4g5xxxzjOk5P//886VHjx6mWJEu0RRPf2OILzHdI6rz1umUAcE4uWsryUirkhDbdvv23Xzs0d4+x+7O1z0Wtg+44b3bqlUrM3XLqlWrzDyimqJ7+umnR21/EHs8Ho9MmjTJzNep1XKffPJJGTRoUFT3KZ7+xhBfYjoQ1fLPOm+dloQuT62MVOnStlFYy0VHc9tu376bjz3a2+fY3fm6x8L2Abe8d4844gh54YUX5MUXX5Tjjz8+qvuC2FS/fn0ZMWKEjB07Vs4555xo707c/Y0hfsR0IKqqpqaYeYnKevPrm37kkN5moupE2rbbt+/mY4/29jl2d77usbB9wC7eu0Bk8TeGSPB4rdHQMUzLQOu8RNMXrJWJ05aasUyag67d/3rlRb8URerqSzS37fbtu/nYo719jt2dr3ssbB8I93u3zxFNpcehzXnvAmH4G9u6I09mLFgj3/2eTfsAdwSi/n8Aubv/vxqXR0wOulNfiKK5bbdv383HHu3tc+zufN1jYftARd+7+u1mzerVsmzxfDn22GMlIyODkwpUgIYMr732mjRo0EB6HNNbkpOTaR+QuFVzS9IvQdGalyia23b79t187NHePsfuztc9FrYPhOO9+8uyRbJkyRJp2bJl1KfAAOLdli1bJDc3VypVqiS1qqdHe3eQAGJ+jCgAAIAdzZo1Mz9XrlzJCQQqyPo7sv6ugIoiEAUAAAmpadOm5qdOlxJHI5GAmEQginAjEAUAAAkpMzNTatasKTt37jRphQDsKSwslNWrV5t5TrOysjiNCAsCUQAAkLBIzwUqbt26dbJ3715TqKhKlSqcUoQFgSgAAEhYBKJAxZGWi0ggEAUAAAlL0wg1nTA7O9ukFwIIHYEoIoFAFAAAJCxNI2zYsKHs27dP1q5dG+3dAeJOQUGBrF+/XlJSUszfEhAuBKIAAMA11XMBhMaqOq3ZBcnJyZw+hA2BKAAASGiMEwXsIy0XkUIgCgAAEpqmE2paoaYX5ufnR3t3gLhiZRJYmQVAuBCIAgCAhKbphJpWqOmFWrQIQHBycnJk27ZtUq1aNalduzanDWFFIAoAABIe6bmA/bRc7Q3V6tNAOBGIAgAA1wSiFCwCgsf4UEQSgSgAAEh4tWrVMumFmmao6YYAyqep7IwPRSQRiAIAgISnaYVWsZUVK1ZEe3eAmLdp0ybZvXu3GRuqF3GAcCMQBQAArkB6LhA80nIRaQSiAADAdYGoph0CKBuBKCKNQBQAALhCenq61KlTx6Qbbty4Mdq7A8Ssffv2yZo1ayQpKUmaNGkS7d1BgiIQBQAArsE0LkBga9euNcFoo0aNpHLlypwyRASBKAAAcA2rYJGVdgig/PlDgUghEAUAAK6RlZVl0g017XDv3r3R3h0gJjE+FE4gEAUAAK6RkpJi0g0LCwtN+mGsGTlypJlqxn8ZPHhwtHcLNp144om+1/GLL74I+r5o0jHUGzZskCpVqkiDBg2ivTtIYASiAADAVWJ5nOidd95pKvpayyGHHCLnnXdetHcLNn399dfmdTzyyCNDui+atKq0f/YAECm8uwAAgKvEciDqb/r06bJ9+3bp06dPtHcFLmIFotbfCRApBKIAAMBV6tevb9IOdQqXXbt2Sax6/fXX5ZJLLqFXCo6iUBGcQiAKAABcRdMNNe1QZWdnSyzauXOn/Pe//zWBKOAU7YHfsWOHZGRkSM2aNTnxiCgCUQAA4Dqxnp77wQcfSOfOnaV58+bR3hW4tFquFlECIolAFAAAuDoQ1YIxsZiWe9lll0V7N+AyTNsCJ8VdIKolpfft2xeVVIXNmzebJRrbVwUFBVFtLPXcR9OePXvM+XfyHOg5t153XbZu3SrRoO+5LVu2yLZt26J27Lpouk403nc6zUI00+OckJOT4zvPZc1tmJubG5H3f1FRkW/bJd9j5d0HxLMaNWpIZmam+dvTNj6WzJ8/XxYvXiynn356tHcFFXTTTTeZnkUtPHXKKaeYf1vvt/Luiwb9vLdS1Zs2bRq1/YB7xE0gql9G9QNZGw5dRo0a5ej2ddtt2rQxBQ7++OMPR7f9zz//mA+o2rVrm5z922+/3dFgbMaMGdKpUyepW7eu2Ydnn31WouHCCy80+6ABmVN0fE6TJk3Ma69Lz549xUkaDF5++eVSrVo1Oeigg6Rv376OHrt13LroeKqLL77Yse3/+eefZtqCOnXqmOO/6KKLHJ18/umnnzafNfqe09L6VhXBSNFxYHqeGzZsKN9//32x++bNmydt27Y150J7cX799dewbnvNmjVm2wceeKA558HeB8Qz/dJvfdmOtfTcdu3ambZOCyohvmlb4j8djy7atgS6Lxq0eFd+fr5p96pWrRq1/YB7xE0g+sILL5gPZe2Rmj17tjz66KOyZMkSx7Y/efJk0yNgFTdw0jfffCNXXXWVuUqmX0jff/99+fzzzx3b/pQpU2Ts2LGSl5dnviDfcsst5lw4PVYmGudenXXWWb4eIT3/TnrwwQdl0aJFJgjS979eFHDKBRdcUKw3tGPHjuY2pzzwwAPSr18/877TSeenTZtm5lxzwty5c8329Sq1VtTUC0F6ASiSPv74Y3OeDzvssP3uu/baa+Xcc881F+R0vzRdL5wXo/RvS7etn3Oh3AckSnpupC80AfGAtFw4LW4C0fHjx8v1118v6enp0rp1aznttNPMFzc3uPrqq+Xkk0+WSpUqmUZTeyWcTJHTL+AtWrSQDRs2mN7ZRo0amR4qp+h2n3vuOXnooYckWjQYiobnn39ennrqKdMTHs20bE0TW7p0qZx66qmObVPf5xqAapqQblvTk1u1auXIthcuXGi2r581auDAgfLJJ59EJUVY/9Z/+eUXcwFIK30OHjzY3Ob0RREgEVk9ohqIaloi4GYEonBa3ASimh6mwZBF/7169Wpxm1mzZpkvoP3793d0uyNGjDCpedojNnr0aElNTXVs29dcc408+eSTkpaWJk7T49Re4MaNG5t0mUceecSxba9bt870xr377rsmTUbHMmkmQLSKZmhqdOXKlR3b5s0332wCYA0Gu3btagIwTU91gvb+agr+F198Yb6g6sUA/ZK6fv16icZnn5WWb6UTahVNN37+AeGm6Yf16tUzwyD0oifgVjr0RS/+Jicnm+88gBPiJhDVPwz/3gjtHdEeQjf5+++/5fzzzzc9M/rF1EkPP/ywKeig6XmaFqg9o07QIKxWrVomCLbSgTU926mCUZqWqwGhFunRXilNEf/uu+8c2bYGHHqcevxapEZT0jUgnzNnjjhdJOrtt9+WSy+91NHt6njUPn36mGJB+hpoerZmRjihZcuW8uabb8rw4cPlmGOOkfbt25vbnbwAU9Znn1s//wC3TuMCOHXRU9saDUJTUlI46XBE3ASi2gOg6XIW/beb5tbSnlAtmPTee++ZwkFO8k8J1aIt+iV9wYIFjmxbxwVq8GEVzFHdunUzhWycdvDBB0uvXr0cS4nUq/R6tf7MM880QakWK9Lxg1pJ0UmffvqpSYnV43fSzJkzTUqspqPquTjuuOPM34FT9Lxr8L98+XLTK6uFypy+AKS0WJZeCNm0aZPvqrVeCHLT5x8QSbFasAhw0ooVK8xPquXCSXETiA4aNEgee+wx+euvv2TChAny1VdfyTnnnOPY9rVHSnvkND1PvxQ6WblVg7EBAwbIiy++aL586n44OZWKnmet0qkpiq+++qr5EnzEEUc4sm0dG+pfMEdp8R6ntm9NqaE9ch999JF53x111FGObFsDME2F1rRQ/YKkBaq0N1QnOHfDXHb6GmsauAaC+v7TgNjJizA6DlODv59++kmuu+46ueuuuyK6Pe35taaHst53SlNyNRX/jjvuMGNltZdWA+Nwj5fVzzQtiGZN16KfecHcB8Q77QHSzANNS3SyMjcQS6yCXVzkhKO8caKwsNB7xx13eJs2bept37699+OPP3Z0+1dccYW3du3avqVx48aObfvWW28ttm1dRo0a5dj2p06d6u3Vq5e3WbNm3r59+5rfo0WPfcuWLY5t7/zzzzfbbNiwobd79+6Ov++2bdvmveCCC8z7rXPnzt4JEyY4uv21a9eav7mcnByv01avXu09++yzzfvu4IMP9j722GOObl/Pd506dbxt2rTxPv74496ioqKIbm/o0KH7/Z3n5eX5XodTTz3V26hRI2/v3r29ixcvDvv29T3mv239zAvmPiARjBs3zvvkk096//nnn2jvCuA4bWv0/f/8889HvK0D/Hn0f86GvgAAALFDp8b6+eefTSaGDsEA3ESHW02cONEMAdLpygCnxE1qLgAAQCRQsAhuxrQtiBYCUQAA4GpaEE2rYusYaB2vDbiFJkYSiCJaqP8PAABcTSuTa69oUZFXcnbmy15vsiR5PFItrbIkJXmivXtA2Ol7PW/3HlOgq1vPY2XTumypXr06ZxqOYowoAABwtcKiIsnJ2y2/zc2W737Plh15+VK9Wqr0O7KVHNmukaSnEpAicd7ru/L3yvT5a2Xi9KW+9/oJnZpL90Oa8l6HowhEAQCAq7+Yb9y2S4a+8r1sy83f7/6aGany2JDeUr9mOr2jiGu81xFrGCMKAABcS3uHygpCld6u9+/M3+P4vgHhxHsdsYZAFAAAuHacnKYolhWEWvT+GQvWmscD8Yj3OmIRgSgAAHAlLdai4+SC8eW0pZK7uyDi+wREAu91xCICUQAA4EpFXq8p1hKMnJ0FIgnUIfrOO+/I0UcfLYceeqhceOGFsnr1anGb3r17S6tWrczyzz//FLtv1apVcuaZZ0r79u3lsssukx07dkg8c/N7HbGLQBQAALiSTtGiFUODkZleRSRBZnKZO3euXHPNNXLHHXfIu+++K0lJSXLVVVeJ27z55pvy9ddfy9atW2XPnuJjgM877zxp2LChjB07VnJycuTmm2+WeObW9zpiG4EoAABwJZ0nVKdoCcbJXVtJRloVSQQaeOqckdojesghh0jnzp0lOTlZ3KZp06amN1TPh78lS5aYYP2pp56STp06ybPPPivvv/++FBTEb2q2W9/riG2Vor0DAAAA0ZCU5DHzhNaclFpuwaJaGanSuU2jhJm+pV27dnLnnXdKkyZNJDMzUzIyMmTy5MnR3q2YsWzZMjnwwAOlcuXK5nftGa1ataqsWbNGDjjgAIlHHo9Ix1Z1zXREgd7rXdomznsdsY0eUQAA4FpVU1PMPKH6Bb2sL+YPDO4uf86ZIfv27ZNEsGjRInnkkUdMauqXX34pHTt2lNtvvz3auxUzNE03JSWl2G0alMZrj6jX65UpU6bI5O++lgcHdy/3vT5ySG9JT/03AAcizePVdycAAICLp7bQeUKnL1grE6ctNcVadJycpih2at1QfvlpsixYMF+aN28uAwYMkEqV4juhbPTo0TJjxgyTbqpWrFghbdq0kfz84IrZJJo6derI1KlTzTlQs2fPllNPPdX0gKpdu3aZVObNmzebn/EYhOox6fv23PPOk6rVqpf6XteeUA1C6Q2FU+L7kxQAAKCC9It3RtUqclzH5tK5TcN/K4Z6xIyT0/u6dz9K1qxZbQK2zz77LO6DUR0b+eKLL8q2bdukZs2apmCP3oZ/dejQwYwb/eSTT+SMM86Ql19+Wbp37x73QageS/169cx9Zb3XASfRIwoAABCATt8xbtw4U0E13ntGi4qKZPDgwfLRRx+Z4Mrj8ZjpXI477jhxkyuvvFJ++OEHWb58uRkvW79+fdNTrL744gszrY0WcUpLS5MJEyaYFOZ4DkKzsrKivVtAMQSiAAAALgtGrZRTPaYGDRqYYNRt1q1bJzt37vT9rkFnixYtio0V3bBhgzRq1CiuqgoThCJeEIgCAAC4NBiNNj2PL7zwgixevNhMJXPdddf5qtUidAShiCdUzQUAAAiSprKeffbZZtoTa8xoolTTjUbQ1KdPH5M+2rNnT5Mme/XVV0d7t+IWQSjiDT2iAAAAIaJnNDzzdWphIC2apL3KWrW3Vq1asnLlSqlbty7vyRAQhCIe0SMKAAAQInpGK65atWpmbs4tW7aY39evXy+7d+8285wieAShiFcEogAAADYQjFaMVqm95pprTDVaHWs7cOBAU71Wx40iOAShiGek5gIAAFQAaboV8/fff5spVLp06SJt2rSRX3/9Vdq1a8d7MgCCUMQ7AlEAAIAKIhituGeeeUbGjBkjf/zxhyQlkbRXHoJQJAICUQAAgDAgGA3dqFGjZObMmbJ69WozNvSLL76QI488kvdjOQhCkSgIRAEAAMKEYDQ0U6dONUGoTofTo0cP8xNlIwhFIiEQBQAACCOCUUQCQSgSDQn4AAAAYUQ1XYQbQSgSEYEoAABAmBGMIlwIQpGoCEQBAAAigGAUFUUQikRGIAoAABAhBKOwiyAUiY5AFAAAIIIIRhEqglC4AYEoAABAhBGMIlgEoXALAlEAAAAHEIwiEIJQuAmBKAAAgEMIRlEWglC4DYEoAACAgwhGURJBKNyIQBQAAMBhBKOwEITCrQhEAQAAooBgFAShcDMCUQAAgCghGHUvglC4HYEoAABAFBGMug9BKEAgCgAAEHUEo+5BEAr8ix5RAACAGEAwmvgIQoH/8Xj1LwIAAAAxYceOHTJu3DjJycmR5s2by4ABAyQpKVnydu+RIq9XkjweqZZWWZKSPNHeVZSjqMhb7DVLT02RqVN/llmzZkmlSpXkjDPOkKysLM4hXKtStHcAAAAA+/eMajCq/QXbcnbJn/9slonTl8mOvHypXi1V+h3ZSo5s10jSUwlIY01hUZHsyt8r0+evlYnTl/pesxM6NZeOBx8qW7dulU6dOhGEwvXoEQUAAIhBubl5siW3QO4bO1W25ebvd3/NjFR5bEhvqV8znd7RGApCN27bJUNf+b7M12zEFcdKw9oZvGZwPcaIAgAAxKLklDKDUKW3a8CzM3+P47uG0mlPaFlBqNLbh702mdcMoFgRAABAbI4v1NTOsgIai94/Y8Fa83hEF68ZEBp6RAEAAGKMFrnR8YXB+HLaUsndXRDxfUL5cnbm85oBIaBYEQAAQIzRSqta5CYYOTsLZPPmLfL7zCWmym7jxo0lJSUl4vvodkVFRbJ+/XpZuXKlWQ7v3C2k10zoxIbLEYgCAADEGJ3uQyutbty+K+BjM9OryM68PJk9e7ZZkpOTpVGjRtKsWTOz1KtXT5KSSIKrKFPBeNs2X+CZnZ0te/b8b3zuwYftCek1E2bfgcsRiAIAAMQYnSdUp2h5ZvWMgI89uWsryWpUQ3r27GkCpDVr1pggSZepU6dKamqqmSrECkxr1KjhyDEkgl27dvkCz1WrVklubm6x+xs0aGDOadOmTaVhw0bSb2eloF+zjLQqEdxzIPYRiAIAAMSYpCSPmSe05qTUcgsW1cpIlS5tG0lG1SrSpUsXs+zdu9cEo1bwtHHjRlmyZIlZrHlKreBJl7S0NAePLLZZ527FihXm3G3atKnY/RrE6znT86fBfclzF8prpq8x4GbMIwoAABCHc1JqQDMyiHlEtVdPgyqrZ69kr179+vV9vaWa0lupUiVXjfPUQN06N2vXrpXCwkLf/dqbbAWeumgQ78RrBrgBgSgAAEAMTwmi84ROX7BWJk5baorc6PhCTe3UXrX01MohBTQ6znH79u3FxjkWFPyv4q4GoVrsyAq86tatKx5PYgVMJY8/P/9/AaOOr9Xj1+BTCz/p8Yc6vjbcrxmQqAhEAQAAYpwGN2aKFq206hEzvjAcwYxV+dXqMdUeQb3Noqmn/j2CmZmZEm92795tjs86xh07dhS7X4NN6/jCWXE4Uq8ZkCgIRAEAAGBoFdjVq1f7egy3bNlS7MzUrFnTF5jqzypVYq/gzr59+0xAbR3Dhg0bit2fkZHhCzz1GKpWrRq1fQXcjEAUAAAApcrLyys2vnTnzp3/+xLp8fiqxurSsGFDk9pqp+cwb/ceM3eqTlujFYNDTTfWokLWPmqxIQ1GLZUrV/YVZtL91GA60dKNgXhEIAoAAICgAr6tW7cWG1+pVWYtmtKqlWStgK927drlBnxa2GdX/l6ZPn+tTJy+VHbk5Zt5OHXaGq0+W95YypycnGLTqmj6rUXHdGrRJWs/NFhmHlUg9hCIAgAAIGRaXXbdunW+gFDHmmqwaklPT/elv+rPatWqBV1dtmZGqjzmV11WCypZPbP6c9u2bcUer0Gv1TPbpEkT0wsKILYRiAIAAKDCNFjUXlIrMC0vWKxTv7Fc98zX5c63qcHo6Gt6y6SvPjcBb2lBrhXo+ge5AOKDeyaKAgAAQMRo4aJWrVqZxT991urJ1MJHuuTm5kml9XvKDUKV3j99/moTdOq0Mpr2awWegdJ+AcQ+ekQBAAAQUf4FhWrUri8vfbVIlqzeGnC9A5vUkjvP7SK1a1SzVQgJQOyiRxQAAAARpb2X9erVM8v2vHzZkfdnUOvl7CwwPa0EoUDiSYr2DgAAAMA9dIoWrY4bjMz0KiJk4AIJiUAUAAAAjtF5QnWKlmCc3LWVZKRVifg+AXAegSgAAACc+/KZ5DHzhGpV3PLUykiVLm0blTmXKID4RiAKAAAAR1VNTTHzhJYVjGoQOnJIb0lPZT5QIFFRNRcAAACOKyryys78PTJ9wVqZOG2pKUykY0I1HVd7QjUIpTcUSFwEogAAAIhqQJq7u0DEq99MxYwJJQAFEh+BKAAAAADAUYwRBQAAAAA4ikAUAAAAAOAoAlEAAAAAgKMIRAEAAAAAjiIQBQAAAAA4ikAUAAAAAOAoAlEAAAAAgKMIRAEAAAAAjiIQBQAAAAA4ikAUAAAAAOAoAlEAAAAAgKMIRAEAAAAAjiIQBQAAAAA4ikAUAAAAAOAoAlEAAAAAgKMIRAEAAAAAjiIQBQAAAAA4ikAUAAAAAOAoAlEAAAAAgKMIRAEAAAAAjiIQBQAAAAA4ikAUAAAAAOAoAlEAAAAAgKMIRAEAAAAAjiIQBQAAAAA4ikAUAAAAAOAoAlEAAAAAgKMIRAEAAAAAjiIQBQAAAAA4ikAUAAAAAOAoAlEAAAAAgKMIRAEAAAAAjiIQBQAAAAA4ikAUAAAAAOAoAlEAAAAAgKMIRAEAAAAAjiIQBQAAAAA4ikAUAAAAAOAoAlEAAAAAgKMIRAEAAAAAjiIQBQAAAAA4ikAUAAAAAOAoAlEAAAAAgKMIRAEAAAAAjiIQBQAAAAA4ikAUAAAAAOAoAlEAAAAAgKMIRAEAAAAAjiIQBQAAAAA4ikAUAAAAAOAoAlEAAAAAgKMIRAEAAAAAjiIQBQAAAAA4ikAUAAAAAOAoAlEAAAAAgKMIRAEAAAAAjiIQBQAAAAA4ikAUAAAAAOAoAlEAAAAAgKMIRAEAAAAAjiIQBQAAAAA4ikAUAAAAAOAoAlEAAAAAgKMIRAEAAAAAjiIQBQAAAAA4ikAUAAAAAOAoAlEAAAAAgKMIRAEAAAAAjiIQBQAAAAA4ikAUAAAAAOAoAlEAAAAAgKMIRAEAAAAAjiIQBQAAAAA4ikAUAAAAAOAoAlEAAAAAgKMIRAGEXXZ2tmzYsIEzCwAxorCwUObOnSv79u2TeLd9+3ZZunRptHcDQAURiAIIq82bN8vhhx8uPXr0kIKCAs4uAMSA559/Xg477DB56qmnJN6dd9550q5dO/n999+jvSsAKoBAFEBYDR06VK666io58sgj5YknnuDsAkCUaYbK448/Lt99950888wzsnr1aolX48ePNxc833jjDbn22mvF6/VGe5cA2EQgCiBsli1bJuvXr5f77rvPXH3/8ccfTQoVACB6Xn/9dXnwwQfl2GOPlZEjR8prr70Wly9HUVGRvPnmm/Kf//xHLrjgAjn00ENNcA0gPnm8XEoCAAAAADiIHlEAAAAAgKMIRGPIRRddJKeddpr8/fffxW7Pzc01t0+ZMkXihY5FGTFihO/3iRMnyqBBgxzZ9tSpU835ihQ9Fn2tLBs3bjTbW7BgQcS2GU9uueUWcz70vATrrbfektGjR4uTPvvsM7nkkksCPk7TjCdMmODIPgFAJCxZssR8Lmt6brx77733zLFoWwwgvhGIxhD9UNUvx3fddVex27XyqN6uU2LEixkzZsj06dN9v//zzz/y5ZdfOrJtLcKg5ytS9Fj8G8Bdu3aZ7W3ZskXcTl/jZ5991pyPYKsZasB64403Ss+ePSOyT998842psFjaF7Ovvvoq4PqdOnUyBTH0dQaAeL1A+MUXX5jxlfFs27Ztcv3115tjCebzG0BsIxCNMfqlVz9gf/31V0kkJ598srz77ruSiOrVq2eq+GkpeTfbu3ev3HrrrXLbbbdJenq6/PHHH0GtN2rUKFNwQt/7kbB8+XL5/PPPba9/yimnSJUqVUyFRgCIN5MmTTIX5PQi94oVK+K6gNzw4cOlSZMmpkc02DYGQOyqFO0dQHF9+/aVqlWryrBhwwKm4upkzloJT3voateuLWeddZb07t3bd79OXH3PPfeYL/pvv/22SR094YQT5LLLLpOzzz5bLr74Ylm3bp3MnDlTdu/ebT7YzzjjDFPp9MMPP5ScnBzp3r27mYojKel/1yw0xXbnzp3i8XhMEKbTdOhzJScnl7mvum1Np9GAVOl+6f6VpL1iGsworaP18ccfmwZU05M7dOhgeqYyMjKKrfP111+b/dWeY93fGjVqBHxbaUM8ePBg8289tsaNG5tzV1pK7yeffCKffvqpqdanjylZ3ysvL0/Gjh0rrVu3llq1apnbNBizJtvW23TutiuvvFLS0tKKrbt161ZzhVp7DzMzM2XgwIGmqqFFt6W9i9oDu2PHDhOwXXfddVK9enXfY/TLRdOmTaVVq1bmIob2zHbp0sW8bikpKcW2p9UFrd5b3Sc9n9WqVTPrvfPOO2apVOl/HwurVq2SG264waRz6bbL89xzz5nj0f354Ycf5M8//wz4OujE6mPGjCmWxq0++OAD8/7XY9V90i9PBx54oOk51fe6Rd/bP//8s/m3nr82bdqY47ZeBz3el19+WfLz832vrc5xqum2Fn1uDTK14q+eR73a3qhRI9/9+j7X97w+j+4PAMQL/Yy9+eab5ZprrjGfgQ899JD89ddfcvTRR0u8mT9/vrz00kumJ1Qv1uvnv7aR+hkNID7RIxqD9Ev5Tz/9ZAKwssyePdsEEosXL5b+/fub4OzEE0+Up59+2vcYnWdLgw4N7jTQ1EBVAxSlY97OP/988yVeGyT9cn/mmWfKqaeeagLBI444Qrp16yb33nvvfqnCup4GcTpO8pBDDpHHHntMTj/99HKPqWRqru6rPoe1aPClvVZr164192vQp8GyjuHLysoyj9dgqUePHrJnzx7f82ggrj1WdevWNY/Rc6aBUyAaEFrb1iBDr7BqAHPHHXcUe5yWudfjbdGihRx//PGmV/f+++8v9pjSUnN1n6zn1/P4/vvvS9euXU2voUVfu/bt28u4cePkqKOOMq/nww8/bHpXlTawF154odm/hg0bSr9+/eTbb781z6evp0XfK3fffbcvWNTtPProozJkyJBi+6lBnO6XHrs+l6Y46e9KX28r4Pb3yiuvmDTrQL29+l7T7T/wwAMmIDz44IODCkT1Ioiet5JfihYuXGjGjfbp08cElXoBQF9/PTa9CGI55phjfOdZH/PLL7+YbWtArDR41fOlAbn1OH1Oi54DvTij+3zSSSfJb7/9Zi6s+G/D2s68efPiKj0eADRw03ZVL761bdvWXHgN5rM5FmlArZ/X2hbr57xeLNcLiZHoQeazHnCITt+C2FC7dm3v3Xffbf7dv39/7+GHH+4tKirybtq0SbvgvG+//bbvsT169PD27t272PqPPPKIt2rVqt6NGzea3ydPnmzWGzVq1H7bqlKlivfMM88sdlunTp28tWrV8m7fvt1328MPP+xt2LBhufu9cuVKs53ff//dd5s+94ABA3y/P/fcc97q1auXuv62bdu87dq1M8eUn59vbnv33XfNc3711Ve+x+3evdvsy7PPPmt+z8vLM+fsoYce8j1Gz1e3bt3MuqH65ptvvJUqVfLm5OSY3zds2GDO50svveR7zL59+7ytW7c227UsX77cbO/nn38u87l37tzprVGjhve///2v77bjjz/e26FDB+/evXuLPXbLli3m58cff2yed/z48b77CgoKvM2aNfM+/vjjvtu6d+/ubdWqlbnP8vrrr3tTUlLM/qoff/zRPNenn35abFubN2/2/fvss8/2Hnfccb7f9+zZ461fv773vvvuC3juhgwZ4m3btq3vWJ588klvcnKyec3K8/zzz5v91NfN3/Dhw/d7/Xfs2OGtWbOmeU+WpbCw0HvwwQd7R4wY4btNX7/09PT9HvvEE0+YbcyZM8d3m/6teTwe72effVbssfo3pY/V1wQA4oG2Jdqm+38H0LbisssuK3e9WbNmFWvPY8Hnn39u2pR58+aZ3xcuXLhf+2jXBx984M3NzfX9fvLJJ5vtAYg8UnNj1COPPGJSUT/66KNiqZpKe9WmTZsmL7zwQrHbzznnHNMzpr2l2jvon+5bmpLPe8ABB5i0Vv+0T71N03e1h9JKz9XftbdKe/S0R0l77jQtV3uxdJ9Dob2b2ptaWFhoehV1LJ7S3tNmzZoVO47U1FTTY6tpqpo+qT1U2pumPbkWTdHRnl/t2QpE999K+9Qrq9rLqGlMmqKpxzFr1izT2+n//Hqcmr786quvlvvcmkarE25rCpTuo54/XfQcKU0jnjx5sjzxxBPFUmGVlVaq56B+/frF0oUrV67sqxZ4++23+27XlGS9z6I9gfo+2bBhg0kz1fRlfd4BAwYU25Z/mqum6WrP36JFi0yasfaQak/nFVdcUe6x6jFqz7S+ftax6NVqfU01/bq8sZ+bNm2SmjVrlppapeNM/V9/7bXU3kyrB1hpyq2m8WphLC16pNvU3lDrPAei7/WOHTv6fq9Tp475G9CCV6W9JqFUAgaAaI+n1M8z/yEF+tkcaGyl9gZqFkmo7XlZtC3SYSfB9HhqG1Ta+pqppW2RlZ2jQ1H0+4IeS0Wr5A8dOtRkwugwFQDOIhCNUZpiee6555rU2JJjRXV8owZM+gW+tC/LGjz48w8s/VlBn0WDgdJuU1YgqkGbBhaa4qtBjQYyGnxoYKRjJUOhAaym3uq4Dw2srf1XGuBqemTJBkYDDGufrFTYkueh5O+l0fElGohr8N6rVy/TWOt505Qc6zis5y855jTQ82tQq+dHj0fTejWY1CBxzpw5vufWY9OgSQOfsug50EC95DnQaq8lK7hqkO7Pumigr5sVGJe3LaXpsZpqrWMhdSoVTenS1F1NWy7PTTfdZLb32muvmUXpmF6lKWDlBaL6ftOgvDSljfXV26yxt3psepFFg0Md96xfYPQ86IWSYN+LJc+b0mOxzpvFSgcv7fEAEGu0XdXPcr2YrMNcLDo9nKbqavtj1XXQC8t6gVUv4OoFPx0OY92nt+l3CH281nrQi55aU8F/eIXWEtD2Q9tVHQrk35YrfS6rJkN5WrZsWertWoldLxyXvDCrz+ufZqwXXnV/tM3RYRp67NaFRr3ArBd/9fNd27TjjjvOfHfRx2l7oXUm9PuMf8Cs30s0KNdhHyWPCUB4EIjGMB1zp2M6tJHwp+MhdUyofjD7s37XD99I0V4yDR60t84KCNesWVNs7GOwdOypjknU4kg6BtOf/q7jSktrvLSYk/UYKzBr0KCB7379PRAtLqQNqvZaWr7//vv99kFp4KOvQ7DPr8ej6+gFA6uwkl448J97VAMqDWi1V7csun1tZEs7B6EGRPqe0II8GgBrT2NZtFdUC2Xp2FS9AFLeOGXr/aBfVLQYVsmLGPqlJdBYJC0OpEGyBtbW62pZv369+YLgf5Vaz6v1/taLEto7qtvwL6SkF2/8haOQhQa3Sr+gAUCs095FHUtZslaAZrBoT6lmvli9i/q5r+2D1iLQDCUNVrWN0R5RrYugAZm2ZdpuXX311SbTRR+rtQief/55E4RqbQv9nNTvBiWDNg3+7PZaataMFljSAoday8CfXjD0b2O0bdaiTPodSbOCNPDUsbF6fPo8ehx6AVy/W2itB62RoVXV9WKoFgzUtkZrbijdpgamGoBr7QgN7EsWGwQQBg6k/8LGGFH/sXc6xqPkGNHrr7/e27hxY+/q1avN7zo+sF+/fmZ8nDVOzxojmp2dXeoY0ddee63Ybeecc44ZG+Hv/fffN89hPaeO6cvMzDRj6axxhOeff755jP/zBRoj+vLLL5vxHhMmTCj1XOj4FB2f6T9GUC1YsKDY2I0jjzzS27dvX9/4SB2vWadOnYBjRK+77jpvmzZtfOvp+EMda+k/1lOPWceD6nmxxlrq+BQdb1jeGNGvv/7a/G6NZVF33XWXuW3o0KG+2+644w5zLv3H4ixevNj722+/+bal56DkeEV9jP9YT91vfZ/4033xf+3XrFnjzcjIMI+zXksdT6ljcf3puFt9nVq0aOFt2bLlfmM3/el43gMOOMB70003lXp/nz59vEcffbQ3mPHFU6ZMKXWM6G233ea77YcffjDjN63Xf+nSpeYx/u+hMWPGmNv8xz9/8sknZj3/MUDWGFEdA1uSvrb6fi05hkjHsur5AYBYpp+JSUlJxdogy7Jly8xn5Hvvvee7Tds0/7ZWv4dYtReuvfZa74UXXui7b9CgQeZzdteuXaZN0c9wpd9FUlNTwz629MorrzRttdUG+3vmmWfMsWj7bbV7eizW9xP9vqC1GbSts9pO/SzX7yrads2ePdvcrnUXtB236Pege++9t1gb+/3334f1uAD8i6q5MU6v5pVMw1RaXVXHeugVTU0b0fESesWu5PQb4abTtBx00EGmh1DTInW7mhpZsjcsEO1106uNOnWHXim1Fi3HrvRKrFaavfTSS01lWR0rqMeqKUb+07fo2EQ9bt0PTbXRqqpaJTUQHW+iY0L1qqlW4dP1S6aC6nnUnlO9qqrHrKm8eoVZK/eWR8cx6lhWHXOiz63jLfUqccneNH0N9Xh0n/WxWjlX06Os49Pj1THCeoVXX2ut6qrnQs9TqGNZdJyoVkrW/dCeVt1H/VmyR1Z7S7UHVq8SaxXh8noTNX1XU6H0tSyNnrNgekQ1jVlTu0vSqYG0Yq8es6Z76XtAxzpZV6w1jUsrJFvTFmkKllbt1fRif3pf8+bNzdV0TSfXTINQ6XQBev7L600GgGizxlPqsJDSqp3rZ6E1ttJfee1m586dff/WtFYdNqLpuPoZrZ/hStN1w52Npe2HtvHae1na9HDaxliPs+gUXtYwFP23DovR7Brt8dW2W6eE055RHW6hvaShHDOA8CM1N4ZoeqM2EiUDCJ2TUb/w+4+103Ecmjap6YnWPKL6Rds/CNUv8DoVSGljA//73//uNy+kzn2pKaT+NADQ57AaAQ2AtDCMFkTSD3HdX23sdGoN/wBAB//7j7PT+UP902/1WEtL5/Ufj6jBnH7515QZLUCj62vg6D+nqR6jpuNoeqg2LBqM6E8NYMuj+62pSVqQSMczaoOl6b1a1Me/8dYgUYMyfX5N6dFzrCm3/sVwrOO0zr3unxbu0fQmHV+iKUw6NYumuuoYF4sWg9AxlRoYabqUvob6OP+5P/X4dVyufmmwzrcGtv7nQFOi9P3gT4+h5GuvY2H1WPS1s+Yk9U9ptui50C8qOn63PNpQ6zyd+mWkNBokauCur3PJ+UxLPk5TnzQw93//akCuFwE05VzPgV4s0MXfM888YwpX6XtAU5319Sn5BUvPjaYJ6xhdPYeatqU0oNf3T0n63tRz4D/mVy8I6GsKALFMP9sff/zxMgNLbTv0omRp4zjLUvKCpLaF2pbpRWhruIde2NVhOuGk+6TtmDXNWEl68Vbv9/9uoQGyfgfQAFTrPGj7ru2gXqTXz3a9OKzptvoZb80JrtspWRegtGMGEH4e7RaNwPMCrqFjQrW3VCut+hdxiEd6IUKDYb1yrHOIOkG/AOhFFh3LZI1n0ivg+sXBKkwUTbovegVdL1IAQKLRC8zaa2hl2uh4TB0jqj81C0WDNqvy7p133mkCO71wfd5555mL5JppohfGtViRjtsveZHbKVOnTjVBq9Z/0IugWlH98MMPlxdffNFkFukFZB0Dq/uqRYo060ozbTQ41d5cbYe0WJHO3a0ZQVb2jRaO1MwbXQCEF6m5QAULQmjlXW244j0I1S8a2qOsPb5azMIpeoVeexxL652MBZoVoCnkAJCIdDiGf9aKBmRWtVntddShIRYdSmEFmlpIUTNL9CKsZkFpMR/N4oom3VcNknWf9Liee+45c7tOlaZB58qVK01QqplI1nAZrS6sGTWa7aU9uzrsyEo5Vjrsp2RBRQDhQY8oUAF69VdTSP3nooxXWjVYU5Y0Hblkqq/T9Mq1fpHQq9oAgNijQ0p0HL/O56zDczSdVcfTR4v2iGqPrf4EEB8IRAEAABASDTq1+I/WFNC6BDqfczTnWtahHLo/2jsLID4QiAIAAAAAHMUYUQAAAACAowhEAQAAAACOIhAFAAAAADiKQBQAEHN+//13s4QyB+4ff/wh8+fPZ/J5AEBC27dvn5lySGcZCNauXbtk9uzZsmzZsgo9JpwIRAEAMePpp5+WNm3amLn7LrzwwqDW0cnpdd6/AQMGSK9evcyctE41ogAAOGXXrl1y//33S8uWLaVPnz5yzz33BLXehx9+KA0bNpTzzjvPTDmobeW2bdtCfky4EYgCAGLGihUrZPz48TJkyJCgHr9z504566yzZODAgWay+nXr1pmJ6rUhBQAgkWzZssV3AVYv2AZj+fLlctFFF8nIkSNl8eLFZp72TZs2yY033hjSYyKBQBQAEFM9om3btg368RMnTpSNGzfK3XffbX5PTk6WYcOGycyZM2Xu3LkR3FMAAJyVlZVlekSbNGkS9DrvvPOO1KhRw3eBNzMzU2644QYZN26cuZgb7GMioZK4QFFRkaxdu1YyMjLE4/FEe3cAIKK8Xq/k5uZKo0aNJCmp4tcb8/PzZc+ePRXan5KfvVWqVDFLRek4Um2Y69Wr57utS5cuvvs0TRflo40E4CbhbiPjoZ3s2LFjsWPVdrKgoMDUVejcuXNQj4kEVwSiGoTqFxUAcJPs7OyQrpqW1bi2aFZN1m8stP0c1apVk7y8vGK3DR8+3FzVraitW7dK7dq1i92WlpZmFr0PgdFGAnCjcLSRVjvZKK2abJPYbScbN25c7Dar3bTayWAeEwmuCES1J1T1kH5SSVIiuq3kLxuIEwpPXu/IdgDEn32yV6bKRN9nX0XoFV4NQlfObi6ZGaFfOc7JLZJmR6wwDb6m+ljCcZVXpaSkmC8BJa8s635Xrlw5LNtIdNb7ZOrPP5kvQ5GWnd9QnJCVus6R7QAIn7o/vhPx05mbXyBthr0QljZSaXujQejY5BZS1caox11SJIPzljvaTu7evdv8tNrJYB4TCa4IRK2ubg1CK3kiHIimh+dNE4gnwscBII55//0RzqEI1TI8ZglVkfy7jjau/g1suDRr1swUKPJPa9LfCwsLTSVdBGadNw1Cw/XFrDzplcL/PihNRlrx3gUAsS8zzZnv0Srcw/XSU5Klqic59P3wFop2pkaynSxZM2HNmjXmp9VOBvOYSKBYEQAgoEJvke0lnDTgnDp1qqxf/29WiJav1/LyP//8s+8xn332maSmpkrPnj15ZQEAjvBU8kiSjcVTKbwBsRYX0nZyx44dvnZy1qxZ5iKtfzvZokULMw1MsI+JBFf0iAIAKqZIvGaxs14o/vzzT1NEQkvH63xp2piqrl27SqVKlUzhBA0wX3rpJbnqqqvksMMOM1O1XHzxxfLoo4+aMTZDhw6Vu+66KyJXlgEAKI0nJUk8ntD7+Dze0NrJ3377zWT96NhNrRSv7aSm1h555JHm/iVLlph2cvLkyWYuUJ3ibNSoUWauba0qv2jRInnxxRfl3Xff9T1nMI+JBAJRAEBARea/0IW61nPPPScLFy40/9aKhnfeeaf595dffinVq1c3Ff26d+9uJt22jB071qynP3Usy7PPPiuDBw+2sbcAANiTlOyRpKTQezeTikJbR4sY6YVaq+q5tpM69coXX3zhG2ah7aS2mUqD1W+//VYef/xxeeGFF8xjJ0yYICeddJLvOYN5TCQQiAIAYsbrr79e7v0aaFq9pP633XrrrWYBACCRTZo0qdz7W7VqtV87qUHpI488Uu56wTwm3AhEAQABFXq9ZgmVnXUAAIg3nhSPeGz0iHpC7BFNJASiAICYGSMKAEA8MsWHHEjNTSRxUTX3iSeeMJOs6kDcjh07ypQpU6K9SwDgKhpQFtpYCEQjT+ewu+GGG6RWrVpm3rnevXvL4sWLHdgyAKBYj6jNxa1iPhB99dVX5YEHHpAxY8bI5s2bpV+/fmZZsWJFtHcNAFzXI2pnQWTddtttMn78ePnhhx9MteE6derICSec4JuMHADgULEiO1O4JBOIxiwtJXzZZZfJiSeeaAbRPvzww+aq78svvxztXQMAIKp0qhu9YHvfffdJhw4dpG7duqbioQakH3/8Ma8OACBmxXSPqM6Po+lFxxxzjO82j8dj5sT59ddfo7pvAODGYkV2FkTOnDlzzNyq/u2k9ogecsghtJMA4CBPssf24lYxXaxo/fr15qde4fVXr149mTFjRpnraaOsiyUnJyeCewkAiU9nA7U3jygiacOGDWW2k9Z9JdFGAkCEUnNtBJVJ4t5ANKZ7RMuik7dqz2hZRowYYdJ4rSUrK8vR/QOARGOnUJG1ILbaSdpIAAg/nbrF7uJWMR2INmzY0PzcuHFjsds3bdokDRo0KHO9YcOGyY4dO3xLdnZ2xPcVABJZodf+gthqJ2kjASD8PMlJthe3iukjr1mzprRt21YmT57su83r9ZrfjzrqqDLX0/L1mZmZxRYAABLN4YcfLqmpqcXaSQ1K586dW2Y7SRsJAIgFMR2Iqttvv13eeOMN+eyzz0zjqmXqdczn1VdfHe1dAwDXjRG1syBy0tPT5ZprrpEHH3xQpk+fbqrlDhkyRJo3by5nnnkmpx4AHB4jamdxq5guVqQuueQSU57+5ptvNoUXtBLgpEmTGPcJAA4qEo8U2iiooOshskaOHCnJycly2mmnSV5envTs2VO++eYb0/MJAHCGjsu3M97TU+TedjLmA1F1ww03mAUAEB1F3n8XO+shslJSUuTxxx83CwAgOjzJ//aKhryeV1wrLgJRAEB0FdrsEbWzDgAA8cbunKAer3vbyZgfIwoAAAAASCz0iAIAAqJHFACAsnmSkswSKo+NdRIFgSgAIKAir8csobKzDgAA8UYLFdkqVpTk3naSQBQAEBA9ogAAlM3uVCxJLr5gSyAKAAioUJLMEqpCzi0AwAXoEQ2de5OSAQAAAABR4aoe0eQvG0hyemQn+C48dq04YelTXcUprW6Z5ti2AMQmr80xoroe4kN2fkNJr5QZ8e00S3OmnQQQfzYef2nEt5GbmysiT4X9eT0em8WKPO7tF3RVIAoAsIcxogAAlI3U3NARiAIAAir0JpklVIVeTi4AIPHZLlZU5N7MIQJRAEBAReKRIhtlBYqESBQAkPjoEQ0dgSgAICBScwEAKJuOD7U1RjTJvWNE3XvkAAAAAICooEcUABDBMaKk5gIAEh+puaEjEAUABDlGNPSCCnbWAQAg3hCIho5AFAAQkBYqKqRYEQAAUQ1Ei4qK5L333pPp06dLjRo1ZNCgQdKmTZsyH//JJ5/IxIkTS73v5ZdflkqVKsnatWvlvvvu2+/+22+/XVq3bi2RQiAKAAiI1FwAAAIFokkRD0TPOussmTNnjlx55ZWyaNEi6dChg3z77bfSs2fPUh+flZUlXbt2LXbb448/LmlpaSYIVVu3bpUxY8bIqFGjJDMz0/c4/39HAoEoAAAAAMS4b775RsaPHy9z586Vgw8+2Ny2b98+ufHGG01wWprOnTubxbJhwwa5+uqrZfTo0fs99vzzz5cGDRqIUwhEAQBBpeYyjygAAGX3bCYl20jNLQx+nc8//1wOPfRQXxBqBY/9+/eXNWvWSOPGjQM+x3/+8x/TE3rBBRfsd9+IESPE4/GYdFxN+Y10jyjTtwAAAir0emwvAAC4ZYyonUXl5OQUWwoKCqSkpUuXSvPmzYvd1qJFC999wXjjjTdk4MCBZnypvwMOOEAyMjKkUaNG5jE67nTJkiUSSfSIAgACKrRZrKhQmL4FAJD4dHyovTGiSb6xnP6GDx8u999/f7Hbdu/eLXXq1Cl2mwaP1n2B/PLLL7Jw4UJ59dVXi93etGlT+fvvv6Vq1arm91tvvVWOOuooufnmm+WLL76QSCEQBQAEVORNMkuoiphHFADgAhWtmpudnV0sFbZKlSr7PVbv37ZtW7HbtNCQdV8gWpBI025LFjYquW5ycrIpijRy5EiJJFJzAQAAACCKMjMziy2lBaLt27eX+fPnF7tt3rx5kpSUJG3bti33+XNzc2XcuHFyxRVXBLU/2sOqU8VEEoEoACDo1Fw7CwAAia6iY0SDcc4558jKlSt96bJaMfell16SE088UWrWrOnrWb388svN1C7+PvjgA9m7d69cdNFF+z3vDz/8YAJV/8q6r7/+upx00kkSSaTmAgAC0muidgoPRfZaKgAAiTFGNBg6Z+hDDz0k5557rvTu3VuWLVsmO3fuNIGkZcuWLSYFV6viahquRW877bTTpG7duvs976ZNm+SII46QAw880PTETp48WTp16iTPPPOMRBKBKAAggtO30CMKAEh8FR0jGqy7777bjN+cOXOmqXyrAWlaWlqxwkOvvfZasSBUe0I1Jbfk2FD/nlbt/fz1119Nz6gWSdJpYiKNQBQAEFChN8ksobKzDgAA8caJHlGLBpn+gaa/WrVqmdRcfykpKXLZZZdJeXRcqqb4OolvCAAAAAAAR9EjCgAIqEg8ZgmVnXUAAIg7Hs+/i531XIpAFAAQEKm5AACUzeOxOUbUQyAKAEDZgajNqViYvgUA4AZOjhFNFPSIAgACKvJ6zBIqO+sAABBvnKqam0jcG4IDAAAAAKLCVT2ihSevF48nJaLbWPpUV3FCq1umiVMS8ZgAhD4fqJ00W+YRjR9ZqeskIy0v2rsBAHGJ1NzQuSoQBQDYU+RNMoud9QAASHSeJHtpth4XN5MEogCAgArFY5ZQ2VkHAIB4wxjR0BGIAgACokcUAIByaPVbOxVwk9zbJUogCgAIqNBm76auBwCAK+YRtTEnqMfF84i6NwQHAAAAAEQFPaIAgJhJzd29e7eMGDFCJk2aJJUrV5YzzzxTrr/+ekkqJ3Vp0aJFMmrUKJk7d65UqlRJOnfuLLfffrs0aNAg5P0FAMAOquaGjkAUABBQoTfJLKEKdZ1zzz1XFi9eLE899ZTk5ubKNddcI2vXrpXHHnus1Mdv2rRJevToIccee6w8+eSTJpC977775LjjjjOBaXkBLAAA4UKxogQORLOzs82V7oYNG0Z7VwDAdbzikSIbY0R1vWDNnDlTJkyYINOmTZMjjzzS3JaXlydXXXWV3HnnnVKzZs391pkxY4Zs3rxZXnjhBalbt665LSUlRY455hhZsWKFHHDAAeIGRUVF5nirV68utWvXjvbuAID76Dwsdi5+etx7wTTmj/yZZ56Rpk2bSvfu3eWwww6TVq1ayffffx/t3QIAV/aI2lmCNXnyZBNEWUGoOvnkk2Xv3r0yderUUtfp0KGDpKenm1Re5fV65ZtvvpHmzZtLkyZNJNHt3LlT7r77bhOE9+nTxwTeev7mz58f7V0DAHdJ8vh6RUNZxMbco4kipgPRwsJCWb58ufz222+yatUqWb9+vZxxxhly+umny8aNG6O9ewCAIOXk5BRbCgoKSs18KTmus169epKcnGzuK03jxo1NADt06FBp1qyZyZr54osvZMqUKWaMaaJbt26dCcT/+ecfWbZsmWknGzVqJAMGDIj2rgEAEL+BqH75ePrpp80XDaVjfW655RYzbmj27NnR3j0AcI0ir8f2orKyskzaqLVoQaKS9u3bt1/wqGXtNdVWe0VLs2XLFrnwwgulW7du8u6778rbb78tGRkZcskll5iLmYlOs4Tuuusuc05VWlqaXHvttbJ06dIyg3cAQPh5PEm2F7eKmzGilr/++sv81CvfAABnFEqSWeyspzQoyszM9N1epUqV/R6rabkaWPrbtWuX5OfnS506dUp9/jFjxpgMGQ1CrSC2bdu2JvCdOHGinHLKKeI22k7q+a1fv360dwUA3MNumm2Se1Nz4yoQ3b59u1x33XVy6qmnSrt27cp8nKZ8+ad9aRoYAMA+/97NUNdTGoT6B6KlOeKII+TRRx81VXI1vVT9+uuvvvtKoxky2hvo35OqQav2pLrxs18rDj/44INy6623lpmaTBsJAOHH9C2hS4qnggz9+/c3Y2Heeuutch+rKV/+KWB6ZRwAYF+RJNlegnXSSSeZAkP33nuvqQKrU7E89NBD0rNnT2nTpo15zJ49e6R9+/Yybtw487tO26LVYj/44ANfsSKd6kWDsKOOOspVL7n2Ovft29eckwceeKDMx9FGAkD42SlU5LEKFrlUUrwEof369TNXvr/77jupUaNGuY8fNmyY7Nixw7cwTgYAYl9qaqp8+umn8vPPP5teTV008Hzvvfd8j9EAdd68ebJ161bzu84XOnr0aDPFiwaxWtzotddeM6m6LVq0ELdYvXq1CUAPOeQQ+fDDD810Z2WhjQQAxIKYT83V8UFavl/TcnXalmDmR9OxMaWNPwIA2FPo9ZjFznqhOPzww2XRokWml1N7Na1idRb9bP/777+L3X7TTTfJDTfcYIIxLWzktvmm16xZY4JQHRv70UcfBawWTBsJABHg8dibE9Tj3h7RmA5EtYKiFppYsGCBuSKuXzJ0UTq3aK1ataK9iwDgChUdIxoKHd9ZVm+m3qepuSVpVXVtF9xm8+bNpldYe5M1pdl//tCDDjpIqlatGtX9AwC3sJtm63Fxam5MB6J5eXmmgqJe3dbCC/6GDx9u5hMFAESe15skRd4kW+shcrTnWKdsUVdeeWWx+3QqG03VBQA4ICnp38XOei4V04GojgX9448/or0bAOB6heIxS6jsrIPgderUiXYSAGKAZuzoYmc9t3JvCA4AAAAAiIqY7hEFAMSGIq+98Z66HgAACU8LFdlJs/W4t1/QvUcOAAiajg+1uwAAkOicmkd0/vz5cvzxx0tGRoZkZWXJ/fffb6Y2K4tOeaZTepVcpkyZUqHnDQd6RAEAARWJxyyhsrMOAABxR3s2bU3fkhT0Q3Nyckyw2KdPHzPVmS5nnnmmCSzvueeeUtfxer1SWFhoZh6pX7++7/bk5OQKPW84cKkaABD0PKJ2FgAAEp72bNpdgvTOO+/Ijh075KWXXpJGjRqZOaR1ZpHRo0ebaS/Lo4Gnf4+of5GkijxvRRCIAgAAAECM++WXX6RLly7F5oju3bu3bN26VRYuXFjuuh06dDAzkhx55JHy3//+N2zPWxEEogCAgBgjCgBA2TyeJNuLlR7rvxQUFEhJ69atk3r16hW7rW7duubn+vXrpaye0KFDh8rUqVNl8eLFMmjQIDnvvPNML2hFnjccGCMaZq1umSZOWPpUV3EKxwTAjBG1UzWXMaIAADcIMc3W5//X0QJB/oYPH24KBgWS9P+VenUsaGnatm0rI0eO9P1+ww03yJ9//imPP/64XHDBBbafNxwIRAEAAXltFivS9QAASHSepCSz2FlPZWdnS2ZmpliqVKkiJWmxoQ0bNhS7bePGjb77gnXYYYfJe++9F/bnDRWpuQCAgLQ31O4CAEDC0+I/dhcRE4T6L6UFokcddZTMmDFD8vPzfbf98MMPZuyn9nwGa+7cudKwYcOwP2+oCEQBAAExRhQAgECpuUk2Fk/Qp/XCCy+U9PR0k16rhYSmTZsmTz31lFx//fWSkpJiHqNpt/7zhD700EPy/vvvy6ZNm8zY01dffVXefPNNufHGG0N63kggEAUAAACAGFejRg2ZNGmSzJs3z6TM9u/fXy699FIznrTkvKHW2M5LLrlEvv/+eznkkEPM1Cwvv/yyjB07tlggGszzRgJjRAEAAdlNsyU1FwDgCn5ptiGvFwId36nTrZQ3TcvevXtNtVzVpEkTef311yv8vJFAIAoACK5qro3CQ1TNBQC4QUWLFYWTpubGg/jYSwBAVNEjCgBAOXQ+0P+fEzQkHveOlCQQBQAERCAKAECAFFs784h63Ftd3r0hOAAAAAAgKugRBQAERI8oAABl83iSzBIqD6m5AAAQiAIAYH8eURtptknuTc2lRxQAEJDXZgXcf2cxAwAgwVGsKGQEogCAgEjNBQAg+vOIJhKKFQEAAAAAHEWPKAAgIHpEAQAoR1LSv0uoktzbL0ggCgAIiEAUAIByMEY0ZASiAICACEQBACgHVXNDRiAKAAjI6/WYJVR21gEAID6LFdlIs/W4t510b1IyAAAAACAq6BEFAASkc4jamUfUzjoAAMQdpm8JGYEoACAgxogCAFAOquaGjEAUABAQY0QBACgHPaIhIxAFAAREjygAAOVg+paQUawIAAAAAOAoekQBAAGRmgsAQIAeUR0nGiqPe/sFCUTjVKtbpjm2raVPdXVkOxwTENuBqKbn2lkPAICExxjRkBGIAgAC8pqgMvQTZWMVAADiD2NEQ0YgCgAIaj5Q/S9UzCMKAHAFekRDRiAKAAiIMaIAAJSDeURD5t7RsQAAAACAqKBHFAAQkBYq8tgoPGSnwBEAAPHG6/GYxc56bkUgCgAISAsV2SpWRLUiAIBrxojamb7FI25FIAoACIgxogAAlIOquYkdiK5evVp+/PFHadu2rRxxxBHR3h0AcA0C0fgwb948+f3336Vbt27SsmXLaO8OALiGk6m5K1askNmzZ0uNGjWkZ8+eUrly5XIfv2/fPtM2rFmzxrQNhxxySLH7d+zYIZ9//vl+6/Xp00fq168v4vZAVE/gWWedJX/88YdcddVVBKIAAPjZvHmznHLKKeYLyquvvkogCgAJaNSoUXLfffdJ9+7dzee9+v777yUrK6vUx3/xxRdy6623SvXq1aVx48YydepU6dChg3z66aeSnp5uHpOdnS0XXnihnHnmmZKamupbVzv+CERF5O6775aDDjpI8vPznXmVAQA+FCuKfYMHDzYXau+6665o7woAuI8Dqblz586VO+64Qz766CM5/fTTZc+ePXLMMcfIddddJ5999lnpT+/xyKRJk6RZs2a+i5aHHXaYPPTQQzJy5Mhij33++eelQYMG4pS4mL5FT56ecD05AIDoFSuysyDyRo8eLTt37pTbbruN0w0AUStWZHMJ0vvvvy9NmjQxQajSlNxrr71WvvzyS9m+fXup65x88sm+IFTVqVPH9Kb+9ddf+z12ypQppqd0wYIF4oSYT83dsGGDXHLJJTJu3DjJzMwMap2CggKzWHJyciK4hwCQ+P4NKm2MfSEQjTgdJ/TYY4/JrFmzJEknVA+ANhIAIkA/f4P4DC51Pdk/XqlSpYpZ/P3999/Svn37YrfpeM/CwkITPGp9gEB27dolv/zyi1xwwQXFbq9UqZI899xzJt7S9N2jjz5a3nvvvaDjr4TrEfV6vSZf+bLLLjORe7BGjBhh8qCtpaycaQBAsJ/HHtsLIicvL0/OPfdcefbZZ81V8mDQRgJA5IoV2VmUxiv+8Yt+VpekRYVq1qxZ7LZatWr57guGDuHQwFXHjVpq165tihlpADpx4kQT1OrvQ4cOlUiK6UBUu59nzJghBxxwgLzzzjtm2bZtmyxcuND8WwPV0gwbNsy8GNaiA3ABAEg0jz76qCQnJ5txQlY7qW3jtGnTSq2AqGgjASD2ZGdnF4tf9LO6pLS0NHMB0l9ubq7vvkBuueUW0zZosFmvXj3f7Q0bNizW06pFja688kpT6Mi1qbl169aV/v37y3fffVfsZK9cuVK+/vprOf/8880A3JJK68oGANinl/3sZNmSmRtZBx54oHTq1Mm0ib5z7vWaaVz0KrlW0S2JNhIAYq9YUWZmZsA0WO2c++2334rdpnGRdV95br/9dnnjjTfk22+/lcMPPzzgbmlFXS1s5NpAVOeu0cWflhvu1auXPP3001HbLwBwGyfnEdVy9DpntBZh0DZAL0oGUlRUJD///LMsW7ZMDj30UBOcuYHWUNDF3wcffGCGtFx++eVR2y8AcBuvJ8ksdtYLlhYeeumll2Tx4sVmNhHrM1/HiVpDETV7VIsX+c8BqpV2X3/9dROEdu7ceb/n1flFtRfUv00dP368HHnkkeLaQBQA4K4u0f/85z9m/Io2oJoBc/XVV8uECRNMefqyrF271vT8aeN73HHHmefQFCMqrQMAHBNiBVyfENbRQFSXfv36mWq5ixYtMkMZ/bNitIdUa+xMnjzZBKJPPPGEWW688UbzeF2UZs3o86gxY8aYAkbHH3+8yZrRIrEa7Po/byTEXSCqJ79t27bR3g0AcBe7hYdCWGfTpk0m8NQCDdpgKh2joj1+S5cuLbMi7MCBA6VatWry66+/+oZlaMEFtxo0aJC0atUq2rsBAK7iFZs9ohLaOjq9yptvvinTp0+XGjVqmIrpmglk0QBT2wGrN7Rq1armd02z9Q8sdUoXKxC97777TLupY0L1IvDZZ58tF198sSmaFElxF4g+8sgj0d4FAEAEaAOolfw0rdSiV3xfe+01U7iua9eu+62jwacueiXXvzZAjx49XPsavfXWW9HeBQBAhFSqVEmuuOIKs5SmadOmpnCdfzuqSyDabjrddsZdIAoAiNY8ovbWC3Z+tPnz55spSLR302JlwOh9pQWiGoDq1d7DDjtMPvnkE1NNUP+tCwAAiZSam2hievoWAEBizCMazPxomg6kaUb+tGCRBpolA1nLli1bTGU/HUOqY0O/+eYbc0W3rCvFAABEhAlEk2wsHte+IPSIAgAC04CyAmNEdX40/7L0pU2xpXOgWfOhWfbt2ye7d+82wWhp9HYdW6rzaVpVYmfOnCldunQxY0dPOOGE0PcZAIAQeT0es9hZz63oEQUABJ2aa2fxnx/NWkoLRHVOTC0hv2fPHt9ty5cvN/Ni6n2lscrX+wecWppee1b//vtvXlkAgDNs9YYm2Zt7NEG498gBADFFq/fl5+ebioCWt99+W2rXri3du3c3v2sxI52WZd68eb4AVHtF58yZUyx43bFjh7Rs2TIKRwEAAIJBai4AICbmEW3evLncc889JsV29uzZpvCQVswdO3asGSuq9u7dK9dff72Z0Pvggw82ZeqfeuopufTSS2XatGlmvOgbb7whffv2lVNPPZVXFgDgCK94zGJnPbeiRxQAEPFiRcG6//77Zfz48ebfGmRqcHn++ecXK1uvZejbt2/vu23IkCGmSFFKSooUFBSYwHTixIllzjsKAEC46Ryidhe3okcUAbW6ZZojZ2npU/tPzRApHBNgg50eURt69+5tltJoIKqpuSXpuFBdAACICrvjPT0EogAAlMlO76a1HgAAiY6quaGjRxQAEBNjRAEAiFd202y9Lu4Rde+RAwAAAACigh5RAEAQNMXWTpotqbkAABfweP5d7KznUgSiAIDASM0FAKBsdivgetyboEogCgAIjEAUAIBymknmEQ0VgSgAIDCtfmunAi5VcwEALkCxotC5ty8YAAAAABBfgegHH3wgffr0kZYtW/pue/jhh2Xjxo3h2jcAQIzweu0vblRYWChPPfWUHH300XLiiSea2/bs2SPDhg2Tffv2RXv3AAARqennsbGIa9kKRF977TW54YYbpGfPnvLPP//4bq9Vq5Y8+uij4dw/AEAsjRG1s7jQLbfcIq+88oocccQRsnr1anNb5cqVZceOHTJ27Nho7x4AIMy8kmR7cStbR65XeT/66CO57777it3er18/+fDDD8O1bwCAWBsjamdxmYKCAnn99dflxx9/lMsvv7zYfbSTAJCYvB6P7cWtbBUrWr58uXTu3Nn82+N38mrWrClbt24N394BAGKCx/vvYmc9t8nOzpYGDRpIw4YNZdu2bcXuo50EgMREsSKHekQbN24s8+bN2y8Q/fLLL6VVq1Z2nhIAgIRQv359Uy9h+/btxdpIRTsJAEAFekSvvvpqueSSS2T06NGmkdWg9Ouvv5YHH3xQRowYYecpAQCxjHlEg5aRkSFnnnmmnHPOOXLRRReZ4kRz5syRcePGmaEtkyZNiuQrBQCIAuYRdSgQvfXWWyU3N1cGDBhgKgO2b99e0tLS5I477pBrrrnGzlMCAGIZ84iG5MUXX5Trr79eBg8ebAJRLVpUu3ZtU+yvV69ekXqVAABRQmquQ4Go9oI+8MADpgz9ggULpKioSNq2bStVq1a183QAgFhHj2hItD0cM2aM6QFdsmSJqZir7WRKSkqkXiEAQBTZLTzkpViRPampqdKxY0ebawMA4gaBqC3Vq1eXTp06hfvVAADEGFJzI9gjWrIEfXm0bD0AAG6xdu3a/aY0K6/gn2YVAQDgZkEHovn5+b5/5+XlyWeffWYaU6tH9Pfff5c1a9aYcaMAgARDj2i5dIiKfzu5evVqmTJlihx00EFy8MEHy65du2TGjBmm/bz55psj/3oBABzFGNEIBqLvvPOO799XXHGF3HjjjfLkk09KpUr/PoUWY7jttttMYwsASDAUKypXkyZNirWT3bp1k5deekmuuuoq3207d+6Us88+21zEBQAkFlJzHSpWpPOgzZ071xeEmieqVEnuvfdeOfTQQ+08JQAghnm8/y521nObrVu3ysqVK4sFoSo9Pd1Ul3/00UflhhtuiNr+AQDCzytJplfUznqh0IuaOoXm9OnTpUaNGmZKzeOOO67C69h53ooK/WyJmKlbtJEtadWqVeY+AECCpubaWVxG28Ft27ZJTk7OfvfRTgJAYveI2llCGQZywgknyMcffyznnXeeHHDAAeb38ePHV2gdO88btR5RTS0aOHCguarbuXNn8Xq9MmvWLLnrrrvMBN4AALhVs2bNTHbQiSeeKMOHD5d27drJ7t27ZfLkyWbaM70NAIBQffLJJzJt2jTTIahDQtTmzZtl6NChcvrpp9tex87zRq1H9Pnnn5f+/fvLRRddZCLmli1bysUXXyynnHKKPPfcc+HfSwAA4ogW9GvatKmcdNJJ5mfr1q1NEKoXbEnLBYBEnUc0ycbiCXobkyZNkiOOOMIXLCoNFHW+6uXLl9tex87zRq1HNC0tTZ5++mkZMWKE/PPPP+Y2DUj1dgBA4tFm0tYYUXGnBg0ayAcffCCvvvqqacSrVq0qzZs3l5SUlGjvGgAgBosV5ZQYzlGlShWz+FuxYkWxYFFZv+t9LVq02O/5g1nHzvNGLRC1aOCpZemBcGh1yzTHTuTSp7o6sh2OCQmDqrm2ZGZmymGHHRbuVwMAEJM9ojYCUc+/62RlZRW7XYdx3H///cVu27Nnz34df3qh07qvNMGsY+d5oxqI6hXeZ555RhYsWGDGiOoYGJ3SJVIRMwAgiphHNGSzZ8+WV155RZYuXWoq5uq82zfddJPUqlUrEq8QACCKvF6PWeysp7Kzs83FS0vJ3lBVs2ZNU5nd35YtW3z3lSaYdew8b9TGiP7www/Stm1bM1m3Bp46RlT/rbfpfQCABEPV3JC8/PLLppjf4sWLTeZQvXr1zDyjOlZUA1MAQKJJ+ncKlxAX+f9wTINQ/6W0QLRDhw7yxx9/mCq3ljlz5phhH9opWJpg1rHzvFELRLWC0p133im///67aWx10m79t96m9wEA4FaaxqRt4bhx4+THH380RfzGjBljij707t1bHnnkkWjvIgAgDg0aNMj0VL755pvm97y8PHn22WflrLPOkmrVqpnbli1bJscff7z8+eefQa8TzGNiJhD966+/THpRSZqaq/cBABKLFiqyu7iNlr/PyMgwDbi/5ORkufbaa2knASABOTGPaKtWreT11183MZfWH9AieDq2U4NG/7msv//+ezOfdbDrBPOYmBkjqrnCmm7UpUuXYrcvWrSIsS8AkIgYIxq0GjVqmCvLOt6m5HhQ2kkASEwVrZobLJ0+c8CAAfL333+b9qZ9+/bF7teg8ttvvy1WKC/QOsE+JiYC0QsuuEDOPvtsefjhh33B6PTp0+Xuu+829wEAEgyBaNDq1q0rxxxzjJxwwgmm6qGOEd29e7d89913cu+99zLfNgAkIKcCUVW9enXp0aOHlEZTaTU1N5R1QnlM1APRRx99VJKSkuTyyy+XgoICc5sOqNVJujU4BQAkFrtptm5MzVXvvvuuGcKiV5e1sryVTaTjQy+++OJo7x4AII4D0URhKxCtXLmyPP744/Lggw+aAbEej0cOOOAASU1NlUiWwZ88ebKZ0+bMM8+U+vXrR2xbAABURO3ateXtt9+WF198Uf755x8zfYuOualUqULTd5dLe1xnzpwpDRs2lIEDB5ptAgAQq2wVK7Jo4KkpR1rWN1JBqF5Jvvrqq02lQZ27VJc+ffqYMaoAAIfoPGd2FxfTokU6TkfH7EQqCN25c6f07dtXLrnkEjM2ddasWSa1ateuXRHZHgCg7HlE7SxuZatV3Ldvn7z11lvyyy+/7Df5qfr0008lXHQy8LFjx5oeUWsem7vuukvy8/PDtg0AQACMEQ2Jlr7X6c10Xjb9t79mzZrJM888E7a3nE4Vs3DhQrMt7YlVetFWs5UAAM4gNdehQFRL++r4l5NPPlmaNGkikaRlg88///xik6nqOBsAgHMYIxqa/v37++ZyK9lOhnNoifaG6hylWrvBCkJVixYtwrYNAEBgBKIOBaI6SbeORenUqZNEks6Ds2DBAnO19+uvvza9oo0aNZJTTz21WINbkhZQsoooqZycnIjuJwAkPHpEg7ZhwwYzVnPVqlXltlXhoGX2NUPoqKOOkvfff9+MR9WaDaeffnqZQ2ZoIwEg/AhEHRojqhVz27RpI5G2Y8cO8/O5556TESNGmCu/77zzjhx44IEyZ86cMtfTx2r5YWvJysqK+L4CAGC1kTqFS6SDULV9+3bz87rrrpP//ve/Jg34scceM1lEGzduLHUd2kgAQNwGolos6JNPPpFI03lwlFbKnTJlikk9+v777+WII46QO++8s8z1hg0bZoJYa8nOzo74vgJAQvv/6VtCXUxPqstoEFqrVi1TNMipdlIzlLRd1iBT5/XWQn8jR44sdR3aSACIUI+onWJF4t7x/LZSczXd59JLL5XPPvvMVAIsWRChrMYvVDVq1JAGDRpI165di93erVs3Uxa/LDqnqS4AgDAhNTek1NymTZvKMcccY6Yb0yEl/rRd0zlGw0Gzk7QN1nbRou1fx44dZcmSJaWuQxsJAOFXJB6z2FnPrWwFoitWrJBevXqZ3kYdtxlJ55xzjkydOtVc3bUC3p9//tlMGwMAcAiBaNB2795tUmQ1OFy7dq1Z/IWzkFCdOnXkuOOOM+3iRRdd5Nu+9sZqoT8AgDMYI+pQIKqFipwyfPhwE/Rqg67FGDTlSMvST5482bF9AAC3o2pu8Jo3b+5oO/nCCy+YdrJfv36mh1SL+2l1+fKGsAAAwsvunKBe5hGNXdqYzpgxQyZMmCArV640U8fotDHp6enR3jUAAKKudevWpsK8DpfZsmWLKVakQWlycnK0dw0AgPD2iDpNx7MMHDgw2rsBAEBM0poKF198cbR3AwBcPoLFRo+ouFdcBKIAgChjjCgAAGU3k6TmhoxAFAAQEGNEAQAoG8WKQkcgCgAIjpvzhwAAKAc9oqFLsrEOAAAAAAC20SMKAAiMMaIAAJTbTBbZOD9eF59TAlEAQECMEQUAoGyk5oaOQBSu1OqWaY5sZ+lTXcUpiXZMTh0PYrNH1Ov1iscTehn8ffv2mUWn/bKzPgAAdlCsKHSMEQUABN0jamcJxapVq6Rfv36Smpoq6enpcuGFF0pOTk5Q627atEmaNm0qaWlpsmzZMl5VAIDjPaJ2FrciEAUABN8jamcJUmFhoZxyyimmNzQ7O1v+/vtvmTNnjlx66aWBd8/rlYsvvli6devGqwkAiFqPqJ3FrQhEAQAx4fvvv5e//vpLnnvuOalXr54ccMAB8sgjj8jHH39sekrL89RTT8nevXvlpptucmx/AQCAfQSiAICY6BH97bffpFGjRtKqVSvfbccee6z5OW1a2WOGZ82aJaNGjZK33nqLcaEAgKgo8tpf3IpiRQCAiFfNLTnOU4sJ6eJvw4YNUrdu3WK3Va9eXSpXrmzuK01ubq6ce+658vzzz5sg9p9//gl9JwEAqCCKFYWOHlEAQMR7RLOyskxQaS0jRowodTNFRUUhVdC97rrr5KijjjIFjvLz82XPnj3mdv2p1XMBAHACxYpCR48oACDi07do8aHMzEzfzSV7Q1XDhg1l48aNxW7btm2bGfvZoEGDUp/+jz/+kEWLFsm4ceP+3Zz33w127NhRrrzySjPeFACASNPm5/+boJDXcyt6RAEAEadBqP9SWiDao0cPk4K7YMGCYgWMtDdUez0t2vOpFXbVn3/+aX63Fn28mjdvHkEoAAD/b8uWLaadDJZe2N2+fXup92nG0erVq/dbCgoKJBQEogCAmJhHtFevXtKlSxcZMmSILFmyRH7//XcZOnSoXHDBBWb8p9JGVOcJfe2113jVAAAxo0g8tpdImjJliikCqPNs69CYwYMHlxswLl682MzhrY9t0aKF1K5d21Sw97dw4UIz5Ebb7K5du/oWnXItFASiAICYqJqrPZ8TJkyQxo0bmwZNx32edNJJ8vLLLxd7jPamVqpU+siSpKQkc7/+BADAzWNEN2zYIKeeeqqcc845smPHDhNA/vDDD+Yib1m+/PJLOfHEE2Xt2rVmeIxOoaaB6IsvvrjfYzXw9O8RDXUub8aIAgAiXjU3WPXr15f333+/zPs1yCwvtUhTeENJPQIAIFHHiL799tvmAu79999vLuBqD+fNN98s9913nzz22GOlDpPR+0tmK2lg+tVXX8k111xT7D5tbzVYrVmzpq3945IxACAmekQBAIj36VvsLJEyY8YM6dy5s6SkpPhu69mzp+Tl5cn8+fODfp5ly5aVWjSwTZs20qRJE3MR+Yknnii18n156BEFAAAAgCjKCWK+ba0iX9a82paMjAwzvlNt2rRpvwCyTp06vvuC8cwzz5gigm+99ZbvttTUVHnppZfk4osvNv/+/PPPTfqv9rqW7FEtD4EoACDi07cAAJDIirz/LnbWU1r8x9/w4cNNSq0/DQi1fkJ5Lr/8ct96Wi+h5JzaGsyq5ORkCeSjjz6S22+/XV599VXp0KGD73YtfqSLRceh6pRpr7zyCoEoACC8NHHITvJQZGsBAgAQI+wWHvJ6gp5v+9BDDzVFgYKlabP//PNPsdusHlUtDFie8ePHy6BBg+SFF14wlXYDOeCAA2TFihUSCsaIAgACY4woAAABixXZWYKdbztURx99tBknqhVzLV9//bVJ1z3ooIN8PaQl5wD99NNP5dxzz5Vnn31Wrrjiiv2et7SxoNOmTTPBaChIzQUAxEzVXAAA4pHdOUGLIpg7dP7558uIESNMz+ZDDz0kixYtkqeeekoef/xx3zRn8+bNk44dO8rkyZNNhdyJEyfK2WefLcOGDZOTTz7Z1wNbuXJlqVevnvm3Tv9Sq1YtOf74403A/MEHH8iHH34o7777bkj7RyAKAAAAAAkmLS3NBJh33nmnDBw4UGrUqCGjRo2Sq6++2vcYDTA1TdfqgdV5RDXgHDNmjFksBx98sHzzzTfm3zoGdfTo0XL99ddLbm6utG7dWn766Sfp0aNHSPtHIAoACIxiRQAAxNU8olYRpPJ6Ktu1a1ds3KmOCdWlPOnp6XLPPfeYpSIIRAEAwSHNFgCA0ptIm8WKvHYKHCUIAlEAQECMEQUAIHLTt7gRgSgAIDBScwEAiLvU3FjG9C0AAAAAAEfRIwoACIjUXAAAyuYVj1lC5Y3g9C2xjkAUABAYqbkAAJSpyOZ4zyIXn1MCUQBAQPSIAgBQNsaIho5AFIigVrdMc+z8Ln2qa0Idk1PH4/TrFLfoEQUAoOxmkmJFISMQBQAERiAKAECZirwes4SqyMXziFI1FwAAAADgKHpEAQABMUYUAICykZpLIAoAiARScwEAKLuZZIxoyOgRBQAE5PF6zRIqO+sAABBvtLmzM32L18XNJIEoACAwekQBACi7mfR6zBIqL8WKAAAAAABwRlz0iH7xxRcyceJE2bZtmzRt2lQuueQSadOmTbR3CwBcg2JFsWvv3r3y3nvvydSpU2XXrl3SunVrueKKK6Rhw4bR3jUAcA3GiCbg9C0PPvignHfeeZKVlSWnnnqqbNiwQTp06CAzZ86M9q4BgPtSc+0siKhBgwbJPffcI4cddpj069fPBKQdO3aUdevWceYBwCE6PtTu4lYx3yP6n//8R6677joZNmyY+V2D0mnTpsmHH34onTt3jvbuAYAr0CMam7QH9OOPPzZtpQak6owzzpDMzEz55ptvZPDgwdHeRQBwBXpEEzAQPeigg2TJkiW+37du3SqbN2+Wtm3bRnW/AMBVKFYUk9LS0kzG0OLFi323/fPPP7Jv3z6GsACAgwhEEzAQ1au8Q4YMMYFns2bN5O+//5Y777xTLr300jLXKSgoMIslJyfHob0FAMA5Ho/H9Hxq7YSvvvpKqlevLgsXLjRZQ127di11HdpIAEAsiPkxohMmTJApU6bI+eefLxdddJH06dNHnnvuOVm0aFGZ64wYMcI0xtaiV4sBABVPzbWzILLGjBkjq1evNqm5F154obRr106eeOIJk0FUGtpIAAg/xogmWCCqY190fOjw4cPl3nvvNcHo2LFjpVWrVnLXXXeVuZ6OJ92xY4dvyc7OdnS/ASDhUKwoJs2dO9cEnW+99ZbceOON5oLt559/LuvXr5enn3661HVoIwEgcqm5dha3iunUXJ2uZffu3XLggQcWu11/nzNnTpnrValSxSwAgPChdzP2rFmzxvz0bycrV65shrJoL2lpaCMBIPyKiv5d7KznVjHdI9q4cWNp1KiRvP/+++L9/8sFmmqk42ComAsADuJSb0zSKVs08Hz33Xd9ty1YsMBcrKWdBADn0EwmWI+o0sZVx73oBN3NmzeX2bNny8EHHywPPfRQtHcNAICoatCggbz66qtyww03mAJFNWvWNFOcnXbaaXLllVfy6gAAYlbMB6K9evWSZcuWmXEwW7ZsMelGbdq0ifZuAYCrMI9o7Lr44ovl9NNPN+2k1lbQac+aNm0a7d0CAFdh+pYEDERVamqqdOrUKdq7AQDuxTyiMS0zM1OOOuqoaO8GALhW0f9XzrWznlvFRSAKAIguT9G/i531AABIdFrPxqppE+p6bkUgCgAIjB5RAADKbiZtTsXidSAOnTp1qkyfPl1q1KghAwYMkDp16pT52E2bNskrr7yy3+06T7UOkbT7vHFXNRcAAAAAYI/OMX3qqafKokWL5J133jG1drSmQFk2bNgg9957r6nNk5+f71uKSswzE+rzloYeUQBAQBQrAgCgbF6b84h6IziE5bfffpNnn31Wfv75Z+nRo4dJA+7Xr59cd9118uOPP5a77tChQ01l9nA/rz96RAEAgTFBGgAAcdVMfvTRR6aSugaLyuPxyOWXXy4//fSTScEtj/ZyPv300/LVV19JYWFh2J7XH4EoACDoHlE7CwAAiU4r5tpdVE5OTrGloKBAKmrhwoUmYPSnv2sPpqbUlqV69eryxx9/yOLFi2XIkCFy+OGHy/r16yv8vCWRmgskiFa3THNkO0uf6ppQx5OoxxR2FCsCACBixYqysrKK3T58+HC5//77i922bt06GTNmTLnPd+SRR0qfPn3Mv/Py8vZ7Xi0sZN1XmoYNG5pA00rLffzxx800mjfffLO8//77tp+3NASiAICAGCMKAEDZvEVes4TK+//rZGdnmzmhLVWqVNn/sV6vKRxUnr179/r+nZ6ebnpX/e3YscN3X2lq165d7Pdq1arJRRddZMaEVuR5S0MgCgAAAABRlJmZWSwQLU2jRo3k4YcfDvo5W7duLd98802x25YsWWJ+lkytLU9SUlKxns6wPW/QjwQAuFcsVmEAACBBxohGwhlnnCELFiyQadP+NzTozTfflO7du0v9+vV907VocLty5Urz+59//lmsONHu3btN4aJevXqF9LzBoEcUABAQqbkAAERujGgk9OzZU6688ko55ZRT5PzzzzeFhDR4nDx5crFxpzpvqFbAbdasmfzyyy8mFVd/1/Tgzz77zPx85plnQnreYNAjCgAIvliRnQUAgARXVOS1vUTSK6+8Iu+9957UrVtX+vfvbwoRdezY0Xe/FiW6++67TRCqrrnmGvn000/lkEMOMYWLRo8eLX/99Ze0bNkypOcNBj2iAICA6BEFACC+ekQtWkXXqqRbkgaiJcedtmjRQq666iqpyPMGgx5RAAAAAICj6BEFAARmt6JChFOOAACIBbHcIxqrCEQBAIHZHe/p4gYWAOAeRV6vWeys51YEogCAgDz/P07UznoAACQ6b9G/i5313IpAFAAQUzlHEyZMkEmTJknlypXNXGVaQr48a9askXHjxsnSpUulSZMmppS8Vf0PAAAnePU/G22e18WpQxQrAgDEjDvuuEMGDx5sJsSuVKmSHHfccfLGG2+U+fjx48fLMcccI6tXr5Z27drJvHnzpHXr1iHPZQYAAJxFjygAICamb1m2bJmMGjVKPvnkExkwYIC5rXr16nLrrbeaXs7U1NT91jniiCNk/vz5pvdUXXvttVJQUCD33HOPmZQbAAAnaIptEam5IaFHFAAQfLEiO0uQvvrqK6lataqcfPLJvtvOO+882b59u0ydOrXUdZo2beoLQi2tWrWSTZs28aoCAByjabl2F7ciEAUABOTxem0vKicnp9iivZYl6RjPxo0bm5Rci4719Hg8prc0GLm5ufLee+9J7969eVUBAI7PcmZncSsCUQBAYEUVWEQkKyvLpNlay4gRI/bbxO7duyU9Pb3YbcnJyZKWlmbuC6SwsFAGDRokSUlJ8sgjj/CqAgAc4y3y2l7cijGiAICIy87OlszMTN/vVapU2e8xer+m4frTntNdu3aZ4DVQEHrhhRfK77//Lj/++KPUqlUrjHsPAADCjR5RAEDEU3M1yPRfSgtEDznkEBOwauquZe7cueZn+/bty9y3oqIiufjii+Wnn34y1XJbtmzJKwoAiMosZ3YWtyIQBQDERLGi/v37m8q4L730ku+2Z555Rg488EDp1KmT+X3v3r1mehdrehYNQvV37QXVRQsVAQDgtKIir+3FrUjNBQAEZveybQjraDrtmDFjTGA5adIkycvLM0WKvvjiC1OwyErBfeutt6Rr165y7LHHyvPPPy9vv/22HH300fLwww/7nislJUVee+01XlkAgCPsVsD1urhLlEAUABAT84iqgQMHSs+ePeXnn38207L06tWr2PhQDTDffPNN6datm/ldA1D9vSQtcgQAgJPziOpiZz23IhAFAMSUBg0amIC0NBpgao+ppUOHDmYBAADxhUAUABATqbkAAMSrIq/XLHbWcysCUQBAQJ6if5dQ2VkHAIB4wxjR0BGIAgACo0cUAIAy2a2AW0TVXAAAygtEQ5uKpdh6AAAkOK7Xho4eUQAhaXXLNEfO2NKnukqiHVPy5EaObMe7s0Dk5PA+p8frNYud9QAACMbK3ZFvJ3fm50QuNddG76bXxe1kUrR3AAAAAADgLvSIAgACI+cIAIBymkl7VXO9Lu4RJRAFAASm7aSdCrjubV8BAC6iabm2UnOL3NtQEogCAAJijCgAAGUjEA0dgSgAIMiquTau2rr3Qi8AwEW0Y9NO52aRi9tJihUBAAAAABxFjygAIDCKFQEAUHYzyRjR+OoRLSoqki+++EL69+8vrVq1kunTp5f6uM8++0x69+4t7du3l/POO0+WLl3q+L4CgKsVVWCBbfn5+fKf//xHjj76aNNObtu2rdTHvfjii3LUUUfJoYceKtdee61s2bKFsw4ADjLziNpcImndunVy+eWXyyGHHCI9e/aUsWPHlvv4J5980rQ3JZfWrVvLvn37zGOWLFlS6mPKiuViskd06NChMn/+fDnttNPkyy+/lN27d+/3GA1UzzrrLHniiSekW7duMnr0aHMS582bJ7Vq1YrKfgOA21CsKDrOOeccyczMlBNOOEHuvfdeKSws3O8xjz32mDzyyCPy6quvSuPGjeXOO++UE088UaZNmybJyclR2W8AcJuiIl28ttaLlIKCAjnuuOOkadOm8sorr8iiRYvkqquukj179siVV15Z6jqXXHKJic38DRgwQLKysqRSpUq+5122bJn89ttvUqdOHd/jtA2Km0BUG87KlSvL6tWry3zM/fffLxdccIHcdNNN5ne9MtywYUN56aWX5O6773ZwbwHAxUjNjYr//ve/pp38+uuvS71fvwyMGDFChg8fLueee6657d1335UWLVqYC7n65QEAEHl2eze9EewRff/9903A+Ouvv0rNmjVN5szixYvlgQceML2kSUn7J8fWrl3bLBbt/NOOwwcffHC/xzZv3lwaNGgQn6m52riWJzc3V+bMmSN9+/Ytts7xxx8vP/74owN7CABA7LaTv//+u+zYsaNYO6lfDNq1a0c7CQAu9+OPP0qXLl1MEGrp16+frF271qTXBmPMmDFSr149OfXUU/e775RTTpEOHTqY7J1Q03JjvliR9pTqVYKSkbb+/tdff5W5nl4h1sWSk5MT0f0EgIRHj2hMys7ONj9LayfLyjaijQSA2CtWlFMiXqlSpYpZKtpGlNY+KG0jdNxneTSF9+2335ZLL71UUlJSit2nwaf2qurwkQ8++MD0tk6cOLHYhdG4DkS1mJEqeeB6hbi0cTIWTVPSLmcAQJgQiCZMO0kbCQCxF4hmZWUVu12HXOgQRX9z587db/xmaWM8reGL2kaU1j6o8mIpy4QJE2Tz5s0m4PTXtm1bE3xatNdVg16tZZAwgag1+LVk9T89If4DY0saNmyY3HLLLb7f9QpDyRcXABACjXc8Ns4YVXMdayerV69erJ3s2LFjqevQRgJA+BWJV4psjPcskn/X0UBOexctpfWGHnjggWXWDLDUqFGjWBtRWhxl3RdMWm6vXr3Mdv2VVgivR48epkc0FDEdiNavX98EkFqRyT8v+ZdffjEVAcsSjq5sAMD/UDU3NmmwqV8ItJ084IADfPUV/v77b7niiitKXYc2EgBir0c0MzOzWCBa1ue3TpMSrM6dO8vIkSPNtCtWxdupU6dK1apVTS2B8mjq7qRJk0xqbjBWrFhRLAiO+WJFwdASw6+//rosXLjQ/K7l6f/5558yG1gAANxCpzE7++yzTbqtXuXWVCtNjapWrZq5HQDgXhdeeKEZ5/noo4+aujtr1qyRp59+WgYPHiypqanmMQsWLCh1DtA333zTBJZnnHHGfs+rs5foBVCr4q8GrBqjaVpw3PSIfvLJJ3LHHXf4cpQHDRokaWlpcsMNN5jFmmtUI/LDDjtM0tPTzZXfd955x0zKCgBwCGNEo0KvZOvF2F27dvnG4Wi5/eeff96XGaRfCPTLRqNGjUwbqulWn332WchXpgEAiTV9S8OGDWX8+PGm2NDo0aNl586dcvrpp8uTTz7pe4w1J+ju3buL7ZMGotq2WAGrv27dusltt90ms2bNMm2Sx+ORu+66y8xjHTeBaJ8+fUrNc9YrvBYNPF988UV54oknZOvWreaEWl3LAACHaOqQx0ZjaSNNCf+j2T9nnXXWfqdE20KLjg3VghLbt283XzI0INUvBQAA52iKbVEFUnMjGW+tXLnSTNlSWvqvpujqVC6NGzf23aZFjrSXs6w5QnXKlu+++85cJNV2p27durb2LaoRXUZGhlmCob2hugAAooAe0agoObF4ebQHlF5QAIjPMaKRpL2WTZo0KfU+raJbctypdgQGMxZVx5rqYhddiwCAIHj/DUZDRo8oACDxxWJqbqyL+WJFAAAAAIDEQo8oACAwUnMBACi7mSwqMkuovDbWSRQEogCAwMwYFooVAQBQajNps1hRkYuL+hGIAgAC8xb9u4TKzjoAAMQZxoiGjkAUABAYqbkAAMRl1dxYRSAKICa1umWaY9tKntzIke0UHrvWme1494b/SUnNTXh1f3xHMtOqRHw7G4+/NOLbABBeK3c70042S4t8O5m7Lzciz0sgGjqq5gIAAAAAHEWPKAAgMFJzAQAoU5H+Z6MuQpG4t5YCgSgAIDBTNNfGOBb3Dn0BALiupp+dMaLiWgSiAIDA6BEFAKDsZpJiRSEjEAUABGYm3LZx2dbFE3UDANyD6VtCR7EiAAAAAICj6BEFAARGai4AAGUqKioyS6iKXJw5RCAKAAiMQBQAgLKbScaIhoxAFAAQmKkEaKMEro0KggAAxBuvt8gsdtZzKwJRAEBANLAAAJTTTtIjGjKKFQEAAAAAHEWPKAAguDGidtJsdT0AABKdzR5RcfEQFgJRAECQASWBKAAApSnyFpklVEWMEQUAoLyWskjEY6OggosbWACAezBGNHT0iAIAAqNHFACAcprJIvHamBPU6+ILthQrAgAAAAA4ih5RAEBAepXXayM1181XegEA7kFqbugIRAEAgZGaCwBAOc1kka2Lr14XX7AlEAUABFde3kPVXAAASm0mi3QJvZ0scm8cSiAKAAi2R9RO1Vz3zo8GAHDZEBY7xYqK3BuJUqwIABBT9u3bJ3/88YfMnz9fvEEGsnbWAQDADfbt2yfTp0+XhQsXBr3Orl27ZPbs2bJs2bIKPaY8BKIAgKCLMNhZQvHLL79I06ZNZcCAAdKrVy9p3759wAbOzjoAAMRjOxkKDRTvv/9+admypfTp00fuueeeoNb78MMPpWHDhnLeeedJx44dTdu6bdu2kB8TCIEoACAwLaZgdwnSzp075ayzzpKBAwfKypUrZd26dZKVlWUauXCuAwBApIoV2VkiZcuWLb4Ltscdd1xQ6yxfvlwuuugiGTlypCxevFhWr14tmzZtkhtvvDGkxwSDQBQAEBNXeidOnCgbN26Uu+++2/yenJwsw4YNk5kzZ8rcuXPDtg4AAG7oEc3KyjI9ok2aNAl6nXfeeUdq1KghQ4YMMb9nZmbKDTfcIOPGjTMXf4N9TDBcUTXXGi+0T/aKMHQIQMnPiJ0FjpyTQu9eR7ZjPuv8PvvC8pzegpB6N0vuS05OTrHbq1SpYhZ/v//+u2k069Wr57utS5cuvvs05bYkO+ugOOt9kpvvzN9Bbm4uLwEQZ3bmF/8Mj5TcfZH/fMjLyzM/w11PYN+eXFuFhwr37Qy6nXSCtp2aapuUlFSsXS0oKDB1GDp37hzUY4LhikDUavSmysRo7wqAWHSyJOxnX/Xq1Sv0HJUrV5YGDRrI1PX2Pz+rVatmgkV/w4cPN1dp/W3dulVq165d7La0tDSz6H2lsbMOSm8j2wx7waFT8xQvAYCEaCP928lZ358d8XYyLy/PFOYrT+PGjaVFixa290XbTn0Of1Y7a7WrwTwmGK4IRBs1aiTZ2dmSkZEhHo8nqHX0qoS+IXQ97W5OBIl2TIl2PIpjig+x/jrpVV5tYPWzr6JSU1PNWJA9e/ZUaH9KfvaWdpU3JSVF8vPz91tXt60NfWnsrIOKt5Hx8HcQqkQ7HsUxxQdep/htI51uJ9esWSN33nlnuc919tlnmzRZu0prV3fv3m1+Wu1qMI8JhisCUe02DiU32p82RonSICXqMSXa8SiOKT7E8usUjqu8/o2sLpHWrFkzU2zIv0HW3wsLC01V3HCtg/C1kbH+d2BHoh2P4pjiA69TfLaRTraTrVu3lqlTp0Z0G9qulqyxoAGwstrVYB4TDIoVAQBigpaW19LvP//8s++2zz77zDTuPXv2NL9rwKmN8Pr164NeBwAAlE6LC2m7umPHDl+7OmvWLHNR179d1XRfnQYm2McEg0AUABATDjvsMDPtysUXXyzvv/++vPbaazJ06FC56667fD1UWghBA8xPP/006HUAAHCr3377zQSaOnZTp3PRf0+fPt13/5IlS0y7qgWIlE6Jdvjhh5u5ucePH2+maHnxxRfNT0swjwmGK1Jz7dC8bB0kHI1qVZGSaMeUaMejOKb4kIivU6wYO3asPPfcc+anjjN59tlnZfDgwcXSSLt3724m0Q52HURGov0dJNrxKI4pPvA6IZL0c23Xrl3m30VFRWaMqU698sUXX/gKJWm7aqUr6zRo3377rTz++OPywgsvmMdOmDBBTjrpJN9zBvOYYHi84a5dDAAAAABAOUjNBQAAAAA4ikAUAAAAAOAoAlEAAAAAgKMIREuhE7LOnj1bli5dKolCJ+j+66+/TInmRHuttPrXokWLJBHs3bvXvE6rVq2SRKAVThcsWCB//vmnmTw6Hm3evNm8x/RnWXQqkZkzZ5pqdIAb6JQ5Wrrfmjcu3mm5DK0cuXDhwgpNSh+LrCqZidKu6PeYOXPmyKZNmyRRjkfb/Xnz5kl+fr7E63dMfY+V9x1zxYoV5jMjLy/P0X1DjNNiRfif//73v97q1at7DzzwQG9mZqa3R48e3i1btsTtKfr000+9Bx98sLdJk/9r716AqqrWOIB/KoiGpqgomDwUUzFEMVNrfOLb8dWYWKRN+ErHV5ZmNT5rREqaSBnN1HxUmpovMHwMRApK0gMUtWwUo/BZaWKDZdi+8//u7HMPiN6Z7vXIOv5/M8zx7LM9nM05Z337W+tbazeyWrVqZXl7e1vz58+33EVMTIxVuXJla/jw4Zbp1q1bZ9WtW1c/e6GhodbAgQOtK1euWKbauHGj5evra4WEhFjh4eHWfffdZ82ZM8cyxfHjx62RI0da/v7+WNDN2rBhw037lJSUWKNHj7aqVatmtWzZ0vLy8jLqGIn+ibi4OP3Mo53CbXR0tHX9+nVj/5iJiYlWQECAtr34qVevnrbH7gBtVOfOnTVOzp071zIdzl9wHoOYEhwcbE2cONEy2cKFC/V4wsLC9LPn4+NjrVmzxjJFZmamNWDAAP3OIE7m5OTctM/Vq1etPn366HE2b95cb1evXn1XXi9VPExEnRQUFOiJ5OLFi/V+UVGRNg5PPfWUZaqEhAQ9obZ99tlnloeHh7VlyxbLdOvXr7fatWtnRUZGGp+IJicnW1WqVNGOEFtKSoqVn59vmejatWv6XXI+8dm5c6cGqqysLMsE+I6sXbtWg+itElF8v2rXrm2dOHFC72dkZOj3a8eOHXfhFRPdeampqZrU4BZOnz6tJ6ELFiww9s8/b94868yZM477y5Yt0/b42LFjlulmz55tRUVFWUFBQcYnougAwQBBdnZ2qfcKybaJjhw5orHFOe7jGPHZu3z5smUC/P0R73Jzc2+ZiI4fP16TbHtQB0kojtH53JTuXUxEncTGxuqIlHOjtnLlSsvT09PokamykFxPmzbNMtnJkyctPz8/TQDQ02Z6IhoREaEnC+7i/PnzGpR2797t2IbAim1JSUmWSf76669bJqLolUeQddazZ09r8ODBLnyFRK6D0U9UCjl7/vnntfLBXeAcACfKq1atskyWnp6uCSjaXtMT0eLiYq1We+211yx3kZaWprGlsLDQsQ2dmdhmWid0Xl5euYkoKiVq1KihnbbOAgMDrZkzZ7r4VVJFxDmiTnJycqRNmzZ6kVZb+/btdd4eavfdZa7I6dOnpWnTpmIqvB9PPvmkzJ8/X5o1ayamu3Tpkn72Bg4cKL/99pvOT75w4YKYrEGDBjJt2jS9aPLWrVtl165d8swzz0iPHj2kb9++4g7sduHhhx8utR1tBt5PIneEz3Z5n/lTp04ZOw+8vGO8ceOG0XESc9rR5q5Zs0YvNG86zC28cuWKxknMycccUcRLk3Xt2lX69+8vY8aMkZSUFNm+fbvGzQkTJkjjxo3FHWDeNeaElm0z2rVrxzhJiolomYSgbt26zpsc9/GY6TACPnbsWPH19ZWRI0eKqZDcPPDAAzJu3DhxB+fOndPbgwcPSosWLfQ9CgkJkcGDBxs9qR+fsUqVKsn06dPlpZde0gR78uTJ4unpKe4AJ0U4WS2vzXCH9oLoXoyTWGwFiQGShM6dO4upYmJiJDo6Wrp16ybu4OzZs3q7du1aiYiIkFGjRom/v7/GFJzbmAiDHpMmTdIOzRkzZugPFmB89tlnxV3YbQLjJN0KE1EnOEEuu2IZGgWoWrWqmG7ixImyf/9+SU5Olpo1a4qJDh06JEuXLtWGGiu04Qe9ovbKpiaudmgnZnhvsMIsenrRi4jEbfbs2WIi9Fh36dJFoqKiJD8/X/Ly8mTdunUydOhQSU9PF3dgv2/ltRnu0F4Q3WtxEsc1ZMgQjSObNm3SjjQToa3FKt69e/d2xEmsYI5Vc7OyssTk9hYj7wUFBZKbm6udtytWrJD3339fTIT3YsCAAZKYmKjJKOL+c889p50H7rLCMeMk/Tce/3WPe0hQUJCWfzizl6YPDAwUk6HXEIE1LS1NwsLCxFQ44UGJR3x8vGMbLt3i4eGhI6Xbtm3TEV+TBAQESOXKlWX48OHi4+Oj29DTixHRjIwMMdG+fft0NBedHzaU5TZv3lw7Qrp37y6mq1Wrlpa8lb18Be6b3l4Q3S5OlveZ9/Lykvr16xv7h0OihiQUl6H4/PPPjT4WQFnxnDlzSl1uJzU1VQoLC2Xv3r1imuDgYMdIr93hgZHRDh06aJwcPXq0mAbluI0aNZJBgwY5to0fP17Lc/FeYdTXHdoLu43A+2VjnCQbR0Sd9OrVS2vW0VDbduzYoSeVJs9FnDJliqxfv14bttatW4vJ0FNo9/DaPwhESHLwb9OSUKhevbqOHpY9ucPn0MTjAft1O3+XMMpw8eJFY4+pPD179tTE2lZSUiKffvqptiVE7gif7T179pSqPkGcjIyMLLW+golJKK5ziIoNPz8/MRnmhpaNkzgmJDYmJqGAcxccg3OcREkuSnZNjSl43ShdLS4uLjVVB1M+TD2msvCeYfAjKSmp1FolBw4cYJwkxRFRJwhEWHQBt6+++qqcPHlSFi9erHMSTC3RwXGglDUhIUFHqBCQAI0cRqeoYoiNjdUyKvQeYsQXPfJIaEw9aejUqZP2fmKUd9asWeLt7S3Lly/XRG3EiBFiApR8Hz16VE8K7JF3fH8wWo05vIARh44dO+riElh0Am0FyvteeOGFu/zqie5cdc3KlSvliSee0PnsqLJBBYSp1RswbNgwPTFGiSdKP/EDaI9RsUJ3Hzo53njjDW1bUQGFxXw++ugj7dxE+2sixMcFCxbI448/rnNF0bmzcOFCCQ0N1U5OE6AjANNvsAgmoGQa55pNmjSRhg0b6jYcE86rMfobHh6uFW04/zTlXIDurEpYOvcO/w6jFBUVyaJFi7R2H6V3KANBDb+p8Pox76AsNHLz5s0Td4DFcGrUqGH88aAsfMmSJdrjiyCL4Nq2bVsx+buEuS/Z2dkaYBFcp06dakzZKuYjv/jiizdtR0DFZ852+PBhefvtt3VOD4IrFmZylxUPicqDSoe4uDid046TTVTdPPLII0ZX2qCTrCwsiIfRRXeAZLtfv37Gl3uinHX16tUaX7C4H8pY7bJdEyHeY8ADnZ5IsBHz8X2yp+lUdJs3b5Z33nnnpu2I9fjM2dBhhc5ojIaisx1TqerUqePiV0sVERNRIiIiIiIicinOESUiIiIiIiKXYiJKRERERERELsVElIiIiIiIiFyKiSgRERERERG5FBNRIiIiIiIicikmokRERERERORSTESJiIiIiIjIpZiIEt0FR44ckX379vFvT0REVI7MzEzJycnh34bIjXnc7RdAdC9av3695ObmSteuXe/2SyEiIqpw4uPjJTg4WCIiIu72SyGiO4QjokRERERERORSHBEluoVDhw6JZVkSHh6u5UG///67dOjQQWrXrl1qvxs3bui+Fy5ckAcffFDCwsJueq4///xT9u/fL1WqVLlt725eXp6cOnVKAgICpE2bNro/ERFRRZSamioNGzYUf39/jZOVKlWSjh07SvXq1Uvt98cff8jBgwelqKhIWrduLY0bN77pufAY4qSPj88t4+Tff/8tX375pZw/f15CQkLKjbdEZA4mokS3sGzZMjl8+LAG0KCgIA18586d07mdLVq00H2QfPbt21d+/fVXeeihh+SLL76QXr16yYYNGxxJ5JkzZ6R79+5SUlIizZo1k2PHjmmief/99zt+19WrVyUqKkqOHj2qAfj777+XmjVrSnJysvj5+fE9IiKiCmfWrFni5eUlhYWFEhoaKt99953GPnTO2p22iGv9+/cXb29vjX0HDhyQyZMnS1xcnON5kMT27t1b412DBg2koKBAnxelubaffvpJBg0aJNeuXdNYiv+DpHbLli26LxGZh6W5RLdx4sQJ2bp1q+zevVuDHnpfFy1a5Hj85Zdf1qD77bffyq5du+Sbb76RPXv2yKpVqxz7vPLKK1K/fn05fvy4Pk9KSop89dVXpX7P9OnTtScZo6FJSUm6b2BgoG4nIiKqqPLz8zXx3Llzp3a0Xr9+XVasWOF4fNy4cdK+fXt9bO/evRoj33zzzVIL9k2YMEE7dbGQH0ZZEWexv7MRI0ZIp06dNN4iTqLD9uzZs6ViMhGZhYko0W1069ZNe3kBiWKXLl00OQWU7W7atEmmTp2qPb2AcqPo6Gj5+OOPHft88skn2vtbrVo13daqVSvp16+f43dgpPTDDz/UEVUE182bN+v/adSokaSnp/P9ISKiCmvYsGFSr149/TdGJlGaa8dJjGxmZWXJzJkzpXLlf59yIpnEQn0bN27U+z/88IMmsnaHLAwZMkRHPZ2TXZTtohwXI6CIk6gYwn3GSSJzsTSX6Dbq1KlT6j6CLEp14eeff5bi4mJp0qRJqX0QGNHra++DMiLn8iI7YUUJE1y8eFGfB6voovSobCJMRERkYpxEIgrlxUn7sR9//FFvy4uTNiSrkJGRIZ6eno7tqEhq27bt//mIiMhVmIgS/UNYUAFB8NKlS6W2477dO4w5MugFvnz5cql9nO9jLih6gceOHavzRImIiNyBHQsRF+vWrVtunLS3Iy7WqlWr3Dhpr6kwd+5cXUCQiNwDS3OJ/iH0ymLeC+aQOq+gu23bNi09gqpVq+o+27dvd+yD0U/MFXVORB977DFZvny5lvI6w0JHREREJmratKkuQOQcJ5FgpqWlOeIkVpvHAkXOcRIjoFhzwYZFifA877777k2/A/NEichMHBEl+h+89dZbEhkZqSOjSDgxZxQr4GKBIltsbKyuBoiRUQTTNWvW6BL0zpYuXSo9evTQ58J8G5Q1IVCjnGnJkiV8j4iIyDjojI2Pj5dRo0bpKCjKb9HpiuQzJibGsc/rr78ukyZNkl9++UUTzsTERO2kde74xSKAQ4cO1SkviKnYF/NEsS4D/i8RmYeJKNEt4JqhZRPGli1bSp8+fRz3H330Ufn66681uczMzNQ5nbh0i11yBLh0C+a1rF27VlcBnDFjhl5X1J4fAyg1wmN4nuzsbP3/U6ZMKfW7iIiIKhJcrgwL7d0udj799NN6CTR01OISZ0hAx4wZIx4e/zkFxdQUXIsUo6LoiH3vvff0eqG+vr6OfXAJGFwK5oMPPtB4iwX9EhIStBOYiMxUySpbC0hERERERER0B3GOKBEREREREbkUE1EiIiIiIiJyKSaiRERERERE5FJMRImIiIiIiMilmIgSERERERGRSzERJSIiIiIiIpdiIkpEREREREQuxUSUiIiIiIiIXIqJKBEREREREbkUE1EiIiIiIiJyKSaiRERERERE5FJMRImIiIiIiEhc6V9IPtcNCet+tAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "adj_path = dense_symmetric_normalized_adjacency(\n", + " path_edge_index, NUM_NODES, dtype=torch.float32\n", + ").numpy()\n", + "adj_ring = dense_symmetric_normalized_adjacency(\n", + " ring_edge_index, NUM_NODES, dtype=torch.float32\n", + ").numpy()\n", + "\n", + "fig, axes = plt.subplots(2, 2, figsize=(9.5, 8.0))\n", + "draw_graph(axes[0, 0], path_edge_index, title=\"Train / hold-last: path\", layout=\"path\")\n", + "draw_graph(axes[0, 1], ring_edge_index, title=\"Known future: ring\", layout=\"ring\")\n", + "\n", + "im0 = axes[1, 0].imshow(adj_path, cmap=\"viridis\", vmin=0.0, vmax=1.0)\n", + "axes[1, 0].set_title(r\"Normalized adjacency $\\hat{A}$ (path)\", pad=10)\n", + "axes[1, 0].set_xlabel(\"node\")\n", + "axes[1, 0].set_ylabel(\"node\")\n", + "fig.colorbar(im0, ax=axes[1, 0], fraction=0.046)\n", + "\n", + "im1 = axes[1, 1].imshow(adj_ring - adj_path, cmap=\"coolwarm\", vmin=-1.0, vmax=1.0)\n", + "axes[1, 1].set_title(r\"$\\hat{A}_{\\mathrm{ring}} - \\hat{A}_{\\mathrm{path}}$\", pad=10)\n", + "axes[1, 1].set_xlabel(\"node\")\n", + "axes[1, 1].set_ylabel(\"node\")\n", + "fig.colorbar(im1, ax=axes[1, 1], fraction=0.046)\n", + "fig.tight_layout(h_pad=2.4, w_pad=1.2)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "18-7", + "metadata": {}, + "source": [ + "## Train\n", + "\n", + "Fit per-node and networked operators under the shared protocol.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "18-8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-21T02:11:06.554633Z", + "iopub.status.busy": "2026-07-21T02:11:06.554564Z", + "iopub.status.idle": "2026-07-21T02:11:08.438515Z", + "shell.execute_reply": "2026-07-21T02:11:08.438056Z" + } + }, + "outputs": [], + "source": [ + "models = {\n", + " \"pernode\": make_model(\"pernode\"),\n", + " \"graph\": make_model(\"graph\"),\n", + "}\n", + "histories = {\n", + " name: model.fit(seq, epochs=EPOCHS, lr=1e-2) for name, model in models.items()\n", + "}\n", + "\n", + "predictions: dict[str, dict[str, list]] = {}\n", + "gap_curves: dict[str, np.ndarray] = {}\n", + "rows: list[dict[str, float | str]] = []\n", + "\n", + "for name, model in models.items():\n", + " hold = model.predict(origin, steps=horizon)\n", + " rewire = model.predict(\n", + " origin, steps=horizon, future_topologies=future_topologies\n", + " )\n", + " predictions[name] = {\"hold\": hold, \"ring\": rewire}\n", + " gap_curves[name] = latent_gap_curve(model)\n", + "\n", + " with torch.no_grad():\n", + " z0 = model.encode(origin)\n", + " z_path = model.koopman.advance(z0, edge_index=path_edge_index)\n", + " z_ring = model.koopman.advance(z0, edge_index=ring_edge_index)\n", + " one_step_gap = float((z_path - z_ring).abs().mean().detach())\n", + "\n", + " rows.append(\n", + " {\n", + " \"model\": name,\n", + " \"final_train_loss\": float(histories[name].loss[-1]),\n", + " \"rmse_hold_path\": mean_rmse(hold, targets),\n", + " \"rmse_known_ring\": mean_rmse(rewire, targets),\n", + " \"latent_advance_gap\": one_step_gap,\n", + " }\n", + " )\n", + "\n", + "graph_model = models[\"graph\"]\n", + "spec_path = graph_model.koopman.spectrum(path_edge_index, NUM_NODES)\n", + "spec_ring = graph_model.koopman.spectrum(ring_edge_index, NUM_NODES)\n", + "truth_field = field_matrix(targets)\n", + "\n", + "row_by_name = {str(row[\"model\"]): row for row in rows}\n", + "assert float(row_by_name[\"pernode\"][\"latent_advance_gap\"]) < 1e-6\n", + "assert float(row_by_name[\"graph\"][\"latent_advance_gap\"]) > 1e-6\n", + "assert gap_curves[\"pernode\"].max() < 1e-6\n", + "assert gap_curves[\"graph\"].max() > 1e-6\n", + "# Stable demo: both models should track path targets under hold-last.\n", + "hold_pernode = float(row_by_name[\"pernode\"][\"rmse_hold_path\"])\n", + "hold_graph = float(row_by_name[\"graph\"][\"rmse_hold_path\"])\n", + "assert hold_pernode < 0.25, f\"pernode hold RMSE too high: {hold_pernode:.4f}\"\n", + "assert hold_graph < 0.25, f\"graph hold RMSE too high: {hold_graph:.4f}\"\n" + ] + }, + { + "cell_type": "markdown", + "id": "18-9", + "metadata": {}, + "source": [ + "## Evaluate and results\n" + ] + }, + { + "cell_type": "markdown", + "id": "18-10", + "metadata": {}, + "source": [ + "### Aggregate metrics\n", + "\n", + "Left: one-step latent gap (primary claim). Right: forecast RMSE vs path targets\n", + "(sanity check that both models stayed finite — not a coupling test).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "18-11", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-21T02:11:08.439647Z", + "iopub.status.busy": "2026-07-21T02:11:08.439579Z", + "iopub.status.idle": "2026-07-21T02:11:08.555459Z", + "shell.execute_reply": "2026-07-21T02:11:08.554984Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model train_loss RMSE hold RMSE ring |Δz| 1-step\n", + "pernode 0.0038 0.0814 0.0835 0.000e+00\n", + "graph 0.0039 0.0584 0.0629 1.774e-03\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\n", + " f\"{'model':8s} {'train_loss':>12s} {'RMSE hold':>12s} \"\n", + " f\"{'RMSE ring':>12s} {'|Δz| 1-step':>14s}\"\n", + ")\n", + "for row in rows:\n", + " print(\n", + " f\"{row['model']:8s} \"\n", + " f\"{row['final_train_loss']:12.4f} \"\n", + " f\"{row['rmse_hold_path']:12.4f} \"\n", + " f\"{row['rmse_known_ring']:12.4f} \"\n", + " f\"{row['latent_advance_gap']:14.3e}\"\n", + " )\n", + "\n", + "labels = [str(row[\"model\"]) for row in rows]\n", + "gaps = [float(row[\"latent_advance_gap\"]) for row in rows]\n", + "hold_rmse = [float(row[\"rmse_hold_path\"]) for row in rows]\n", + "ring_rmse = [float(row[\"rmse_known_ring\"]) for row in rows]\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(9.5, 3.6), constrained_layout=True)\n", + "axes[0].bar(labels, gaps, color=[\"#4C78A8\", \"#F58518\"])\n", + "axes[0].set_ylabel(r\"mean $|z_{\\mathrm{path}} - z_{\\mathrm{ring}}|$\")\n", + "axes[0].set_title(\"One-step latent advance gap (primary)\")\n", + "axes[0].set_yscale(\"symlog\", linthresh=1e-8)\n", + "\n", + "x = np.arange(len(labels))\n", + "width = 0.35\n", + "axes[1].bar(x - width / 2, hold_rmse, width, label=\"hold path\", color=\"#4C78A8\")\n", + "axes[1].bar(x + width / 2, ring_rmse, width, label=\"known ring\", color=\"#F58518\")\n", + "axes[1].set_xticks(x, labels)\n", + "axes[1].set_ylabel(\"mean RMSE vs path targets\")\n", + "axes[1].set_title(\"Forecast RMSE (sanity check, not coupling)\")\n", + "axes[1].legend(frameon=False)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "18-12", + "metadata": {}, + "source": [ + "### Latent advance gap over the horizon (decisive evidence)\n", + "\n", + "Encode once at the origin, then advance two latent copies — one under path edges,\n", + "one under ring edges — with **no** decode. `pernode` must stay at numerical zero;\n", + "`graph` must separate. This is the direct answer to the notebook question.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "18-13", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-21T02:11:08.556605Z", + "iopub.status.busy": "2026-07-21T02:11:08.556511Z", + "iopub.status.idle": "2026-07-21T02:11:08.728213Z", + "shell.execute_reply": "2026-07-21T02:11:08.727822Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "steps = np.arange(1, horizon + 1)\n", + "fig, ax = plt.subplots(figsize=(7.5, 3.4), constrained_layout=True)\n", + "ax.plot(\n", + " steps,\n", + " gap_curves[\"pernode\"],\n", + " marker=\"o\",\n", + " markersize=3,\n", + " color=\"#4C78A8\",\n", + " label=\"pernode\",\n", + ")\n", + "ax.plot(\n", + " steps,\n", + " gap_curves[\"graph\"],\n", + " marker=\"s\",\n", + " markersize=3,\n", + " color=\"#F58518\",\n", + " label=\"graph\",\n", + ")\n", + "ax.set_xlabel(\"latent advance step\")\n", + "ax.set_ylabel(r\"mean $|z^{\\mathrm{path}} - z^{\\mathrm{ring}}|$\")\n", + "ax.set_title(\"Topology sensitivity of the linear step\")\n", + "ax.set_yscale(\"symlog\", linthresh=1e-8)\n", + "ax.legend(frameon=False)\n", + "plt.show()\n" + ] + }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "markdown", + "id": "18-14", + "metadata": {}, + "source": [ + "### Physical forecasts: finite rollouts under hold-path\n", + "\n", + "These panels are a **sanity check**, not the coupling test. With the conservative\n", + "Schur factor bound, both models stay finite and pass a coarse mean-RMSE gate, but\n", + "they typically **damp faster** than the true path diffusion over the forecast horizon.\n", + "\n", + "The `|ring − hold|` maps are mostly **endpoint-dominated** (decoder sees the rewire\n", + "at nodes 0/11). A small gap for `pernode` is expected from decode-only topology\n", + "changes. A somewhat larger / more persistent gap for `graph` is consistent with\n", + "decode **plus** linear coupling — still secondary to the latent `|Δz|` curve above.\n" ] - }, - "metadata": {}, - "output_type": "display_data" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "max |sorted |λ| difference| = 2.2013e-02; Hausdorff distance between eigenvalue sets = 2.8137e-02\n" - ] + "cell_type": "code", + "execution_count": 8, + "id": "18-15", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-21T02:11:08.729358Z", + "iopub.status.busy": "2026-07-21T02:11:08.729284Z", + "iopub.status.idle": "2026-07-21T02:11:09.259221Z", + "shell.execute_reply": "2026-07-21T02:11:09.258715Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA8AAAAF0CAYAAADsElDRAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAh3VJREFUeJzt3Qm8THX/B/DvXHv2fd9J9i1bCiVkL2tUKEmSCElS9KREilJRKRWyJYRkl6wp+xJCyJp93+6c/+vzqzP/mbkz956ZO2fmzJzP+3nNoztzzpnfnO17frtD0zRNiIiIiIiIiGJcXKQTQERERERERBQOzAATERERERGRLTADTERERERERLbADDARERERERHZAjPAREREREREZAvMABMREREREZEtMANMREREREREtsAMMBEREREREdkCM8BEFnHkyBEpV66cfP/992H93vPnz6vvnTx5clRu32zRnv7kmDt3rvrtODcTey9S1q9fr9KCf5NK35kzZ6RPnz5Su3Zt9fmSJUvU+9u2bZMOHTrI3Xffrd6/du1a2H9HNBo4cKD07Nkz6PVXr14trVu3lsqVK0vVqlXF6u677z4ZMmSIWFU40xfJfXHz5k11nX722WcSzbz3Ie5PuBbWrFkT0XQR2QUzwEQmi4+PVwFbf5UvX15q1aolzzzzjGzatMm13I0bN2Tnzp1y9uzZsB6T27dvq+89ffp0RLd/8uRJtX+mTp0qVmL2/rGyc+fOqd+OczOx9yLl8uXLKi34N6n0PfHEE7Js2TIZMWKETJs2TWrUqCEXL16UBx54QFKnTq0eqPF+mjRpIvBLosuOHTtk1KhRquAgGIcPH5YHH3xQ8ufPL19++aVMmjRJLl26pK7/L774Qqxo9+7dcvToUbGqcKYvkvvC6XSq6/vUqVOmfo/Z56P3PsyePbtUq1ZNFdJpmmbKdxLR/0vp9t9EZAIEMwTshx56SN59913196FDh+TNN9+U6tWryw8//CBNmjSJ2L7PmjWrbN++XfLmzSuRdOvWLbWfUBJO1vXwww+r2tJChQpJtKQPmeGffvpJ3nnnHbn33ntd7//444/qfOvXr59UqFAhQimOPv/73/9Ura37vgzEokWL1DFBLXK+fPlcLS1w/f/zzz8hTi3FEhRQIV7lzp3b9ILrcJ+Pffv2ldKlS8v8+fOlefPmYfteIjtiBpgoTDJnzqxKlAG1wDVr1lQP6YMHD45oBjhFihSudBElJUuWLOoVTek7fvy4KnjKlCmTx/vHjh1T/3q/T/6dOHFC5syZI6NHjw56N+F4cL9TMBwOR8zGq7vuuksV3o0bN44ZYCKTsQk0UYTkyJFDSpQoIXv27Enw2ebNm6Vt27aqlqVjx47yxx9/uD67evWqCpJDhw712TysXr168vzzz7veW7p0qWqqiAx3w4YNVYbbvZY1sT6uCxYsUOuiaRZqsPHQiz5YukqVKrmadlepUkVatGghX3/9dcBNuPB70SQS3n77bdc28d/uJfKff/65KizAdzVu3Fg+/fRT9b6vftToF/rII4+ofYXmr7t27UrwvUa26Y/Rda9fv65+B2rL8Bo5cqRaBscWzXGDOaa+4Pjht6Op9oQJE+T+++9Xx3zQoEGqqa83LPfqq69KnTp11HfjOK9cuTLJ3+2vjy1+59ixY9X+wPbatWunalhh+fLlap0VK1Yk2B764OKzmTNnJtlstnv37upcxL5euHChofShpQXOe/2/3bsj6H3wGjVqpP5+5ZVXXNtBX+APPvhAfYbj26xZM/n222997nNcT9988400aNBAFW7p/vzzT+ndu7fcc889Kt1du3ZNcB4++uij0q1bN9Xksn///qppNrbjryvA/v37VU0R+hBiu7169VL7xp2R78U62A7OEyz31FNPyW+//SZJQYsVtNbA/cCXdevWqesN34vz/aWXXnJleAGtXj766CPXf2P/4XcjDTBmzBjX8cG9yt3ixYtd/bX1PpQXLlxwfY7joN/LUHunL4tzEeeZEfht7733nrou0F8c5wze8yepNOnQ5/zxxx9XvxnnI+4DuGZ0uGd+9dVX6jzD+YbzDteT93eblb7k7gsj6Xc/PnqMw/n+wgsvuNKEbkE4Xkjvk08+6XHu+OsDHOhxx7mmn2Pod4s0416u37sRk0NxPga6DwHXFbaL+wERmUgjIlPdunULuUGtffv2Hu/Hx8druXLl0goWLKj+3rdvn1quV69e2sMPP6wtXLhQW7JkiVa5cmW13OXLl13rPv7441rmzJk93oMffvhBbWPq1Knq77lz52pxcXHa4MGDtbVr12orV67Uhg8frtWvX9+1zj///KPWGT16tMe2kI4UKVJo/fv315YvX64tXrxY69evn/biiy+6ltmxY4e2fft29cL2R44cqd1xxx3aa6+9luT23V25ckVbunSpWm7QoEGubR47dkx97nQ6tUceeURLmzat9t5772lr1qzRxowZo76refPmal+678Nnn31Wa9KkidqHeNWtW1fLmDGjtmXLFtd3Gt2mr/QbXRf/NmjQQMuUKZM2fvx4tRz2P/ZtmjRptN69ewd8TP1B+rBcnz591HH65ZdftEmTJmm5c+fWqlSpol27ds217NGjR9V5V6JECW3GjBnazz//rD3zzDOaw+HQPvnkE9dyEydOVNvEfk3svfPnz6vzNGfOnNrHH3+szoWZM2dqzZo103788Uftxo0bKh0tW7ZMkG58b+rUqbXTp0/7/W2HDx9W61eoUEGbM2eOOh9xPWE/Ii24TvylD78VacB7OC/1cwsv/I33Fy1apP4+cuSIWufixYta1apVtfz582tffPGFtm7dOm3s2LFahgwZ1L713ue4JvDCftSPKdKYPn16dR7i+/FZly5d1DmC80CH78H5ifMJacdnPXv2VNvFsXeH34n169Wrp33//fdqP2N/4/jqjHzv2bNn1W978MEHtZ9++knbsGGD9vXXX2s1a9bUdu7cmeh59thjj2nZsmXz+dnkyZPV/QbLIB2zZ8/Wypcvr47dn3/+qZbZtWuX1qNHD/X7fv31V7XfDx48qH6Lfv7qx+fvv/92bRvHKmXKlNqAAQO0VatWqX1TqVIlrUyZMtqFCxfUMsePH1fbeO6559S5N3/+fG3ZsmVarVq1tCxZsqjfnZRWrVqpffXBBx+o/YV72lNPPaVlz55d69q1q8eyRtIEr7zyitovOF9xDJGmgQMHqvuU+/WP6+Cdd95R34vjinsWjhFiiJnpC8W+MJJ+/fjgmm/RooW67nCMChcurDVs2FD77bfftKZNm6p7Ns7dYsWKadWqVfP4HtzHsI0333zT9V6gxx3noH6O4dp+//33VVr12IbvCMX5GOg+BKQd37tgwYIkjw8RBY8ZYKIIZICRMXr99dfV+3gQcs+83XnnnR4PPNu2bVPvIwOlQ9DGe5999pnHdzVu3Fg9nF6/ft31UFK6dOkEaUKGROcrg4eHYrw3atSoRNf15e2331YPQjdv3vS7fV+Q+cByyGh4Q2YKn33++ece7+OhHe9PmTLFYx8WLVrU9f36A02+fPlUxiHQbfpKv9F1p02bpv7+7rvvPJbDQyIym+4ZYKPH1B89M+b+UA36g5z7sezcubM6RocOHfJYtm3btipTf/LkyYAywM8//7wqLEGBiL/z5dVXX1XL6JlMwIMiMpXt2rVL9Ld16tRJPUSeOnXKoxDinnvuSTID7H5ejBs3zmO7+BvvIwPmDg+92D+7d+/2eF/ftv479X2OB3r3axu/GRnM2rVrq3S6Q+ETCgvcM8DIHOH4u8ODtPv5inM4T548WvXq1V0FLN772Oj36g/ZW7du9VgG67hfN77UqFFDq1ixYoL3L126pDIb7oVrgIINZC5QMKQbMmSI+n6sozt37px6DwVE3tavX68+w73FHc4HbFsvcNMzQoUKFfK4XpD5xvXm637mTi8oQaGHO2SQcIzcMyxG07R69Wq13NChQxN8n37ckOHzdY+cNWuWev/TTz81LX2h2BdG068fH2R43eOIfp9EAYx7QZ1+n8U+NJIBDva4w4cffqiWReFXqM7HQPahDtck1kGGmYjMwybQRGGCQXjQjKps2bKSLVs21bQKTf/QJModmoWlTPn/3fPRpPKOO+7waAaNpq1oZoa+QrqDBw+qwWUee+wx10i2GNgKzSHRJNZ9pFyMepuYGTNmSFxcnDz33HMJPnNfF9tGM8q6deuqQYTw+z755BPVTO3AgQMSKvPmzVN9lTt16uTxvv5b8bn3PkyVKpXr77Rp00r79u1l1apVrubAgW4zmPSgCTmOHZpiey/n3UzcyDHF3+5NePFC82J3aDLvDiOOlyxZ0uP34L8x+rH3QFZoBotmmfoUQUbhfEFTWpzb/s4XNF8GNBPXodkwzks00U0MBoVB08CcOXN69AXEfjHD9OnTVfNd9Mlz16pVK/Wvd/Nr932O6wZT/GCEV/wupNN7G2j+ib60uqJFi6rj7w5NQ92v+V9++UWtg2sS3+FrHxv9Xn3AOwzK99dff7mWwTru140vGKXeVx9wpA/dKdBs1R1Gt0XXCJzH7t0nAj0e4H2e4HzAcdKb2utwvbmP5l28eHHV5cR9f/o7z7Bvvc+rzp07q64IwaQJ1wb46sKgHzf92vTed/gdGKRQ/9yM9LVp08bjfoIm64F+l9H0u7/vHkdw3wM0Jca9WqdPj5XUcQv0uGMQSvxOdC2pWLGi+t0Y1Rz35L179yb5PUb3bSD7UIf9BRwMkshcHASLKEyQEcEDJx4y06dPLwULFlSZKG9431dQ9J6GBw/CTz/9tOrriofn8ePHq6DqHpTR/xOZph49eqjl8aCBjAQexvBg4A/6T+bJk0fSpUvndxn0KcRDuj51AzJTeuYP3xvK+VQxWBHS451xx/7DVCreU3L42odIH/YPMgAY9CjQbQaTHvRfwyi33hkWX+8ZOab6VFnuvPv3+vvtej9RbAOZmMKFCydYTn8vkClOkKnBlCTFihVLdDmkCyObojDm9ddfVxkt/D6kTe//7YueXn+/K9Twe3Dc8L3o464XVPzXYkpdv+6ZV/Del3qm8q233lL9iPV1AZlEwDZwDoGv34ZCMvdrXu/TnNh+Nvq9uA+8//77qvAN/SaxTRSI4NzDNZ2YDBkyyJUrVxK8rw8o5u+8wn7F79FHfQ4EfheuF70vt/vvwn7B/dSdkf3pC34DMjHeU2FhXe/vMJom/DfuNygISOx7MUgiXu5wruG36NejGelDIab7PUUfYCqQ7zKafl2BAgV8Zvr8vW90Cjojxx0Fs8hoY7TlF198URU+4TdiijTEMSNxy+i+DWQf6vRrC9cZEZmHGWCiCIwCnRhfmWLwrjFErRNKsVHjioE8MJ8mSsxRoq1DTQ0GF8LDL2qHMAjRhx9+qAb8wFye+gOGt4wZM6pMh/7A7wtq8vBQiwyvezBPrOY0WHgYwPyuviCd3jV1+sO+93L6toLZZjDp8bccBkrxVQOQ1DFFRgVTgLjzznD4++3670amHS9f6dL3EY6/UdgWHvCM1Fj07NlTjSA8e/ZsNY0JHrwxcIyvwgD37SOznNgxDSV8F74TA9a4D8LmzrvwyL3WCvR9PWDAANdgOt4wAF4g17x+TBLbz4F8Lx7+MfjQxo0b1b0BGWEUTuDYYCopf5CBxb3D33cndl4F+1CP9XBc0GLA17niXWtt9B7q63t8DRCFwhAMVBdMmnDc0MoB2/A3xzS2hWUw57h76x993+mFHmakb9asWR6ZPr12P9DvMpL+pI5PsMctkPUxry/uJYhTyIjqfA3Q54/RfRvIPtTp8xujIJWIzMMm0ERRCrWzXbp0UU3s0GwWpdz+mpLioQYjXWI0SmRcUTK9du1av9tGc1Y0hU3soQA1j9iud0k2RokNhv5wiIcoX7XneGDYsGGDx/to0omHGXzu7ueff06wDYxwjMyiXgMV6DaDSQ9qcZFh8R6BF81FgzmmyJh5N4H2zqx6/3Y8UO3evduVJhRooJZvzZo1CZqk6s2pE/vtvqApIZqXuzez96V+/fpSqlQp9dvwQlq8m016wzLYj8ikeRcaGBm1OlD4PvwejB6LpuPe+xsvvebWHzSDREZg3759PtfHyzvTnBR9m97NfZPzvcgwYN+iKwZaHeBaRoYoMTg30ITUu/AB28G+826Sj2OG44Tm8YlNN5XY9Y/7ETINyFz7+k04p0IBvw33Pe/rGteUdybMaJqwHPYBmoAn9r0Ygdj72sVoxKg91a9HM9KHZsLu7+u1sIF8l9H0WwHiFrqluGd+9dHjQ30+BrIPdb///rv6118BFhGFBjPARFEMTZuRiUGNDzJP3v0/Ma0OMrH69A74Fw+6ePB1r4Hyhr6gZcqUkWeeecYVkAHTpKD2GDDtAzJX+nQt2DZq8/zVGCcFTcXwgOxr2go0zUS/RfxevaklmnIifahJ1PuXuj/kuPc1xXQcyHSiaXaw2wwmPci84ndhOT3DgOZzmE7HXz/spI5pUjDtlX7MkElHWnBMUOOnw3QeSDemytGn5MBDGQpI0F8TTX8DgSa3mLYD07zoNZQ4H6ZMmeJR0IJ04PchQ4SMFpo++2oy6+3ll19W0/9gmiI9E4yaZGT0zPDOO+/IP//8o/rq4V8djvEbb7yRoBm6NxSyDBw4UPXzR42TnmY89P7666/q2AYK5xsyqmgVgMIDfZvY3/p5bfR78bCPbbgXWOCcQU1gYi0fQJ/+CAUS7nAcMf0Rrjs9k45zAGlDH0x9yil/cK7jN3q3cAB9+iDcl3D/0iETgv6YqLkOBXwPat7QRURv5o6uA2iq792812iacP2iyTm2iSmidLjPoaUHYL9h/+F6ROECoPAL9xkUMmKqK7PSF4p9YTT9VoC4hWbGehzDNYIpqbxrZENxPgayD3WIU7gGixQpEtLfTUSemAEmimKoocKcocjEtG7dOkFQxdyDw4cPVxlLLIummxjAB0E6sVoTlJAjk4Igj5JoZOqQkUMg1zNHqLnDgw0eftD3CsugtDup+WoTgwcRZKixPfd5gFFaj4w8fgf6feJhCzUVeEjB++6DIwEevJA5Qk0d1kXGCZkaZFB1gW7TndF1sb9R84PML/YPlsOgM8gw4sHL14BDSR3TpGCfIaOEfYh0bt26VQ3G5V7ggb5raBqPtGH7eEjDvJ2YN9N7rlsj0EwbNX/oO5srVy718Ibm9dj+nXfe6bEsarhxfqFmJanBr3RNmzZVGTo8WCK9eDBFBhqZPTOg+TkyeCjgwb7BccMxRd9BZOKNZNrRvxYFL8OGDVNNIVHThtp6FESgeXUwcGwxdzQy4dgm0oGaVffmkka+F8cLmXicI/oLLUT69evnGgTJH6yLDB0KN7xhblbMaYxB6HDtIfOD5dBUFO8lBb8NAwfh97jPu4rrBAOzYf5nnLvoT4tzDP+ixUmoahhxPWMOVlybuJ6xfzGvNfald9Neo2lCQRcKpdDHGjWHOI9wjeD+iYEDAccH9w0UYOB44XtxjuMawfv68TUjfaHYF0bTbwW4x6EgCOMt4HfhWKCW2lehVHLPx0D2IaD1EAqP3OMUEZnExBGmieg/7nOM+oNpIbCcr7kq//jjD7/rY15SXMorVqxIdNuYEsLXtm/fvq2+1988rFevXtX27t2r5nr19zm2jbl8Acthe/p0Fklt3xvW27Nnj8c8wO7wG7A/zpw5k+AzfbobfXoiTLODtLtPreFLYttMKv2Jres9ly1egGmG/E2xYfSYetOn5MGUIIB9d+DAgQTT4XjDeeVvH2EqEPx29ylLfL3nDvsBxyGx6bJKlSplaGonb5iiB9vW9zXmTEZa3OdO9pU+f9cW/sb7iU39g6l6sH98HV+cE1jffdoyX3AskG5fvxfXjvc0TIDj6GtaKcAxxRRWSd1TEvtefTs4JzFXMs5zozAnNabL0s81b9jf+F7vabZ0OP+x37ync9LXxf72nndVh3Rif2Hb3uvjOPi7VrFNf+nxBd+N5fXrB1NiYT/5klia3OEaw37BOeoP7p+4nyR1vzQjfaH4rsTS7+/4+LvHIq14H1PR6ZAGvOc+JVowxx3HAteePhUXpj/CNvQ4ForzMdB9iKmPcF9M7PwgotBw4P/MylwTkfkwiiVKkzF9Q7DNj2MFRjRFDSqat6EW2KpQy42mkagdQX/TUBxTNHtFLR9qYZPqoxpJGEAJU3uhuSTSTNEHjw2o5cII8KhtJqLkQfcD1J6jtZKVmowTxSqOAk0Uxb7//nvVp1QfUIisB3020ZRcHwEcfS3RdBdNSTF/st2O6ejRo1UTQoxATNEJ5yWahpoxCjeRXQuV0Fw6qT74RBQa7ANMFIV++uknFSjRnwkv9Lsja0IfWAyGgr5/qJnFCMyY1ggZCPcMbqwfU9RsoL80+hhjKq6k5g0ma0P/du/+3UQUHIyLgEJSX32DiSj02ASaKAphbsG///5bPYRicCX6F0ZPRrNhDFrib47jSMEoyRgJFJlgX/PsJveYYjRgNH9GJtqKD1H4bdgHGHAp2PlgiYiIiJKLGWAiIiIiIiKyBTaBJiIiIiIiIltgBpiIiIiIiIhsgRlgIiIiIiIisgVmgCkknn32WZ/zmQajf//+0qxZM0PLYq7XUH2vmZYuXapG/MUgSMm1ZcsWtS3Mp5oYTLVTqVIlj/cefPBBGTx4sKHvee+99wzt2xIlSsiwYcPEKm7fvq32z3fffSdWc++996prJRAYMfm+++4zLU1EZC6M7ov7cTBwDx46dKihZXG/R/y0unfeeUcKFCgQkm1NmDBB0qZNm+RyiH3ec8NjMD6Mxm9Ehw4dkty3p0+fVrEH8d4q1q9fr9KEqfWsAumZPHlysuJiuDRs2FCdrxR7mAEmIp+B/M0337RUxtauunfvLgcPHpSZM2dGOilERLazbt06lVHGVG5kL3gOeuutt+TUqVORTgqFGDPAFNVQ+rty5cpIJyPmfPbZZ6qEHiWzFFlp0qSRLl26yLvvvstDQUSJtg4aNWoU91CI4d7bunVryZ49O/etm/Hjx6vWDcm1evVqtS0rqlGjhhQvXtyy6aPgMQMcYWhagTlLx44dK2XLlpV06dKpG8qPP/6YYNlPPvlELYMH4nz58slrr70mTqfT9TmalKBpyfTp09VcoKlTp1bBUG+WgyatjRs3VjdxzDP63HPPyfXr1z2+46efflIXPJoUYR7Vtm3byuHDhz2WQW0UtoO0ZsuWTbp16yYXL15MkF400W3RooVkyZJFTfLeqFEj2bNnT1D7Cdt4+eWX5ZFHHpHMmTNL0aJFfTaBxk0KzZqmTJmimoPhv++8806P5jb6fLG9e/dWc67it6KJKfYP9hP2l1nQNKpWrVqSKVMmKVSokIwYMcJn5rN06dLq+OXNm1d69uyp5k9NzLFjx+Thhx9W+xn76oknnlDzwgZr4sSJ6th7W7x4sVSoUEGdg0j/6NGjRdO0BMvNmjVLqlWrps4R7GM0b7p69arHMjivHn/8cXUuYl5cnB/uzbpv3LghL730ksqIY1+gqTWOkff3Ia0IUFgGx3rGjBk+f1NS148/165dkxdffFGto38HmiW7QxNFpOHjjz9W35E+fXp1HSfWvG7RokUSFxcn+/bt83gff+N993tAu3btZOPGjbJz584k00tEImfPnpWOHTuqewviQMuWLVUMwf3IuzsJ4kb16tVVLEBhE6DwD5/hhThXt25d+eWXXzx2LZo1lylTRsVxxFzc7ypXruyzUBbpQazEfRMxrEmTJgliqxF//vmnShOeGe655x71nW3atPHZBBrxsXbt2qoWq1SpUuq+dPfdd8uaNWs8tomuOcjg4XPEpvbt20uvXr3UPddMiHXly5dX34uYN3v27ARxGrWumDsc917cY7Gvk7pv//7772rf4F6PedcHDRqkthUMHLcffvjBZzz86KOPpHDhwup7cN9fsGBBgmWQVsQt7H8sh98yfPjwBHHs119/Vc9ViN84RxHDT5486XGMEC/x/IbtVKlSJcH+wne9+uqrKqbiXK5Zs6barjc89+HcLVKkiCumffXVVxIp3k2g+/Tpo66jkSNHqvMC5wfO7eXLl3usFx8fr2pnS5YsqX4Hfg+eSdyhK5R+HWMZLDtkyBD1fOE+Rz0+x7p16tRRz1HNmzf3iL94zqAYo1FEDR8+HHdBrXr16tru3bu106dPa6+++qqWMmVKbefOna7lBg8erKVOnVr7/PPPtXPnzmnr16/XChYsqA0dOtS1zKRJk9S2qlatqm3dulW7ffu2ev+ff/5R7+fMmVNbuHChdvnyZW3t2rVa5syZtbffftu1/qZNm7QUKVKo70c69uzZo9WuXVsrVaqUdvPmTbXMrVu3tNKlS2v169fX9u/fr506dUrr2bOn2n7dunVd29q7d6+WKVMmrVmzZq7lunXrptJ87dq1RPdJv379tKZNm3q8h7Rin0ycOFG7ePGi6/2uXbt6fO+4ceNUWh544AHtjz/+0C5duqSNGDFC/S7sX13//v213Llza8uWLVPbmzlzpnbHHXeodbG/Qm3JkiVq2+XKldM2btyoXblyRZs+fbrmcDi0H3/80bXc119/raVKlUr78ssvtQsXLqjjVKRIEa1Vq1auZTZv3qy2tX37dvW30+lU50+tWrXUb8axGzhwoFqmYsWKHunAccPxTcyRI0fUuosWLfJ4H8cU5yC2rZ8f+E4s++abb7qW++qrr1zvYV9iv1euXFl7/PHHXcucPHlSy5cvn0oPzlUcg8WLF2t9+vRxLYPzJW/evNqKFSvUvpg2bZqWLl067f3333ct89NPP2lxcXHquJ8/f17bsGGDVqxYMfX9OKaBXD/+PPHEE2rZVatWqXTgOkuTJo32ySefuJYZMmSI+k4cp4MHD6rfg3MM59Tx48ddy+F66t69u+u4lSxZUp3v7vr27auOeXx8vOs9/Deupw8++CDJ9BKRpmJP2bJl1f0S94YPP/xQ3W+zZ8+e4F5aoEABdZ+5ceOGz12H+xjuZ+nTp9cOHTrkev/ll19W699///2uOPfCCy9oadOm1f766y/XckgHvnvs2LHq/oN7xN133601bNgwyUOF+Ib7i27fvn3qOxG/cM+8fv266zPc793vJ4iPWPaZZ57Rjh49qp09e1bdz7Du1atXXcvde++9Kj145sAyeC7AesWLFzf1uQfH6M8//1T3S8Ql3FcPHz7sWq5Xr15arly51O/EMt99952WIUMGj+cW3NOxng7pz5Ytm9apUyd178X2WrZsqb4P+8Mdjue8efMSTevs2bPVumfOnPF4H/EIMQUxG3EB8SF//vxqWcR73fPPP6++Z8qUKWq5lStXqt80ZswY1zKIW9gWjhPODfwGxJnRo0e77v84Pnjt2LFDpeWtt95S3/Xzzz+7tjNs2DAta9as2oIFC9T+mjNnjpYxY0a1HLara9y4sToHED/1/YpYNX/+fC0QiLs4twOF9OD3+YqL0Lt3b7UMzlU8j+D6xef4bdiHui5duqi4iFiP93Ge4NhPmDDB5/fiWlm9erVWtGhR7bXXXkvwzIN7A57HvJ9RcW/A57jGKXYwAxxheiDATc1dpUqVtM6dO6v/RsDEDR4Pxu6+/fZbFQyQoXXPAP/6668ey+kZYPeMg37zcA/ArVu3VjdYd7jgEbj1m9WMGTNUZvLvv/92LYOMNm4o7hnRp556St1M3DOreLhAhuajjz4KKgOMgObNXwbYPYgio4Gb5Geffab+RubTOwMDyLCYnQFevnx5guM8YMAA19944Hj66ad9BmA9w+udAcZNH38j8+uuQoUKQWWAly5dqraHDK47BGdk4N1hGe8MMB4CWrRo4bEczkmcR3h4g9dff13LkiWLOrd9wcMaMrbITHufG1gPxxTq1KmjtWnTxmOZuXPnemSAjV4/vhw4cEClGw877lDogwcIHR5Q8QDjvi38N9Lxww8/+A30eMBBwNYDLv7F37gveMO+79Gjh9+0EtG/kJHzdb9FhstXBhgFjkbceeedKhPrngHGfco9U4x4iEI4PMTrkEnwvifi3oaMsn4vCzQDjAy9N18ZYBQ06oXhgDiB9VHgDWvWrPH42z1TbGYGGPvN/f6P5wM8W+AZAxCH8ff48eM91kX8QoZS/03eGWBkjnPkyOGRiUGGEusEkwF+5513VCbSG+Krd6xGZtg9A4yMFX7n//73P4/l8OyBNOq/oUmTJurZy9+5gDT6ek7EuYGYDtgW0on0ukNGzz0DjIw6/kb8c4f46P38F8kMMOK8e4EUnjmxHtLv/uzh/Vw7cuRIVWCdGOx/93NbzwBjXV9QmIXPUbBAsYNNoC0AzbPQfMYdmiFv377d1UwLzTW8R0ZGs5HLly/L3r17Pd5HE1Vf0ATHHZrSuDeTxfehuZS7YsWKqaafetNU/IsmPGi2rUuRIoVqPuZuw4YNqskYmp/p0PwEzWI3bdokwfD3u7yhSRjSqEPTFjTn1n8rmpBhf3qnGc2FEoMmOHpTGn+v559/PtFtJHYM0ET4wIEDCY6B3g/X36jPeB/Npry3jabWwTh//rz6F03hvL/Hex+h6ZR7vyg0JTp69GiCcxXN7tBsa/Pmzerv3377TTVxQrp9QVNfNOfytS+QPnyHvzSh6Zs7o9dPypQpXcdRH1UU20e89pUONE9zby6PawJNtXT4b/zmxJqiP/nkkypterNtdF9Amp566qkEy+J46MeGiPzT75VG7/G+YguaO2ME2Fy5cqkuCbgv4F5x6NAhj+UQH9Gs2T0eIs7p8Tuxez+aol65csXUeIhmw0iT+/eCfl/CvkJs9p4xILF4qI+0n9QrsWa1aKbrfv9HGvAspKdr9+7dqomrr3sv9hm6YvmC34Pf4j4yNOI/mqgHA/dc71iIdCF9ScUexDnEMV+xB7FDbwKP5e6//361z3zBuYRm897PidiOfq5jW+gqlVSa8GyG72natGmCbW3dulX9Nn8wKKb78e3Ro4eK1e7vocl5KKCbG84Jf+et3rTb1749cuSI/PPPP+pvxNO+ffuqZ1mcE0gjuv95X8eJXVP68Wf8jS3MAFuAv5ueTu/v8sADD3jcaPSgi0yHOzx0+4IgHkxa3Puq+Orv6S/N33//fYKAiL403uk1yt/vCuZ3+vqtSf02ZKT+azXh94U+QclNW6DpMnpMjNIfSrz7dRv5Hv1cfeaZZzyOO343Hvb0Y49tJXXeG9kXgaQpqesHD3X6cfTuG2/kmBg979zhoeaxxx6TcePGqb/xL/ri4aHbG46HvwIDIkqav/uFd2zBPeGhhx5S/SyROcH9AOviAfnWrVtB7epg7g/hiodJxX1vKCxMKhbipfenDjZdVomHvsY4MUKPPTiP3GOPntEKJB6G8tkMyyL2uKepVatW6txObLRjTKHofnwRr5Apd38vFFM9Gjk/9H2LQnj336Fn+PV9izFUMLYNxoXBb0Mav/zySxXvjV5T+vFn/I0tzABbAErtvAe3QSmdPrpexYoVJVWqVGoAJV9Bxr2zfnJgMArvwTEwd9zx48ddacEyKF3Ta+AAJYbeAy2gBByDMvlKLwb/iSQM7IEbnXeasc8jCQMvoJTS+xhgCgbwN9oijglKJr0HGNPXC5ReUu5dwo7vwZyC7lAj4l7DiZp3lABjUBlfxx6DSYHeEuDChQs+04CgigDoa18gCOktEHylae3atR5/J+f60fe5r3SgBsN9QJ1godUAfgOCMs5BlKr7CvYo4Q+2FoPITvSaMgwcF8w9HoMooUUOBstBQRlqolBj593aSh+A0H0wK1yr+N5QjI4bDkgnWqGg9s9K8RCDH6Hm2te9F61r9IEwvSEmoLDavRDz3Llz8scffwSVDtxz8Yzm3toH6UL6koo9VatWVZkyFKL4ij36/O6IhytWrPCbBj3G79q1K8G+0M8zDMaFFndJpQnfhfTj9/hKEwbejAZoVQY4rr5+B1qYwapVq9SAYvrgo772SVL0ZyHG39jCDLBFdO3aVWVgMOIgStnQ5AUj4OpNPzB6JeYDXbJkiboZI9OBUq0GDRqELA0YPRCZktdff11tH6PRdu7cWZWwYVRIwCjMyEDifdwU0MwEoyl7Z5awLYyE+b///U+VxGEkXTTVwciDkyZNkkhnNDHCJdKGNKKJDGqr9Vq4SMK+//rrr9ULpY54CEGmEaWz/h6oHnzwQRUM0JxWP4cwcua2bduCSgMyl2iu5x0k+vXrp7aPbeP8wMOgdwk/gj1G6cTxx7y1ePDA70BzQtRs6g+KyPThOGBkTZwXOAY4t/UMMpoV4prA6J0///yzOuexPYyyjH2kl4bjfMKxQ4Yb34MHTzR3cpec6wcPWQieuBbxIIZ1v/32W/n888/Vw3Eo4OEGD0LI+OLBXX8ocod9hN+HWmwiShyuIzSNxH0eGTsUtOHe4WuUXl/woIsCOIwcj4ww7nuIgd4tQ/QML+6D6L6CeIh7GAqI9XuZ1aHGDM1GcX9Es15ktDA7AaamiSQULqKpKu73y5YtUzECox6PGTNGxRf3Zt3u8DtQKI9/URuJ5w/ExmCbmqMrF2q8vQuUEQe/+eYb9dJjHOKVO2RKUQOJ80N/1kAt5Lx58zya7iKW4DzVm+YibmLmCvxWwIjhyEzjd+AY4XPEWWwTsxkA9seAAQPUsVu4cKGKVXPnznVtQ4em1mjaj9iLjDmezbCPUEOK7UcLjL6O/YoWVDhXcXxxvHGO4FnD/V6AZwQ8o+LcxnNeoCM641kIxxIVFBQ7mAG2ADzsY7oGZC6R+cDFiovYPcODaQxwc8UDP5pHovQR0yDoN79QQIkZpm1BDS3SgZJCfBemvkENGiAQ4CFCLwFFRgmlxx06dPDYFjLNKInU++NgGgncqJAZcb85RQqGzkcAQFoQaN9//321bwNpWmaGTp06qSl2ENyQLkzdgaZ4ifWlQmYQ50vOnDnVMUSmDbX0mAIjWAgsmD7A+5iiCTvOEZQS169fX02/4R0UUDiCAIPzEzXCCBw4TzGFg943G2lFUMH5gAcMXAOYKgKZXh32A84rXBs4f/DAgUILTJGgw7QRmEoDQR/7C+cYlvGWnOsHmWtcmzhfkF5MeYTv81VTGyw8JGGaDn/bROYfD0DRUqtEFGkoRMT1gswd4hniGgrejNzfEddwD8O1jxYnKGREf2I0ZfWGewkK0nAvwv0NBXaIkZiSJVpgDALsIxSkosYbNeC4F0cyFgKmcUSmDPEIMQCFsLiPo0DTHyyHwk0UWuC34L6JzJKvgkUjcPwRh3EPdvfoo4+qaXqQGden+sNzhTfEMWTGX3jhBbUcWiShtY977MG5hfMGlQ7IsOH8Q2Gt/lyFwhjEXVQ+oE80WlnhmGG6QcRPHWIkvgsxGDH27bffVv12veF5AeshtuL3YZu4PvRnoGgxYcIE9Rvwm3HccaxRQI1KJB0KsRDz0ewc1yeer1FQEAgc+2gqHCBjHBgJy+CyZAJkdNBvNNh+sbEI8xiiWUtic6iaAZkk1BKEqg+LFeFBDoNk+AqK7lBDisFTUFId7IMDGYeHJDxIoebIe8AVZIxxLPAwqLfEIKLAoYAMsRaZjVBAhgFxyt8AhaGAee7xQsFbOGGQJBR4oxYxVmHQrWnTpiUYSMkbCvMRO9ElLBTdXih6oKscCvsxeCq6PVHsSBnpBBBFAprMoEkrSg+R4UAtN2ogUUpL/zYbRtMzlFKjmRWZBw/kyNyi+Zt35hc+/fRTVZPBzC+RcagJQpNlZG5Qg4YR1pHZiXQXHKvWpKFLSqNGjVTzYbQ4+vHHH8NeCG1VKDRu0aKFDB8+XD0nkH3gGQitDpj5jT3MAJMtockR+smgZB01vmg2jBJ29Bmjf6EvrXd/WgotnH+oXUATSn99inFO8rwkCgyaJKOpLAry0EcTXTiQKWZBUkLI3GGcA7S+Qp9n9IFGdxfvqXLsDOcO2U+kB20l87AJNFlOpJpA24HRJtBERBR5kWoCbQdGm0ATUexhBpiIiIiIiIhsgaNAExERERERkS0wA0xERERERES2wAwwERERERER2YItRoF2Op1y7NgxyZgxozgcjkgnh4go5mBK+UuXLkm+fPnUtDPBwtQ1mPs4EKlTp5a0adMG/Z0UGoy1RETREWvtHm9tkQFG5rdgwYKRTgYRUcw7cuSIFChQIOhgXLRofjlx4mxA6+XJk0cOHjwYE0E5mjHWEhFZP9aC3eOtLTLAqPmFQ8uHS6YMoT9g1yesE7Os+s28jPvq06lN2/buC9dN2/ZBxyHTtn3u9l+mbfvqzX9M2/at25dN23a885pp2xa5ZeK2NYle0dhSBfvb6brfBgMl0QjGfx2cJpky3WFonYsXr0qRoo+qdaM9IEc7/djv7fKIZEydKuTb/35NUTHLomNO07b9q3O9ads+cWGDmCld6nymbTtzOvOeb7I48pu27fTOTKZtO42E/rrRxZkYV5wmxtt4iTdt27fktmnbvukw5zk4Xrspuy/OSFasBbvHW1tkgPVmz8j8ZsqQLuTbT21CoNfdkSKNadtOE2fetlM6zLsZpnCYGCAcKUzbtsMRF6XbNi9oalo0ZvTCIXr3SyjOl4Du1U7zMi4U3LFH5jeTCXExnYnxMFWceedRnGbeo5bD5HuFmbElzmHefknhMK+AP6WZ2xbzth2tGWCHiRlgp4lDIaVwmBubQvVslsmm8dYWGWAiIooiCLJGA20MBWQiIqKwctoz3jIDTERE1qJp/76MLktERESMtwYxA0xERNbi1AIokWYGmIiIiPHWOGaAiYjIWmzaJIuIiCisnPaMt8wAExGRtdg0IBMREYWV057xlhlgIiKyFpsGZCIiorBy2jPeMgNMRETWogUQkLEsERERMd4axAwwERFZikNzqpfRZYmIiIjx1ihmgImIyFps2iSLiIgorJz2jLfMABMRkQWnQTI4vRGnQSIiImK8DQAzwEREZC02LZEmIiIKK6c94y0zwEREZC02DchERERh5bRnvGUGmIiIrEXTjI/ujGWJiIiI8dYgZoCJiMhabFoiTUREFFZOe8ZbZoCJiMhaOAgWERER461JmAEmIiJrsWmJNBERUVg57Rlv4yKdACIiIiIiIqJwYA0wERFZCwbAMlrSbHSwLCIiIvJk03jLDDAREVmKw+lUL6PLEhEREeOtUbbKAP/S85CkT5km5NtdffpOMcvmMzdN2/Z+50HTtv2PZt62r9w8adq2b9y6YNq2b8dfNW3bmmbeeWJuiZ+ZvTCiOWOk2TvNahokg9vjNEiWs3VrblNibSoTbxc1cqYybdtFr9czbdun0tQRM527ecu0bZ92XjZt22cc5j0nHHHsNG3bV2+fNW3bN29dMm3bt+KvmLbteKeJz05O856dNIk3bcuh3Zxmy3hrqwwwERFFAZsOykFERBRWTnvGW2aAiYjIWmwakImIiMLKac94ywwwERFZC+cBJiIiYrw1CTPARERkLTYtkSYiIgorpz3jLTPARERkwRpgowE5dgblICIiCiunPeNtxDPAFy5ckEmTJskff/whvXv3lpIlSyZY5vjx4zJ58mQ5efKklC9fXjp27CipUpk3YiMREUWQTUelNNvmzZtl2rRpkjlzZhk0aJDPZZYtWyZLliyR1KlTyyOPPCKVK1cOezqJiChMNHvGWzPnIEnSZ599JqVLl5Z169bJxx9/LEePHk2wzN69e1Wmd8WKFZIxY0Z56623pGHDhhIfb9bw4kREZIkmWUZflKSaNWvKk08+Kb/88ot8++23Ppd54403VKZX0zQ5ffq01KhRQ6ZOncq9S0QUq5z2jLcRrQGuVauW7Nu3T86dO+c3IL/88stSrlw5WbBggTgcDunatasUL15cpkyZIp06dQp7momIyGQoZXbar0TaTGPGjFGZ4IEDB8r8+fMTfH7o0CF58803VSxu166dei9HjhzywgsvSOvWrVWNMBERxRjNnvE2ojXAqNlNnz69389v3bolCxcuVE2ekfmFAgUKSL169WTu3LlhTCkREYWNTUukzYTMb2JQyJw2bVp5+OGHXe898cQTqiZ4zZo1YUghERGFndOe8TbifYATc/jwYblx44YULVrU4/1ixYolGpCxDl66ixcvmppOIiIKIZuOShlJaI2VP39+j5pexF4UPuOz+++/P8E6jLVERFHOac94G9Ea4KRcu3ZN/Yu+v+4yZcokV69e9bve8OHD1SAf+qtgwYKmp5WIiEI8D7DRF4Uk3nrH2pQpU0q6dOn8xlvGWiKiKOe0Z7y1dAY4Q4YM6t/z5897vI8+w8gE+/PKK6+o0aX115EjR0xPKxERhYjmDOxFIYm33rH25s2bKvPrL94y1hIRRTnNnvHW0hngQoUKqaC8e/duj/fxd5kyZfyulyZNGhWw3V9ERBQlbFoiHUlly5aVv//+Wy5fvux6T4+9/uItYy0RUZRz2jPeWjoDHBcXJ23btpWvvvrK1Rx6y5YtsnbtWmnfvn2kk0dERGaw6aAckdSsWTNJkSKFfPHFF673MD0h+gFXr149omkjIiKTOO0ZbyM6CNaGDRtk0qRJcuXKFfX3Bx98IN999500adJEveCdd95Roz5XrVpVKlWqJD/99JN06dJFmjdvHsmkExGRWQIpaY6hEmkzvfvuu2qqo3Xr1snx48fl+eefV++PGDFCzcaQM2dO+eSTT6RHjx6yfPlyVRO8ceNGmTdvniqMJiKiGOS0Z7yNaAYYA1Tddddd6r+RwdVh7kFdrly5ZPPmzbJo0SI5efKkmpMwqekciIgo2gOy03YB2UyFCxdWA1rpMVeHWl9d586dpU6dOrJy5Uo1GvS0adNUxpiIiGKU057xNqIZYARi72Dsr59RixYtwpImIiKKMJuWSJupXbt2hpZDk2fvqQeJiChGOe0Zby09DzAREdlRIKNNxk6fJCIiovBy2jLeMgNMRES2s2fPHjXKcb58+aRatWricDiSvY6mabJp0yY1mnK2bNnU4FFowURERGRHN2/elDVr1silS5dU3MybN29I1sGUuIi3mKrvzjvvlFKlSgWULmaAiYjIVk2yevXqpWYXqFWrlmzbtk1Kly4t8+fPV4NBBbvOqVOnpGHDhnL69Gm5++67Zd++fXL27FmZO3cuR1EmIiLbxdsDBw5IgwYN1FgT+fPnl19//VXGjBkj3bp1S9Y633zzjTz33HNSsWJFVdj8888/q3UwbkWqVKkMpY1DOxIRkW3mJZwzZ46MHz9eVq1aJYsXL5YdO3bIn3/+KcOGDUvWOu+9957K8KKWGMtjGcxc8NJLLyVrVxAREUVjvH3mmWfUmBK7du2SFStWqNl+evbsKQcPHgx6nfj4eDWLQb9+/VQtMWYq+P3332X27Nkq9hplqxrg1punisMR+jx/vPO6mMXpvGnatkW7bd6mJV6iU+x08CeKWoHMNxjgvISTJ0+W+++/XypXruyadaBTp06qRHn48OFBr3Pjxg01YrJeI4zm0QjimMXAbjrs/EUcjv8fXTpUUjrMa04e5zBWa2A1ZsdazXDfwMDd1m6Ytu342+Zt22nis1N8vHnPfE7tlmnbNuPZWhcXl9a0bWuOlFF37aCrjaZdtHy8PX78uCxbtky1gkqZ8t/9jGlsX375ZZkxY4b6N5h1nE6n3Lp1S4oUKeJar2DBgqrmF02njbJVBpiIiGKzSdbFi54PBOh766v/7fbt26Vp06Ye75UvX1712z1//rxkyZIlqHX69++vmmF17dpVTSWEJtCYtx6ZZyIiIjvF2x07dqh/y5Ur53oPmVp0H0JM9cXIOsjofvTRR/L222+rVldZs2aVqVOnSpMmTaRt27bGfgebQBMRUSw0yUIJMOaW11/+anMvXLig+gy5y549u/oXmdlg10EQRv/gpUuXyqxZs9QLQbtAgQIh2CFERETRE28vXLig/vUVOxOLtUbWwRS6GTNmlJkzZ6pYi65HNWvWNNz/F1gDTERE1hJEk6wjR45IpkyZXG/7G30Z71++fNnjPf3vtGnTBr3Oiy++KKtXr1b9ltAMGs20HnvsMWnZsqUtm0ETEZF9422a/95DrHRvWYW/UWDsi5F1zpw5I40bN5bXXnvNNcYGBs7CgFjonoRWWEZwECwiIrIWTQvsJaKCsfvLXwa4ePHicvjwYY/3Dh06pDKtuXPnDnodNH9GM2m9D3BcXJy0bt1atmzZ4re0m4iIKBbjbfHixdW/vmJnsWLFfCbFyDqY+gjTI7Vr1871OT6rWrWqGjTLKGaAiYjINqNSop8Q+uYigOoDiqAZFUqU9Xl9EXwxncL169cNr4MmYZgj2B3+zpAhg2oiRkREZJd4W7p0aTVQFWKlDqM179+/32NMDQx6hdGcja6DWAvu8RaDX6EWOJAuR2wCTUREtpmXsEePHjJx4kQ1Zy9Gcl6+fLns3LlTvvjiC9cya9eulQ4dOqgRKfPkyWNonVdeeUUeeugh6dy5s9SrV0/++OMP+fDDD+WNN95wZZKJiIjsEG8dDoeav7dNmzaqRVShQoVk9OjRqmVU3bp1XcsNGTJExdnatWsbWgf9fzHYFWJt3759VX9hDIJ19epVNV2SUawBJiIia8H0EU6DrwCnmkAT5XXr1qm+uevXr5cSJUqoProIqrrChQtL+/btJV26dIbXqV+/vsoUY13MF4xaYtQaDxgwIIQ7hoiIKDribcuWLVXtLqYtQnegwYMHy/Tp0z2WefDBB+Xee+8NaB200Bo7dqwcO3ZMNmzYoAqfUeis1w4b4dAQpWMchutGE7RUKXNzHmB3nAfYh5i/HIhMvHacahRH98ExgrlXnx/fXTKlMzbn68VrNyTLs58m63spNPTjlzVDJc4DHCacB9i3eCfnAQ7nPMBmzo1s5rY1U7dt7jzAyY15F20eb9kEmoiIrAXPDYabZJmdGCIiohjltGe8ZQaYiIhs0weYiIiI7B1vmQEmIiJL0ZyaehldloiIiBhvjWIGmIiIrMVtvkFDyxIRERHjrUHMABMRkbXYtEkWERFRWDntGW+ZASYiImuxaUAmIiIKK6c94y0zwEREZC02DchERERh5bRnvGUGmIiIrMWmAZmIiCisnPaMt8wAExGRpWhaAKNAcxAsIiIixtsAMANMRETWYtMSaSIiorBy2jPeMgNMRETWYtOATEREFFZOe8bbuEgngIiIiIiIiCgcWANMRETWYtMSaSIiorBy2jPeMgNMRETWgoGtjA5uxUGwiIiIGG8DYKsM8K3b/4iII9LJICKiRGjOf19GGF2Owufc5Z2mxFqHI1XIt/n/2zbvccjhMK+3mcPsnmwmpj1qmXjT0SQ6b2iaqTdi7hPPfR3aWljNpvHWVhlgIiKKAjZtkkVERBRWTnvGW2aAiYjIWmwakImIiMLKac94ywwwERFZil2bZBEREYWTZtN4ywwwERFZC/o4GS1p5iBYREREjLcBYAaYiIisBaXMRkuaY6hEmoiIKKyc9oy3lh/e79KlS9K/f38pU6aM5M2bV2rUqCETJ06MdLKIiMgkmlML6EWhsXbtWmnSpIkUKlRIihUrJu3bt5c9e/Zw9xIRxSjNpvHW8hngZ599VubOnStffPGFbNq0Sf3drVs3+e677yKdNCIiMrNE2uiLku3vv/+WBg0aSPHixWX16tWycOFCuXbtmtSvX19u377NPUxEFIuc9oy3ls8Ar1mzRh577DGpVauWqgF+8sknpWzZsup9IiKKQVqAL0q2LVu2yNWrV2XIkCGqBrhUqVLy0ksvydGjR+XQoUPcw0REsUizZ7y1fAa4RYsWsmDBAjlx4oT6e9WqVbJ//35p1qxZpJNGREQmsGuTrEiqWbOm5MyZU7766iuJj4+X69evy+TJk6VSpUpSpEiRSCePiIhMoNk03lp+EKzRo0fL448/rmp/06RJI5qmyWeffaaaZflz48YN9dJdvHgxTKklIqJks+mgHJGUI0cOWbRokTRv3lwGDRqkMsHlypVTTaFTpEjhcx3GWiKiKOe0Z7y1fA1wz549Vd9f1PweOHBAPv30U+nRo4f8+OOPftcZPny4ZM6c2fUqWLBgWNNMRETJn5fQ6ItC0we4cePG8sgjj8jevXtlx44dUrRoUfUeaoN9YawlIopumk3jrUNDlapFnT17VpVKT506VY1GqevQoYMcP35cVq5cabhU+t9MMPL7jrCknYjIXhBKnHLhwgXJlClTUFvAvRqFlid7tJNMaVIbW+fGTck9bkayvpdE3nzzTfnoo49UbI2L+7ds/MyZMyoGz5w5U9q0aRNArE1lSqx1OLBdczgc5jWIczjMq2twmF2PYWLao5aJuQAtSqvYNFNzRtwnnvsasfZqsmPeRZvHW0s3gcZBxitt2rQe7+Nvp9P/BYGm0ngREVH0CaSkOZZKpCMJMTV16tSuzC/gb4fD4TfeMtYSEUU3zabx1tJFe9mzZ1cDc6CZFZpnITOMWl+URjdt2jTSySMiIvMqk429LNuGKbqgqfOxY8dk1KhRcuvWLTUi9IABAyRjxoxy3333RTp5RERkBs2e8dbSGWCYMWOG5M+fX0qXLq1qfh999FF58cUXpX///pFOGhERmQAtvAJ5UfJVr15ddTf64osvVKYXBdAYf2PevHlqEEoiIoo9mk3jraWbQAP6E82aNUv9N/oasWkzEVFss2uTrEhr166deqEGGCM/uzeHJiKi2KPZNN5aPgPsjplfIiIbsOm0DFaRKpV5g00REZGFOO0Zb6MqA0xERLHPriXSRERE4aTZNN6yfRMRERERERHZAmuAiYjIUgIZbCOWBuUgIiIKJ82m8ZYZYCIishan49+X0WWJiIiI8dYgZoCJiMhS7NonKXbEi0joCyY0Dds1R/TWbLAAKPzYe5AiKbQ3K82m8ZYZYCIishRNc6iX0WWJiIiI8dYoZoCJiMhS7FoiTUREFE6aTeMtM8BERGS9QTmcsd50lYiIKLI0m8ZbZoCJiMhS2ASaiIiI8dYszAATEZG1OB2icRRoIiIixlsTMANMRESWYtd5CYmIiMJJs2m85VjuRERkySbQRl/Bun79uinraJomN2/eDDJVREREsRNvnU6n3Lhxw5R1EGsRcwPFDDAREVkKmj8H8grUnDlzpGjRopIhQwbJnj27DB8+PCTrnDlzRrp06SIZM2ZUyzRp0kQOHToUcPqIiIiiPd5ev35dunXrJunTp1exs1q1arJly5aQrLNo0SKpUqWKWiZv3rwycuRIlWk2ihlgIiKyZJMso69AbNu2Tdq2bSt9+/aVa9euyfTp0+XNN9+UiRMnJmsdlFQ/+OCD8tdff8nu3bvl0qVL0r9/f1myZElydgUREVFUxtt+/frJ0qVLZevWrXL+/HmpWLGiNG7cWMXH5KyzePFiad68uTz55JNy+fJl2b9/v1y4cEEVQhvl0IKpN44yFy9elMyZM/+X3w++uRwREfmDUOJUQShTpkzJulfvbf6EZEyV2tA6l27dlDvnTTL8vd27d5f169er4Krr2rWr/P77735Lpo2sM27cOHnxxRdVBjhPnjxiR4y1kcBnmvBj3RFFOtbeSlasDUe8RcY0R44cMnbsWFWjC1gvV65c8vHHH8vTTz8d9Dply5aVypUry+TJkyVYvIqJiMhSnE5HQK9AbNiwQe677z6P9+rWratqeVG7G+w68+fPlzp16qjMb7B9koiIiGIh3m7ZskW1jHKPnchwo0YXMTXYdQ4ePCi7du2Sdu3aqb8D7VusYwaYiIiivkkWSrPdX/6C4qlTp1QJszuULiPDevr06aDXQV/f3Llzy8MPP6xKxtEvqUWLFuwDTEREtou3p06dUv/6ip36Z8Gso4+rgdZWBQsWVPE2f/788u677wb0u5kBJiKiqB+VEoEQJcX6K7GBrbwHyrh9+7b61+FwBL0OMsNojtW0aVO5cuWKHDhwQDXdatWqVTL2BBERUWzFW0cisTapdfTWVZ988omsWLFCDZo1YcIEefXVVxMdy8Mb5wEmIiJLCWS6BX25I0eOePRJSpMmjc/lUVJ88uRJj/dQspwyZUrJmTNn0OtgGQRtvd8SaoMHDRokDz30kBw9elR9TkREZId4m/+/mIfYiRpc99hZs2ZNn9s3so6+TK9evaREiRLqvzFIVqNGjeSHH35QA2MZwRpgIiKyFKfmCOgFCMbuL38Z4HvvvVeWL1/u8R5GasZUC/o6t27dUqNP6iXNRtZBn2DvZmD6nMH+0kJERBSL8bZixYqqK9CyZcs8MrIYOwMx1X3gq6tXrxpeB5nefPny+Yy3gcRaZoCJiMg28xK+8MILcvz4cTVFEQbTQNOpmTNnyiuvvOJaZtasWZI1a1ZXra+RdTBSNJo+oxkWSsd//fVXGTx4sDRr1ixBfyYiIqJYjrdp06ZVUwcOGzZMFRjv2bNH1c4WL15cWrdu7VoOraQ6depkeJ24uDgVW0eNGqUyyseOHVOzMKCQukuXLobTxybQRERkKYHMNxjoYMtFixZVcwwOHDhQNalCSfI333yj5hTUpU6dWvVrQqA1ug4yuStXrpQBAwaomuHs2bNLkyZN5LXXXgssgURERDEQb4cMGSKpUqWSnj17qnl8a9eurTK27jW1GTNmlPTp0we0To8ePdS/ffr0UQNRlixZUubMmaMy00ZxHmAiIrLUPMCbH+wqGVManJfw9k2pvPSLZM+JSMnHeYAjgfMAhx8bT1LszAO82abxljXAREQU9YNyEBEREeOtESzGIiIiIiIiIltgDTAREVmK5jbapJFliYiIiPHWKGaAiYjIUtgEmsjw1cJdFXbx3OcUM9e8ZtMuR8wAExGRpTj/exldloiIiBhvjWIGmIiILMWuJdJEREThpNk03jIDTEREluLU8HIYXpaIiIgYb41iBpiIiCzFriXSRERE4aTZNN4GPQ2SpmmyZ88eWbhwYWhTREREtvZvDbDxV6y7dOmSrF+/Xnbu3BnppBARUQxx2jTeBpUBPnXqlNSpU0fuuusuadKkiev9Ro0aybJly8QM165dk9WrV8umTZvE6eSwJ0REsV4ibfQVy2bOnCmFChWSWrVqybhx49R7u3fvlkqVKpkWC//66y9Zvny5nDhxwpTtExGRNWg2jbdBZYD79u0r+fLlkzNnzni8P2jQIHnrrbck1L766ivJmzev9O7dW73uu+8+BmYiohjlFEdAr1h17Ngx6datm3z55ZcyevRo1/ulS5eWkiVLypw5c0L6fRcvXpRHHnlEKlasKG+//bYq6Ma/REQUm5w2jbdB9QFevHixbNu2TbJly+bxfuXKlWXdunUSSosWLZKnnnpKlYK3bt1avff777/LhQsXJE+ePCH9LiIiijxN+/dldNlYhVZPDz74oMqUfvzxxz7jbatWrUL2fY8//riq/T1w4IBkz55d1TAj9hIRUWzSbBpvg8oAX758WdKlS6f+2+H4/9IA1AinSZMmdKkTkWHDhkmzZs1cmV+oWrVqSL+DiIisAyNAGx8FOnZKpI3GWj3e6p+FwtatW2XevHmq0BmZX4iLi5P27duH7DuIiMhanDaNt0E1gb7nnntk8uTJHkH59u3b8vrrr6smU6Fy/fp1VcLduHFjOXnypOpfjL5PGIArMTdu3FBNudxfREQUHbQAmmNh2ViFfr/IkJ4+fdojA7xv3z6ZOHFiSOPtihUrVAF2vXr11Fgbq1atUt+bGMZaIqLoptk03gZVAzxy5Eh54IEHZMmSJSoz2qNHD5U5RSZ1zZo1IUscSrjj4+NVMzD0Lb7zzjvVKJhFixaV2bNnq37BvgwfPlzeeOONkKWDiIjCx65Nsryhr2+HDh1Un1wMhIUMZ9u2bWX+/PnSsGFD9QoVxG90a2rZsqUcP35c0qdPrzLCr776qgwePNjnOoy1RETRTbNpvA2qBrhKlSoqMBYuXFiVUG/ZskUaNGig3itXrlzIEpc6dWr172+//Sa7du1So1Lu379frly5Iv369fO73iuvvKL6COuvI0eOhCxNREQUniZZRl+x7IMPPpAxY8aoAt8UKVKoFk3vvvuuzJo1K6Tfg3iLjO+9996rYjoKs7/77jt57bXXZO3atT7XYawlIopuTpvG26BqgKFYsWIqMJspR44ckjFjRmnRooVkypRJvZchQwZVQv3tt9/6XQ/NuELdF5mIiMJDC6CpVSw1yfIHtb54mQkxXR8IS9e0aVPJnDmzmoMYXZ+8MdYSEUU3zabxNmUg/XGNSps2rYQC+jyh/y9qfd3hb0zDREREscep/fsyumwsQbefW7duGVo2ZcqU6hUKaMWFbSG+onUX/PPPP3Lp0iXGWyKiGOW0abw1HDkDGW0yqUGqAvHmm29KzZo11fy/tWvXlg0bNqhmWQsWLAjZdxARkXXYdVRKGDdunPTq1cvQsj179pSPPvooJN+LQuVBgwbJk08+qZo2ow/whx9+KBUqVFDTMBERUexx2jTeGs4Au8/vi/5AmJ6ob9++Uq1aNfXexo0b5f333/c7WEawMPAV5v1FkJ8xY4YaCAR9jcuXLx/S7yEiImuwa5MsQFPnu+++2/U34iz6/nbv3l0KFiyoamWnTJmi4mCfPn1C+t0YPBKxde7cuaogu2PHjvLss8+ySxERUYzSbBpvDWeAUQurQ23szJkzpX79+q73GjVqpJZBBhgBO5Qw6vN7770X0m0SEZE12bVJFuTOnVu99IJlzAWMQuBUqVK5lmnTpo2qlUXf3BIlSoT0+7FtvIiIKPY5bRpvg+o8hKmI3EuodagN3rFjRyjSRURENmXXEmlfsRZTILlnfnWIwYy3RESUHJpN421Q0yDlyZNHJk6cmOB9vOdvbl4iIqJASqSNvmIVYu2SJUvk6NGjHu9jKkC0wmK8JSKi5HDaNN4GVQM8YsQIad++vXz//feq1hd9hTBXL/oJIygTEREFy66Dcnhr2LChqgEuXbq0mv6vQIECcvr0aZk3b57kzJlTunbtGukkEhFRFHPaNN4GVQPcunVr1fQKg2VgII7Nmzer/8Z7Dz/8cOhTSUREZDNxcXGycOFC+eSTT9RUhCtXrlSDYGG0ZvQPzpAhQ6STSEREFHWCnkDwrrvuko8//ji0qSEiIttDKyujLa1iqEWW30zw448/rl5EREShpNk03gadAYZbt27JX3/9pZpAY6RmXwN1EBERBQIDbRhtahVLg3Ik5ty5c3LkyBHVLzhXrlyRTg4REcUAzabxNi7YjO+rr74qmTNnVvP0lipVSv033sNnREREwXIG+Ipl6FpUt25dyZYtm+oPjCmSypUrp5pDExERJYfTpvE2qBpgzPU7efJk+fDDD9Xcvw6HQw2ANWTIELl9+7YaJIuIiCgYmuZQL6PLxqpLly5JgwYNpHr16rJs2TIpXLiwnDp1Sr7++mt56KGHVOY41PMAExGRfWg2jbdBZYC/+eYbmTVrltxzzz2u98qWLatGqmzTpg0zwEREFLRASppjqUTa2+LFiyV//vwye/Zs1RcYihcvLrVq1ZILFy7I9OnTVcsrIiKiYDhtGm+DygCfPXtWypQpk+B9vIfPiIiIghXIfIOxNC+hN8RTDDipZ37dMd4SEVFyOW0ab4PqA4z+R+PHj0/w/rhx49RnREREwcJAG4G8YhXi6aJFi9Rgk+7Onz8vU6dOZbwlIqJk0Wwab4OqAX7nnXekWbNmMmfOHNU3CTZs2CBbtmyR+fPnhzqNRERkI3YtkfaGps716tVTXYyaN28uBQsWVPMAz5s3T4oVKyYdO3aMdBKJiCiKOW0ab4OqAcagHDt37pS7775btm/frgbiqFatmnoPnxEREQXLriXSvsyYMUM+//xzcTqdsnr1atX3d+jQobJmzRpJkyZNpJNHRERRTLNpvA16HmCMPPnRRx+FNjVERGR7di2R9gWzLKCml7W9REQUak6bxtugM8Bw5coVOXfuXIL3CxQokJzNEhGRjdk1IPujaZpq+nzz5k2P9zNkyCBZsmSJWLqIiCi6OW0ab4PKAG/btk06d+6s+vz6C9ZERETBCKSpVSw1yfJlxIgR8tZbb6k5gb317NmTLbGIiChomk3jbVAZ4G7duknJkiXlk08+kaxZs4Y+VUREZFsoQzVa0hzL5a0bN26UN954Q8aOHasGnEyVKpXH54y/RESUHJpN421QGWAMeoWpGdj0ioiIQs3538vosrEKsbZVq1bStWvXSCeFiIhikNOm8TaoDHDhwoXl4sWLzAATEVHIaZpDvYwuG6v0WEtERGQGzabxNqhpkPr166f6Hh0/fjz0KSIiIltzBviKVXXq1FGDX02aNCnBAFhERETJ5bRpvA0qA9y7d2+ZP3++5MuXT9KnT69GonR/ERERJXdUSqOvWPXll1/Kpk2bpFOnTnLHHXckiLUojCYiIgqW06bxNqgm0JMnTw59SoiIiNRIk/++jIiheJxAgwYNZPr06X4/L1asWFjTQ0REsUWzabwNKgP88MMPhz4lRERErhJpY32NYqlE2lvRokXVi4iIyAxOm8bboJpAExERmV0ibfQVqMOHD0uPHj2kXr160rFjR1m/fn1I1/njjz/knnvukcceeyyI1BEREcVGvJ01a5a0bNlSHnjgAXnttdd8zmmfnHXeeustqVmzpsyePTugdDEDTEREtumTdPr0aalVq5acOHFCBgwYoMayqFu3rmzYsCEk69y4cUMeffRRFbC3bt0azM8nIiKK+nj7+eefq4Lg+vXru8aPatq0qWiJTCgcyDqLFy+WKVOmqLEyTp48aX4TaCIiomg0duxYcTqdMmPGDEmVKpU0adJEzbc7dOhQWbhwYbLX6du3r9SoUUMyZswoP/30U5h+FRERkXXEx8fL4MGDZeDAgfLCCy+o98qWLSslS5aUH3/8UWVqk7MOMrxdu3aVOXPmSO3atQNOH2uAiYjINtMyLFu2TB566CGVkdWhqdWKFStU8E3OOgjES5culffffz+IX01ERBQb8Xb79u1y6tQpad68ueu9EiVKSJkyZVScTM46qA1+4okn1JS8VatWDep3swaYiIgsBS2dEmkhlWBZuHjxosf7adKkUS9vhw4dUs2X3aFJM5ouo0QZ/x3MOkeOHJFnn31WNdfC9IBEscHY4DgUDVjnFRu0kM7Iq5kUbxE3wTum4m/9M29G1xkxYoTcvHlTdUkKFq8GIiKyFE0c4jT4wrJQsGBByZw5s+s1fPhwn9u+detWgkCdLl0612fBrINaYAyMhf5Kd999d0j2ARERUbTG21v/xVNfsTOxWJvUOhiA8r333pNvvvlG4uKCz8ayBpiIiCwlmBJp1MBmypTJ9b6v2l/Ili2bnD171uO9M2fOuD4LZp0///xTVq9erWqE586d6xo1+vz582p0yjFjxqh/iYiI7BBvs/0XTxE73WMrYif69PpiZB0MeuVwOKRdu3auz1EbPHLkSNVdaebMmYZ+CzPARERkKYH0NdKXQzB2D8j+VKlSRTZu3OjxHkZzRj8jDFwVzDqFCxeWdevWJRg4CyXVyPyWLl3a4K8hIiKK/nhbsWJFSZEihYqdiJVw/fp12bZtm0fmNdB1+vXrl2CKQXRRatu2rXTo0MHgL2ETaCIistG0DBg1EhlTTJ8ABw4ckMmTJ6v3dRhsAzW2eq1vUuukTZtWLe/+yps3r2q2hf9GEzEiIiK7xNvs2bOrwSJHjRolV65cUe+h6TIGsGrfvr1rue7du8ugQYMMr1OkSJEE8RY1wkWLFpVKlSoZTh9rgImIyFIQY43G2QDzv3L//ferATQQZAsVKqQG1kBg7d+/v8e8v6jhRbMqo+sQERFFG83EeDt+/Hh55JFHVIEwMrcYPGvatGmSJ08e1zI7d+70+NvIOqHg0BKbjdhilixZIl988YWag7FTp06G18PO+7cEHp2lOaIhEZFZI1NeuHDBUFPkxO7Vb5R8RdKmSGtonevx12XIvuEBfy+WR00ugqx3YEV/o3379qnpFdynPkpsHW96H+AKFSpItMFjAUbXRD+vDz74QHLnzm1oPcbaWMRnptjBcW9jJ9beSlasDXe8Rdy8dOmS3HXXXQn6C+/atUvFWe9+wYmt4+3XX39VNcO5cuWKvRrg48ePq+ZmaAuOB49AMsBERBTbg3IECoG/cuXKPj9DqTNegazjDTXFeEUj9FueMWOGysQPGzbMcAaYiIiiixaGeFusWDG/n2GO30DX8Va9evXYLA5yOp2qwzNKpH3N0UhERLE3KIfRF4XO77//LqNHj1YvIiKKbU6bxtuoyAC/9dZbapCR559/PtJJISKiKB4Ei/xDczOMojlu3LiAmpIREVF0cto03lq+CfSaNWtUMN68ebPhdTAXI17u7dyJiCg6mDkoB/nXo0cPadCggTRt2lTNa5wUxloiouim2TTeWroG+Ny5c9KxY0f59NNPA+qDNHz4cNVXS38VLFjQ1HQSEVHo2LVEOpK++uor1fwZ008YxVhLRBTdnDaNt5auAZ46daoaaWzKlCnqBZh+YuHChXLixAn59ttvJS4uYR7+lVdekb59+3rUADMTTEQUHTRxqJfRZSn5Ro4cKRkyZJAnn3zSNRUU9OnTR01J4T5Pso6xlogoumk2jbeWzgCjKVa2bNk83lu/fr0UL15cHn74YTXxsS8YLjupIbOJiMjCEyoZHZXS7MTYBGp+3bsL7dmzR5YtW6bicMWKFX2uw1hLRBTdNJvGW0tngDEnlPe8UO+8847ceeed8uijj0YsXUREZJ5AmlrFUpOsSGrSpInH3+gDPHToUNUfuESJEhFLFxERmcdp03hr6QwwERHZj10H5SAiIgonzabxNuoywCNGjOD0DEREMcyuJdJWctddd6lxOPLkyRPppBARkUmcNo23UZcBbtSoUaSTQEREJtL++5/RZSn0cuTIwa5GREQxTrNpvI26DDAREcU2u5ZIExERhZPTpvGWGWAiIrIUu/ZJIiIiCifNpvGWGWAiIrIUu5ZIExERhZPTpvE2LtIJICIiIiIiIgoH1gATEZGlaNq/L6PLktU4/ntFT5m9w5HCtG2bm26z6zFYTxL+fW4OTXNGOgkWFH37RNM00bRbIdye2DLeMgNMRESWeyRxxuzjCxERkTU4bRpvmQEmIiJLsWufJCIionBy2jTeMgNMRETWEkCTrJgalpKIiCicNHvGW2aAiYjIUuzaJIuIiCicnDaNt8wAExGRpdh1UA4iIqJw0mwab5kBJiIiS7FriTQREVE4OW0ab5kBJiIiC07zYKyo2ehyRERExHgLzAATEZGl2HVUSiIionBy2jTeMgNMRESWghhrw0EpiYiIwkqzabxlBpiIiCzFriXSRERE4eS0abxlBpiIiCzFrgGZiIgonJw2jbfMABMRkQWbZBkcBMv01BAREcUmzabxlhlgIiKyFLuWSBMREYWT06bxlhlgIiKyFMxsZHR2I86CRERExHgbCGaAiYjIUtAcy2m4SVYMFUkTERGFkWbTeMsMMBERWQprgImIiBhvzcIMMBERWYrzv5fRZYmIiIjx1ihmgImIyFI0TVMvo8sSERER461RzAATEZGl2HVUSiIionBy2jTeMgNMRESW4gxgUA6jyxERERHjLTADTEREloIsreFpkMxODBERUYzSbBpv4yKdACIiIiIiIqJwsFkNcGpxOBwSVTQTxzh1xEVlus2dhyxax5SNpXI5sjs2gY520Xg/Mi8eOhzmPWrFmbhts9PuMPEZxMH6nbBCp5VopJn6rOo0Lc3x8ZdDtj2nTbsc2SwDTEREUTEPcADLEhEREeOtUcwAExGRpdi1RJqIiCicnDaNt8wAExGRpTi1AAIyq4CJiIgYbwPADDAREVkK+vkb7etv7pgAREREsUuzabyNmgywpmnRN4AVEREFDCHW6PAhsROOrYPxlojIHjSbxlvLZ4AXLVoko0aNkg0bNqgM8L333qv+Ll26dKSTRkREUdgnyel0yrx582T37t2SL18+adWqlWTIkCHZ6xw+fFiWLVsm586dk/Lly8uDDz4YNQW3Fy5ckLFjx8qkSZPk4MGDkjdvXnnqqafk1VdflZQpLf+oQEREFoy3x48flzlz5silS5ekdu3a6pXcdVBI+/PPP8umTZskU6ZMUr9+fSlatGjszAMcHx8vo0ePloEDB8qxY8dk//79kj59emnQoIFcvHgx0skjIiITILgF8grE7du3pUmTJtK7d28VVz788EOpVKmSnDhxIlnrvP766yoIr1q1Sv7++2+VeaxXr55cv35dosHs2bPlxo0bMn/+fLl69apMmTJFZYhfe+21SCeNiIiiMN5u2LBBSpUqpeIKClabNm2q8nTJWefkyZNSuXJl+d///qdi7ZIlS6RMmTLyxRdfBJQ2hxbor4mwI0eOSKFChWTx4sUqI2wEMsuZM2cWkbRRUxrvwnmAE+4SzgPs60QJw8lIlHRDKtQkokQ2GPq9uk6mFySlI42hdW5rN2TVxQ8Nfy+C5AsvvCB79uyRAgUKqAxq1apVVeuiTz/9NOh1Vq9eLTVr1nTVliJIlyhRQoYPHy7PP/+8RKOXX35ZlcLjdwcWa1G2bkasTSFmcThSmbhtzgPse79wHuBYwXmAwz0P8JlkxdpwxVtkVNFi99tvv1V///jjj9KsWTPZvHmzVKxYMah1Tp8+rWqI0cpKN3LkSFUIff78eUmbNm301wD7gh8NWbNmjXRSiIjIxCZZRl+BmDVrlio8RUYWECwfe+wx+e6775K1DjLD7k2Fc+fOLUWKFFEl2NEK8ZaxlogodjlNircHDhyQLVu2qNZQusaNG6suRN9//33Q6+TIkcMj8ws1atRQLZj0PGLMZYBv3rwpffr0kerVq6vSd3+wE1Cy4f4iIqLoEFg4/reU3fuejzjgC2ozS5Ys6fEe/j579qwqWQ7VOtu3b5ddu3ZJrVq1JBqhRhsl8D169PC7DGMtEVF000yKt3rLIffYiVa4xYsX99uqKJh1YNq0aWrcChQ6x1wGGAOQdOnSRQ0yMn369ESbMqPJGar19VfBggXDmlYiIgpviTTu8+73fcQBXy5fvvxfM93/lyVLFtdnoVgHg2C1bdtW9QnGYFnRBhn3Rx55RJ5++mnp3Lmz3+UYa4mIopvTpHirx0ZfsTOxWBvoOsgTfvbZZ/Lxxx8H1M01ZTRlfleuXKlG/Uoqh//KK69I3759XX+jdIKZYCKi2B2VEuNDuPdJSpPGd58mjNyM/kvu0G9I/yy562C5Ro0aqYCNJtJxcVFTzqz88ccfKuPevHlzGTduXKLLMtYSEUU3p0nxVo+NiIl6gbEeO1Fb60ug62CgrE6dOqmBKVFoG4iU0ZD5RVvwpUuXyooVKxI0Q/MFB8Lfww8REVmb87//GV0WEIyNDMqB0SX37dvn8R7+zpYtm+pblJx1UNiKzC9KoTGFX3IGKIkENDG7//775aGHHpIJEyYkWZrOWEtEFN2cJsVbxE09VhYuXFj9N8Zdxow+mCEhuetgcKw2bdqoqXF79uwpgbJ00TR+dLdu3WThwoXy008/qZ2B0TfxwhRJREQUezSHJprDafAV2CBYrVu3VtMmYPoEQDzBlD94X7djxw4ZOnSoq8mVkXUwXyEyv4hbmKXAuwmX1f3555/ywAMPqBeakmHMDfxOf32piYgo+mkmxdtixYqp6QK//PJL13vIzx09etSjaxA+nzFjRkDr4D3EX4z+3KtXr6B+t6WnQTpz5ozkz5/f52fjx49XzaKN4DRIfpg4BYGZ0zdxGiTfe4UoVqZBqpq5m6RwpDa0Trx2U36/8Lnh78WcvphXELWdLVu2lDVr1qg+u/g3T548rgE1OnTooEaUxHtG1sH7CxYsUMHYPfNbrlw5VUptdcOGDVMvbxjxWm/unRROg+Qbp0Hyt184DVKs4DRI0TsNUlUT4y3m9MUMCvfdd5+awnbq1KnSvXt3GTFihMcMCoij+qwKSa2D2uEKFSpI0aJFpV27dh7fhxbDWCfqm0Bnz55dlUATEZF9oJmVI8AmWUZhqiKUHv/www+ye/dulWFFSbJ7X15kWocMGeJ6z8g6mKoB8xdGq8GDB6sXERHZh9PEeIvpiTCuBOaTRysp9NlFhtc70+oeS5NaB11vMEd9clm6BjhUWAPsB2uAfTCv5tpcMX8Zk41qgCtlfjKgEuktFyYmuzScko81wL6xBtjffmENcKxgDXD01gBXsmm8tXQNMBER2Y/T4RSHw5wSaSIiIrJ3vGUGmIiIbNMki4iIiOwdb5kBJiIiS7FrQCYiIgonu8ZbS0+DRERERERERBQqtqoB7pKnj6SOSxvy7Z66fkvMcjr+qmnbPhv3j2nbPh1/wLRtX7112rRt37h1wbRtxzvNG9FcM3PbYuac2xy8yzeH2BkGDzE6gEi0Dr4Sy7rmG2BKrN176YqY5XDcX6Zt+/StP03b9pUbJ8RMt26djcopDePi0pm47dTmbdth3mO5w8Q6LzO3bSbGD7FtvLVVBpiIiKzPKfHiMFjwgmWJiIiI8dYoZoCJiMhSUDNkvESarQiIiIgYb41jBpiIiCzFrtMyEBERhZPTpvGWGWAiIrJgE2hjfcrYBJqIiIjxNhDMABMRkcUYH5QDyxIRERHjrVHMABMRkaU4NQxsFRfAskRERMR4awwzwEREZCl2nZaBiIgonDSbxltmgImIyFIw97RmsAbY3HmqiYiIYpdm03jLDDAREVnKvyNN2m9USiIionBy2jTeMgNMRESWwnmAiYiIGG/NwgwwERFZiqahSZbD8LJERETEeGsUM8BERGQpdm2SRUREFE5Om8ZbZoCJiMiCg3I4bDcoBxERUThpNo23zAATEZGlaFoA0zJosVMiTUREFE6aTeMtM8BERGQpdm2SRUREFE5Om8ZbZoCJiMhSOAgWERER461ZmAEmIiJL4TRIREREjLdmYQaYiIgs2CfJ6DRIsdMki4iIKJw0m8ZbZoCJiMhiMCql8WWJiIiI8dYoZoCJiMhS/i1ltl+JNBERUThpNo23zAATEZGl2DUgExERhZNm03hrqwzwmGEXJdMdN0K+3QPfXBez/HI8p2nb3nwui2nb3nEhj2nbPpB2j2nbPp/isGnbvn7zrGnbvhUfZ9q2nc6bpm1btNvmbTqqm8YabwBsHdGYZjLDyB33SqZM6UO+3RTrN4hZnJvOm7btq1vLmrbtvw/VFjPtv5DJtG0fupratG0fvWbsgT4YJ66alwk4e8O8mHjOec20bV9wmHf9XHKY9+x0Q7ts2rZvOs3ZtlO7LWcunTFl23ZiqwwwERFZH+YadBgtkY6heQmJiIjCyWnTeMsMMBERWYpdm2QRERGFk2bTeMsMMBERWYqmxZuyLBEREf0/u8ZbZoCJiMhSNNWf2BnAskRERMR4awwzwEREZCmBNLOKpSZZRERE4aTZNN5GRQb41q1bsnLlSjl58qSUL19eKlasGOkkERGRSewakK3g2LFjsmrVKkmdOrU88MADkiWLebMFEBFRZGk2jbfmzZ0SImfOnJFq1apJjx49ZNasWVKnTh15/vnnI50sIiIyCUaaDORFoTFt2jQpWbKkTJw4UUaNGiXFihWTtWvXcvcSEcUozabx1vI1wK+88oqqAd66daukT59eNm7cKDVq1JCmTZtK48aNI508IiIKMbuWSEe6sLlbt27yxhtvSP/+/dV7Tz75pHTu3Fn27t0rDod586oSEVFkaDaNt5auAXY6nTJ9+nR56qmnVOYXUBtcs2ZNmTp1aqSTR0REJkCQDeRFyTd//ny5efOmPPPMM673evXqJX/++acqeCYiotij2TTeWroG+MiRI3Lx4kUpU6aMx/tly5aV33//3e96N27cUC8dtkFERNEikCAbOwE5knbs2CEFChSQTJkyud4rV66c67Pq1asnWIexlogo2jlNWtbaLF0DrGdcs2bN6vF+tmzZEs3UDh8+XDJnzux6FSxY0PS0EhFRaNi1RDqSEFO9Yy0Gwrrjjjv8xlvGWiKi6KbZNN5aOgOcLl069e+lS5c83sff+mf++g1fuHDB9UJNMhERRQe7DsoRSYip3rE2Pj5erl275jfeMtYSEUU3zabx1tJNoAsVKiSpUqWSv/76y+P9gwcPSokSJfyulyZNGvUiIqLoo2ma4aZW/y5LyYWYiimQMOgk4i4g9mL/+ou3jLVERNFNs2m8tXQNMJpfNWrUSE3NoO/048ePy4oVK6R58+aRTh4REZkiPsAXJVeTJk3k6tWrMm/ePNd73377rWoWXbt2be5gIqKYFG/LeGvpGmAYMWKE3HPPPdK6dWs1+vPXX38tVatWlSeeeCLSSSMiIhP828/IYbsS6UjCnL8DBgxQsy5g2sHLly/L2LFj5bPPPpO0adNGOnlERGQCzabx1tI1wIARoLdt2yaVKlWSQ4cOqWkZli9f7mqiRUREscYZ4ItCAYNaTZkyRc6fPy9xcXHy888/S5cuXbhziYhiltOW8dbyNcB6X+DXX3890skgIqJwCKBEWoIskT537pzs379f8ubNK/nz5w/ZOsFs10qaNm2qXkREZAOa+fF23759apBFVGoabVFkZJ1gths1NcBERGQvWoD/C6ZrTb58+aRTp05qgKfHHntMDf6U3HWC2S4REVEsxttTp05JrVq11Dzy7du3V/Hxhx9+SPY6wWzXGzPARERkmyZZy5Ytk0GDBsn8+fNl165dsnv3blm8eLG8++67yVonmO0SERHFarzt3r273L59W44ePapqazHORIcOHeTEiRPJWieY7XpjBpiIiCxG+7eplZFXgCXSX375pRpYsX79+urvIkWKyOOPP67eT846wWyXiIgoFuPt6dOnVa1s//795Y477lDv9enTR1KkSKFm9wl2nWC2G7V9gJNLH7Xs4rWbpmz/0m1ztgvX4m+Ytu0bTvPKP25r5qXbqZnXpFDT4k0eac+sbZs3Mp+5o/5F67bNpkVtmkNzvgTe1OrixYuG5qjdvHmzNGzY0OM9NKMaM2aM6kuUMWPGoNYJZrsxG2svXjVl+ymuXBezOE16PoCrN83b9mUTnz/gqonPINfizYuJN5wG+zQG4abTvPvzLe12VD6XxYt556FTzHvmc5q4v83atvO/59TQPZtppsRbDGDsdDrVzD069NMtX768ipe+GFknmO3aNgOMhw8o1GtCpJNCRBTz99vMmTMHPfd7njx5AmrGBBkyZJCCBQt6vDdkyBAZOnRogmXPnj0r2bNn93hP/xuf+cqoGlknmO3GaqwtWqRdpJNCRBTTkhNrwxFvEffAV1zUP/NmZJ1gtmvbDDA6Rx85ckQ9gDgcjiRLNXBgsXymTJkkWjDd3Oc8V6zJLtcmSqMRkHG/DRZKcQ8ePCg3A6wxw3d739t91f4CptC7ft2zJvHatWuuB4Jg1wlmu3aOtXa6NqyC6eb+juXzJJrTHki6QxFrwxFv9elqfcVFf7/RyDrBbNe2GWDMZ1igQIGA1sFOjKaLR8d0c5/zXLEmO1ybySmNdg/KgU5nEIjChQurgTPc4W8E8Fy5cgW9TjDbjTXBxFq7XBtWwnRzf8fyeRLNaTea7lDEWrPjLWKiHgcxLaAOf5crVy7odYLZri8cBIuIiGyjQYMGsmjRIo9S77lz58oDDzygBtHQB9lYvXq1awojI+sYWYaIiMgOypcvL7lz5/aYnmjv3r1qhgTES9327dvljz/+MLyO0e0mxRY1wERERNCrVy+ZMGGCtGnTRrp166amL/r555/ll19+ce2gpUuXqikVjh8/rvpIGVnHyDJERER2kCJFCnn77belR48ekjVrVilUqJC88cYbUrduXWncuLFrOXyOOPvdd98ZWsfodpPCGmAvaK6Gztz++o9ZFdPNfc5zxZp4bVpLtmzZZN26dSpoYoTmM2fOqExqtWrVXMvkzJlTateu7eq7a2QdI8uQJ14b4cX9zf0dy+dJNKc9WtOdlKeeekqmT5+uYuH48eOlVatWsmDBAo8+xBUqVJDSpUsHtI6RZZLi0Myd44SIiIiIiIjIElgDTERERERERLbADDARERERERHZAjPAREREREREZAvMAHvBMNqbN292TX8RDZDWHTt2yIEDByQ+Pl6izZUrV9SUI/v27ZNo8ueff8rOnTvF6XRKtMD0Lps2bZL9+/dbOt0nTpxQ58SFCxf8LvP333/Lb7/9lugy4Xb+/HlZs2aNSr8vGHIB1ynOG+9J3CMJaVm7dq0cPHgwyWXXr1+v9jtRcly6dEmdR4cOHYqqHXn27Fn1jIB/oxHiLO6tly9flmhx9epVtc9Pnjwp0QLPYnhGQLzFgHhWhn2LdPpz+/Zt2bp1q4pbVho2CM/riLf+XLt2TbZs2aKeFazkr7/+UtdgUs8Ap06dUst5zy9PIYJBsEjT/vrrL61ChQpajhw5tCJFimi5c+fWVqxYYeldc/36dW3gwIFa9uzZtbJly2r58uXTSpQooa1atUqLJh07dtTi4uK0zp07a9Hg999/18qVK6fOkapVq2rly5fXtm/frlnZjRs31H6+4447tCpVqmh58+ZV58qvv/6qWW3ftmnTRsuVKxeirLZkyRKf5z2WSZcunVa6dGktbdq02ujRo7VI2r9/v9a1a1e1X3Eujxs3LsEyX375pVa0aFH1QrqzZMnic7lwOn36tNa/f39178D+7N27d6LLf/rpp+r3FS5cOGxppNgzfvx4dS+666671L/NmjXTrly5olnZli1btIYNG2rZsmXTKlWqpNL96KOPWj7d7g4cOKBlzZpV3Vs3btyoRYPhw4drGTJkUDG3WLFiWrdu3bTbt29rVrZu3TqtePHi6r5auXJldW994okntJs3b2pW8uGHH7piUalSpXwus3btWi1//vxawYIFVVzGNbtnzx4tkqZNm6bVqFFDncspUqRI8PmpU6dUPM6cObNWsWJFdc1i+X379mmRtGzZMq1Ro0bqmR3XYGLpwTPb3XffrTkcDu3dd98NazrtgjXA/3n88cfV1BfHjh1TtSD4G/M5Xrx4Uaxcgp45c2aVXtQAHzlyRE0C/cgjj6iSr2jw5ZdfqtKwe+65R6IB5gXFPq5Xr54qlUMNxvfff6/OGyv74osvZM6cObJt2zb5/fff1blSrlw5NV+plaCEuW3btonWMA4bNkzVVqImY9euXTJz5kx58cUX1XuRsmfPHqlRo4ZKU7p06fyeOytWrFA1wEj3uHHj5LnnnlM1qpGC8yBXrlyqdL9MmTJJHps333xTTT9AFCzUyGD+xq+++krV4CB+4b40ePBgS+9UXNv9+/dXtXmoMcM1jyk4rJ5u95ZimNv6mWeekWjxwQcfqPv9okWLZPv27arlUs2aNeXmzZtiZV27dpUqVaqo+ytqVnG+zJgxQ77++muxElx7mHu1Z8+ePj/HcySeg1u2bCmHDx9WzznFihVT51Ek4b4xevRoef/9931+jv2OZ8p//vlH3W/wd6ZMmaRjx44SSXhO7927t/zwww9JLjtw4ECpWLGiml6PTBLpHLgV7N27V5XGLF261KNmJGXKlNqkSZO0aIJSavwW1KRZ3e7du7U8efKoUum6detGRQ3wSy+9pNKM0rlo8sYbb6iWDd4l6yihtqLjx4/7rQFGmgcPHuzxHmpkUOJrBenTpzdcs4uS9/fee0+zArRm8FcDfPXqVVUD891332lDhgxhDTAF7YUXXlC1SO6GDRumanPi4+Ojas8+++yzWrVq1bRogNiFGmu0VoqGGmDEWNSUDRo0SIs2OXPm1EaNGuXxHmpR3377bc2KXn31VZ81wN9//72qgTx27JjrvdWrV6vzZ/PmzVqkTZw40WcNsC+TJ09WvwUtyKzQQiCxGuAFCxZoJUuW1C5duqSuAdYAm4M1wP/1f4CqVau6CgayZ8+uSrr0z6LFxo0bJUWKFFKkSBGxshs3bkj79u1lxIgRUrRoUYkWy5Ytk0aNGqnJtlGyixJUK/eldS+RTpUqlfTp00eWLl2qal8+/vhjefvttyWaoE8MSqHdr1WoXr161F2rqFFC/+USJUqI1eG8qVatmrRu3TrSSaEoh+vU1/V77ty5qOoPjL6QaE0TDdfv4sWLVQ0kWp1EC7RKQW178+bN1X0f8RbnSDR46623ZOzYsfLNN9/IkiVLVA0raiCjrfUMrtV8+fJJ3rx5Pa5V/bNoezYuUKCApEmTRqwMLcWefvppmTRpkmTIkCHSyYlpKSOdACvAYBbINKI5sTtkgqNpoAs0JX7llVfUzdbqzSb69u0rd911l3Tq1EmiCTJfyLCjuWj69OnVzQpN56dOnSrly5cXq0IQQ7PD//3vf/Lzzz+rdN99992qOXc00a9HXJvRfK2iCV+XLl2kcuXK0qRJE7EyNJFDwQ+akhElF65TnPfu9OsZn0VLgeh7772nMmmfffaZWBkGjsK9BjEqS5YslhsQyB+9W9G0adPUK0+ePKrZOZ4ZkJGPi7Nu/c1DDz2kuka9/PLLKt0o2HnjjTckd+7cEk1wPXrHWhSkZ8yYMariLboqfPLJJ6rQ38pQmfLYY4+prlHoUkXmsu4dJIxwQWPEPu+Rn9H/IXXq1BINkKFp2LChqqV59913xcpWrVqlaiDRzxoj3Omj/eoj3mHEQSufKwsWLFCl6XrfErQUiHTfkqSgrwz6UqFvLUpu8RCEhyFkgKNp5HDsf/AePTGarlWc348++qh6wEO/7JQprVsOiTEQUBqNwhOc77g+0RcMLTjw31Yf3ZSseQ37un4hWq5h1M4MGjRI9emsVKmSWFmvXr1Uf1QU8uOa1WvukHlHhtLq93r090ThPu4/qMWbPHmypWuycX+vX7++yuzi+QD7e8OGDfL666/LRx99JNF+rQLei5ZrFecN+jAjU2m1MU+8jR8/Xo0cft9997mejXE+4fz/9ddfI528mGPdJ68wKly4sPoXD6TuTYfxd6FChcTqMOXKAw88oDJis2fPtvyNCTdP1ACg+bMOAwNhf6PjPzKY3rXxVoHzAzUUeg0G9vWTTz4prVq1Us2zsmbNKlY0f/58VSpdvHhx9TcyXd27d5c6deqogUXuvPNOiQb58+dXD3Le0wLg72i4VhHMMIAImvOtXLlSChYsKFaGjC4GS8N9BS9ABhjnOq5VFKpgQDiiQOKtr+sXrH49wJQpU1SXkokTJ6qCLKtDTNJjqz6lEKCJLjJoQ4cOFSvSn8VQe502bVr137gX3XvvvapGz9/ATZGGQgV0b0HhiF64WbJkSVVBgcGPnn/+eYmmaxXPl6iZ1GvcUVGByqJoiLco5HnwwQdVreqYMWPE6rCPsV9fffVVj2lC8UyMa3Xu3LkRTV+sYQZYRGrVqqWas+Lm9MILL6gds27dOnWhW72JKJo3IfOLiwa1SVbv3wAIBHi5w0M0Ah5qhq0M/X8R2ND/C/2AAbWpCNBoFmRVaKbt3fQNN1TIkSOHRAvsZ5SO4lrFg5Fee4R+Vmj+b2WoaUdLAdRiIPNr9X76+nmDUmh3eGDGder9PpERiKloGopZDPR7Jh7s0HoJrVKsDM2I0Y8TsxfgoToafPrppwlGokV3nQkTJqhuMFZVunRp9Vzjq7DEygW2uGeCr3gbLc373a9VzLCAeIXnTP1aRcE/Cs+tDCPLoyYehVQo7IkGzz77rHq5w/MZCnswAj2FFjPAIirzi+YpaNKECxslpiiBwXRCeod/qzZPxAWOGtWXXnrJY+qYsmXLWrY2Mpqh9BZTCnXu3Fk9AGEQLGQI+vXrZ+mmrLiBIoAh/RhUBMH4tddeU7/BSv3FMW0BStD1/kV4WEOmFw9Ceokzah3vv/9+GTBggKoNQL8ePDh7B45wwsM8SpsBpeWoVUcGEQ9DpUqVUu+jpcC8efPk888/Vw9H+gMSBuaIVGYYmXIU9sHly5dVTRHSjcE3rN60k6ITrgM8kKJZIqYEQdyaPn26LFy4UKwMhW5PPPGEmkYI16teAIRCZ2TeKbRQwDxy5Eh1X7/jjjtU6yV0PUJzUKvW/gKmlcMAnxg4EM9ouL8j04gmrPg9VsskIo14HkBBsn5Oo/8pmj/jORLnPK7Z4cOHq9YDeNZEa4JIPl/u3btXVVChph30dFeoUEENNoZmxKj5RSEKMsDuhbW4ViNVUYT9jP7gmAYRMIgeatjRQiDa+ofHAgeGgo50IqzUtAmBGM3+kFnADczKNarIfOHm5AtutNEyt67eTwkjDaIQwupQ6479iwwPMjgPP/ywCnhWh2a3qA3AeYMMIwIEajOslHHHaKUYqMsbChzc++8g04b+VAgeaBaHgOw+UmW4IaD5ml8T+1hvYtisWTM5f/58gmXQJDpSD3TI9KJpvDcEZDTx9AW1X8isYP5lomALut555x3VPw/3UPQxr1u3rqV3JuYdnTVrls8MDwY8ihb6cwMKcvXCOStDTEBa0e0C6cVzmd6Vx6rQRBhpXr58ubrno3saMvJWK1RENyjM7+6rsEcvGMdvQazFXMx4VsBMAGh9pbeAiwTMR4/0eEPfcLRuwKCNQ4YM8TuoIwYmiwSMCu5r0Dw8v+D5wBe8j/FyoqG7RbRhBpiIiIiIiIhsgaNAExERERERkS0wA0xERERERES2wAwwERERERER2QIzwERERERERGQLzAATERERERGRLTADTERERERERLbADDARERERERHZAjPAZBvr16+XGTNmyLZt28QO1qxZI7/99ltYvmvDhg3qRURE9nb27FlZuHChTJs2Ta5cuSKx7ubNm+q3nj9/3vTvcjqd6rvOnDlj+ncRxTJmgMkW2rdvLx07dpRZs2bJzp07JdqtXr1aNm3alOgyo0ePlgkTJoQlPePGjVMvIiKyrwMHDkiJEiXkvffekzlz5sjVq1clml2/fl1lOC9cuOB3mYsXL0qHDh3kr7/+CktmG9+1b98+07+LKJaljHQCiMyGwIWaX2QYK1euHBM7fNSoUVKgQAGpUqVKpJNCRESkzJw5U0qWLClLly6NiT2CWl1kOLdv3y6ZM2eOdHKIKESYAaaYdvjwYZk9e7ar1nTPnj3y0EMPSZYsWdR7O3bsUCWpuXPnlho1akiKFClc6+7fv1/++OMPadSokaxbt06OHz8uDz/8sKROnVo0TVMZ6iNHjkjRokWlYsWKPr9/8+bNKg1ly5ZVpeI6rLt3717139myZVPrIw3ekDakIV++fFKpUiWVvo0bN8rRo0fl2rVrqmQaGjdubCg4J5Vuo+lCs7aff/5ZMmTIEDOFCkREFLzly5erOHvjxg0Vm3LkyCEPPvig+gzxau3atXLp0iUVMwoXLuyx7qJFi6RIkSKSNWtW+fXXX9W/tWvXdtWwIgYD4qCvmITtopsTYlytWrUkY8aMrs9QAI6mw4if+F58f6pUqTzWv3Xrllof34W4hwJmbGvu3Lnq859++kk9L+TMmVPq169vaH8klW4j6dKfA3bt2iXFixf3eI4gouAxA0wxDRnFJUuWqP9evHixpE+f3hUcH330UVVKXbNmTRXYEKwR5PQghfVef/11lVFEpjd//vwqo4kSYWSET548KeXKlVN9irEMAqUedPFZq1at5M8//5SqVauqzDTWGTFihPp869atKuDDqVOnVMD/4IMPpGvXrq60v/DCCzJp0iS577771DIOh0M1KUOmGplx1Gzjb7j33nuTzABjG0ml20i6UIjwwAMPqHUKFSqkgjMeVipUqBDSY0dERNEDmV/EAz02oSYYGWDErKZNm6o4gcJcjE8xYMAAGTp0qGvdl19+WX1+8OBBFUsQY5ABRrelbt26Sfny5eWOO+5QGcq33npLevbs6Vr3u+++k6efflrFs1y5cqltIHaiUBsQ4+Lj4+X27dsq7iGTiVhfsGBB9fnff/8tdevWVdsvVqyYeh7o3LmzDB48WPVlhmXLlqkYe9dddxnKABtJd1LpAjwzDBkyRMV4xG73z4goGTSiGLdv3z4Np/rBgwdd740fP17LkiWL671Lly5plStX1p588knXMuPGjVPrff755x7ba9GihdapUyft9u3b6u8bN25oderU0fr16+dapnHjxlqNGjW08+fPu96bO3eu3zQuWrRIS58+vXbmzBn198mTJ9V3b9u2zbXMpk2bXOlt2bKl1rNnz0R/d+vWrbXu3bsHlO6k0gUNGjRQ29K3s2LFCpXWzp07J5oeIiKKbYgnjRo1cv3tdDq1KlWqaB07dlT/DUuXLtUcDoe2fv1613IVK1bU8ubNq506dcr13oEDB1T8Wblypeu9jRs3amnTptV2797tiu+pU6fWxowZ41rmxIkT2rp163ymLz4+XsXGLl26uN4bOnSods8993gsM2fOHPXfx48fV/Ft+/btfn/zP//8o5bZvHmz4XQbSdfevXu1FClSaPPmzXPtyw4dOqjv8vf7iMgY1gCTLaF5FgbFQpMrQFPe3r17y3PPPSdffvmlaznUGLvXfmLkxXnz5smbb76pmlajiRRe2M6KFSvUMv/8848qNZ4/f75HrWyLFi080oBtodQXy6MZFAa3wABdqPFNmTKleuFzlCBDcpoaG0m3kXSh9hs14ytXrnQ1F69Xr55Ur1496LQREVFsQpcadK356quvVCsmQA0qamenT5/uqqUFtMpCE2Pd1KlTJXv27CoWoW8xYpbePeeXX35RtbFYJk+ePKrFlA6tuLybG6MJMQbounz5svqOVatWuT5Lly6dintoMYaWXnFxcdKyZcugf7ORdBtJF2qRUYverFkz9Tf230svvaS2T0TJwwww2dKhQ4dcQUWH/jUYsRJBSw/CCKJ60NbXQzDDlD8YFMMdmlID+vzCnXfe6ff7P/vsM+nXr5/qG4wmYWhirTc71gPl559/rpqFoakYMplPPPGE6r8c7O9NKt1G0qX/Nr3gQIemZ0RERN6xB9C02Dve6p/p8ubN6/E3RlVGASyaOLtDYSy6LOkxCf1i3eO0O/Q9bt68uWqGXa1aNVUojTEw9JgGPXr0kC1btqjMZpkyZaRBgwby/PPPq8xwMIyk20i68NsYa4nMwQww2RKCEOYqdIe/UaupD5AF3kE1U6ZM6t/+/ftLnTp1fG5bXx8lygio3jDYht6/t23btuo9BEv3kmLo0qWL6oeEEmLU3j7yyCPyxRdfqJrrQBlJt5F0oVQbzp075zGICf72fnghIiJ70zN8iK9oUaXD3979WX3FW/QL1gd79BdvE5sTF/EM/ZKR2UZLL/joo488+h9jPItvv/1WDe6I/sljx46Vu+++W43hEQwj6TaSLsRb7+kOEWuJKPk4DzDZEgaUwAAUaOKrQ0YPzbF8jcKoQ0kzXuPHj0/wGZpP6SXbeH3zzTcen6NmWQ9gGCWzVKlSrs++//57j7RgEBEEYzwQoDZ24MCBKuOKUSoBARPzExplJN1G0oVaYdT26oNv6b8Lg58QERG5K126tMrIIZa4xwzMIoA4nBi0eNq9e7da1nvEZ7ygYcOGqssOanB9xdsTJ06omlw9k6k3LfYVA5FBx/Y+/PBDtZ575jSQeGsk3UbShf2jz9qgc9+PRBQ81gCTLQ0aNEj1P0KgatOmjWoajOZKmMYhKaiFxYiWaL6EZtTIrP74449qtEuMGgmffvqp+hyZSoxmiX5Q6EeL5TBKJUaiRt/i7t27q+ZSaHrsnvHGKM9Yv3Xr1qq/ENZH3yBkhAGl0++++65qJo3SayPTICWVbiPpQoYco1KiFhoZdDRrGzdunOpDRURE5A6xYeTIkaqZMUYxxvRCn3zyiZpq6LHHHkt0ZyE2PfPMMype9erVSxUsYxYCjGOBWR0Q+9BcGd2D0K8Y43ggjqGAtlOnTipOYV2MfdGnTx81+wHWRWbZfcpDxDCM0tykSRNVozxlyhQ1EjW6MWEsDhQKI+6hFRa6RSU1CrSRdBtJF6ZgRME3toftINM8ceJEnmBEIcAaYIp5CDbt27f3aH6FZlnoe4PggtpLlFD//vvvKgOoQ42pdz9hwDpolozaYsxriKZcCGR65hcQIFEqjcCHZVBz6t4fCINkYUoiDIiBKRDwL4K43iQMmV6kC82okPFFLSwC9P33368+x2BdyMSjRhjBXi9V9i49Rt+iQNKdVLoAzaMxVQMGxELGfNSoUWo77oOZEBGR/WCwRoxZ4e6pp55SGT/Mi4up9Z599lk1rRAGm9KhMNp9cCgdCpMROzFIFOIWMqCIhe7jTmCArQkTJsixY8fUFEYYx0LvKlSlShVXPEPzZhQCoxYV0xTqhg0bJq+99poqeEZMRUYX6yDzCxjQEoW9KDDG+97SpEmjnjEQr42m20i6AN2fMJ0Snk/Spk2rtoHv0puWE1FwHBgKOsh1iYiIiIiIiKIGa4CJiIiIiIjIFpgBJiIiIiIiIltgBpiIiIiIiIhsgRlgIiIiIiIisgVmgImIiIiIiMgWmAEmIiIiIiIiW2AGmIiIiIiIiGyBGWAiIiIiIiKyBWaAiYiIiIiIyBaYASYiIiIiIiJbYAaYiIiIiIiIbIEZYCIiIiIiIhI7+D+/1lmMdxbRVgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hold_fields = {\n", + " \"Truth (path targets)\": truth_field,\n", + " \"pernode · hold path\": field_matrix(predictions[\"pernode\"][\"hold\"]),\n", + " \"graph · hold path\": field_matrix(predictions[\"graph\"][\"hold\"]),\n", + "}\n", + "vmax = max(float(np.abs(field).max()) for field in hold_fields.values())\n", + "vmax = max(vmax, 1e-3)\n", + "\n", + "fig, axes = plt.subplots(1, 3, figsize=(11.5, 3.4), constrained_layout=True)\n", + "for ax, (title, field) in zip(axes, hold_fields.items(), strict=True):\n", + " im = ax.imshow(\n", + " field,\n", + " aspect=\"auto\",\n", + " origin=\"lower\",\n", + " cmap=\"viridis\",\n", + " vmin=-vmax,\n", + " vmax=vmax,\n", + " )\n", + " ax.set_title(title)\n", + " ax.set_xlabel(\"forecast lead\")\n", + " ax.set_ylabel(\"node\")\n", + " fig.colorbar(im, ax=ax, fraction=0.046)\n", + "fig.suptitle(\n", + " f\"Feature {FEATURE}: hold-path fields from t={SPLIT - 1} \"\n", + " \"(sanity check — expect damping, not perfect tracking)\",\n", + " y=1.05,\n", + ")\n", + "plt.show()\n", + "\n", + "diff_pernode = np.abs(\n", + " field_matrix(predictions[\"pernode\"][\"ring\"])\n", + " - field_matrix(predictions[\"pernode\"][\"hold\"])\n", + ")\n", + "diff_graph = np.abs(\n", + " field_matrix(predictions[\"graph\"][\"ring\"])\n", + " - field_matrix(predictions[\"graph\"][\"hold\"])\n", + ")\n", + "dmax = max(float(diff_pernode.max()), float(diff_graph.max()), 1e-3)\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(9.5, 3.4), constrained_layout=True)\n", + "im0 = axes[0].imshow(diff_pernode, aspect=\"auto\", origin=\"lower\", cmap=\"magma\", vmin=0.0, vmax=dmax)\n", + "axes[0].set_title(r\"pernode $|\\mathrm{ring}-\\mathrm{hold}|$ (decode-only)\")\n", + "axes[0].set_xlabel(\"forecast lead\")\n", + "axes[0].set_ylabel(\"node\")\n", + "fig.colorbar(im0, ax=axes[0], fraction=0.046)\n", + "\n", + "im1 = axes[1].imshow(diff_graph, aspect=\"auto\", origin=\"lower\", cmap=\"magma\", vmin=0.0, vmax=dmax)\n", + "axes[1].set_title(r\"graph $|\\mathrm{ring}-\\mathrm{hold}|$ (decode + linear)\")\n", + "axes[1].set_xlabel(\"forecast lead\")\n", + "axes[1].set_ylabel(\"node\")\n", + "fig.colorbar(im1, ax=axes[1], fraction=0.046)\n", + "fig.suptitle(\"Physical topology-policy differences (often decode-dominated)\", y=1.05)\n", + "plt.show()\n", + "\n", + "lead = np.arange(1, horizon + 1)\n", + "fig, ax = plt.subplots(figsize=(8.0, 3.4), constrained_layout=True)\n", + "ax.plot(lead, truth_field[NODE_ID], color=\"0.2\", linewidth=2.2, label=\"truth\")\n", + "ax.plot(\n", + " lead,\n", + " field_matrix(predictions[\"pernode\"][\"hold\"])[NODE_ID],\n", + " marker=\"o\",\n", + " markersize=3,\n", + " color=\"#4C78A8\",\n", + " label=\"pernode hold\",\n", + ")\n", + "ax.plot(\n", + " lead,\n", + " field_matrix(predictions[\"graph\"][\"hold\"])[NODE_ID],\n", + " marker=\"s\",\n", + " markersize=3,\n", + " color=\"#F58518\",\n", + " label=\"graph hold\",\n", + ")\n", + "ax.set_xlabel(\"forecast lead\")\n", + "ax.set_ylabel(f\"node {NODE_ID}, feature {FEATURE}\")\n", + "ax.set_title(\"Single-node hold-path rollout (coarse fidelity; not the coupling test)\")\n", + "ax.legend(frameon=False)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "18-16", + "metadata": {}, + "source": [ + "### Effective spectrum of `GraphKoopmanOperator`\n", + "\n", + "Eigenvalues of `I ⊗ K_self + Â ⊗ K_nbr`. Path and ring spectra are often nearly\n", + "coincident when `K_nbr` is modest, so the overlay uses open ring markers with\n", + "filled path markers plus a zoom inset. The **sorted-magnitude difference** is the\n", + "honest quantitative visual; latent `|Δz|` remains the decisive coupling check.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "18-17", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-21T02:11:09.260957Z", + "iopub.status.busy": "2026-07-21T02:11:09.260678Z", + "iopub.status.idle": "2026-07-21T02:11:09.439406Z", + "shell.execute_reply": "2026-07-21T02:11:09.438960Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "max |sorted |λ| difference| = 2.2270e-02; Hausdorff distance between eigenvalue sets = 2.8138e-02\n" + ] + } + ], + "source": [ + "# Use spectrum magnitudes (already sorted by descending |λ|). Avoid element-wise\n", + "# complex eig_path - eig_ring: independent sorts can mis-pair conjugate modes.\n", + "eig_path = np.asarray(spec_path.eigenvalues.detach().cpu().numpy(), dtype=np.complex128)\n", + "eig_ring = np.asarray(spec_ring.eigenvalues.detach().cpu().numpy(), dtype=np.complex128)\n", + "mag_path = np.asarray(spec_path.magnitudes.detach().cpu().numpy(), dtype=np.float64)\n", + "mag_ring = np.asarray(spec_ring.magnitudes.detach().cpu().numpy(), dtype=np.float64)\n", + "mag_diff = mag_path - mag_ring\n", + "\n", + "hausdorff = _eigset_hausdorff(eig_path, eig_ring)\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(11.0, 4.4), constrained_layout=True)\n", + "\n", + "theta = np.linspace(0.0, 2.0 * np.pi, 400)\n", + "axes[0].plot(np.cos(theta), np.sin(theta), color=\"0.6\", linewidth=1.0, label=\"unit circle\")\n", + "# Near-coincident spectra: draw open ring first, then filled path on top; zoom inset for detail.\n", + "axes[0].scatter(\n", + " eig_ring.real,\n", + " eig_ring.imag,\n", + " s=70,\n", + " facecolors=\"none\",\n", + " edgecolors=\"#F58518\",\n", + " linewidths=1.5,\n", + " marker=\"s\",\n", + " label=f\"ring (ρ={mag_ring[0]:.3f})\",\n", + " zorder=3,\n", + ")\n", + "axes[0].scatter(\n", + " eig_path.real,\n", + " eig_path.imag,\n", + " s=28,\n", + " c=\"#4C78A8\",\n", + " alpha=0.95,\n", + " marker=\"o\",\n", + " edgecolors=\"white\",\n", + " linewidths=0.35,\n", + " label=f\"path (ρ={mag_path[0]:.3f})\",\n", + " zorder=4,\n", + ")\n", + "axes[0].set_xlabel(r\"$\\mathrm{Re}(\\lambda)$\")\n", + "axes[0].set_ylabel(r\"$\\mathrm{Im}(\\lambda)$\")\n", + "axes[0].set_title(\"Effective spectrum overlay\")\n", + "axes[0].set_aspect(\"equal\")\n", + "_handles, _labels = axes[0].get_legend_handles_labels()\n", + "# Plot order is circle → ring → path; legend as circle → path → ring.\n", + "axes[0].legend(\n", + " [_handles[0], _handles[2], _handles[1]],\n", + " [_labels[0], _labels[2], _labels[1]],\n", + " frameon=False,\n", + " fontsize=8,\n", + " loc=\"upper left\",\n", + ")\n", + "\n", + "# Zoom where the eigenvalues actually live so path vs ring is readable.\n", + "re_all = np.concatenate([eig_path.real, eig_ring.real])\n", + "im_all = np.concatenate([eig_path.imag, eig_ring.imag])\n", + "re_pad = max(0.04, 0.15 * (re_all.max() - re_all.min() + 1e-6))\n", + "im_pad = max(0.04, 0.15 * (im_all.max() - im_all.min() + 1e-6))\n", + "axins = axes[0].inset_axes([0.52, 0.08, 0.45, 0.45])\n", + "axins.scatter(\n", + " eig_ring.real,\n", + " eig_ring.imag,\n", + " s=58,\n", + " facecolors=\"none\",\n", + " edgecolors=\"#F58518\",\n", + " linewidths=1.35,\n", + " marker=\"s\",\n", + " zorder=3,\n", + ")\n", + "axins.scatter(\n", + " eig_path.real,\n", + " eig_path.imag,\n", + " s=28,\n", + " c=\"#4C78A8\",\n", + " alpha=0.95,\n", + " marker=\"o\",\n", + " edgecolors=\"white\",\n", + " linewidths=0.35,\n", + " zorder=4,\n", + ")\n", + "axins.set_xlim(re_all.min() - re_pad, re_all.max() + re_pad)\n", + "axins.set_ylim(im_all.min() - im_pad, im_all.max() + im_pad)\n", + "axins.set_aspect(\"equal\")\n", + "axins.set_title(\"zoom\", fontsize=8, pad=2)\n", + "axins.tick_params(labelsize=7)\n", + "axes[0].indicate_inset_zoom(axins, edgecolor=\"0.45\")\n", + "\n", + "axes[1].plot(mag_diff, color=\"#54A24B\", marker=\"o\", markersize=2.5)\n", + "axes[1].axhline(0.0, color=\"0.5\", linestyle=\"--\", linewidth=1.0)\n", + "axes[1].set_xlabel(r\"mode index (sorted by $|\\lambda|$)\")\n", + "axes[1].set_ylabel(r\"$|\\lambda|_{\\mathrm{path}} - |\\lambda|_{\\mathrm{ring}}$\")\n", + "axes[1].set_title(\"Sorted-magnitude difference\")\n", + "plt.show()\n", + "\n", + "print(\n", + " f\"max |sorted |λ| difference| = {np.max(np.abs(mag_diff)):.4e}; \"\n", + " f\"Hausdorff distance between eigenvalue sets = {hausdorff:.4e}\"\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "18-18", + "metadata": {}, + "source": [ + "## Interpret the results\n", + "\n", + "The latent `|Δz|(t)` curves answer the primary question directly: under path vs ring\n", + "advances with **no** decode, `pernode` stays at numerical zero while `graph`\n", + "separates over the horizon. That is topology entering the **linear** step.\n", + "\n", + "Physical hold-path panels and the coarse RMSE gate only show that both rollouts\n", + "remain finite (and typically damp faster than the true path field). The\n", + "`|ring − hold|` heatmaps stay mostly endpoint-dominated for both models, so they\n", + "are a weak coupling test — consistent with decode-only topology for `pernode`,\n", + "and with decode **plus** a modest linear gap for `graph`.\n", + "\n", + "Effective spectra of `I ⊗ K_self + Â ⊗ K_nbr` can shift when `Â` changes, but the\n", + "sorted-magnitude differences are often small when `K_nbr` is modest. Spectrum\n", + "overlays are supporting geometry, not a substitute for the latent `|Δz|` check.\n" + ] + }, + { + "cell_type": "markdown", + "id": "18-19", + "metadata": {}, + "source": [ + "## Takeaways\n", + "\n", + "- **Goal revisited:** `koopman=\"graph\"` makes mid-horizon rewiring affect the\n", + " **linear** Koopman step; `koopman=\"pernode\"` ignores topology in that step.\n", + "- **Decisive evidence:** near-zero vs nonzero latent `|Δz|(t)` under path vs ring\n", + " advances with no decode.\n", + "- **Supporting checks:** hold-path forecasts stay finite for both models (coarse\n", + " RMSE gate); physical `|ring−hold|` is mostly decode-dominated; effective spectra\n", + " can shift with `Â`, often only modestly.\n", + "- **Scope honesty:** mechanical rewiring only — not a criticality, spectral-degeneracy,\n", + " or early-warning study (see Sphinx limitations — Topology criticality).\n", + "- **Relation to literature:** Li et al. (2020) motivate relation-typed compositional\n", + " blocks; Mukherjee et al. (2022) motivate sparse agent-block operators with\n", + " non-neighbor zeros. This demo is a shared `K_self`/`K_nbr` factorization with\n", + " explicit `Â` — not a reproduction of their rope/control or multi-agent NDS results.\n", + "- **API:** `GraphKoopmanModel(..., koopman=\"graph\", koopman_parameterization=\"schur\")`\n", + " (or inject a `GraphKoopmanOperator`); pass `future_topologies` into `predict`.\n", + "- **Next steps:** train on sequences that themselves rewire\n", + " (`allow_dynamic_topology=True`); compare notebook 09 topology ablations and\n", + " notebook 13 online adaptation under topology shock.\n", + "\n", + "## Next steps\n", + "\n", + "- See [`13_online_adaptation_topology_shock.ipynb`](13_online_adaptation_topology_shock.ipynb) for RLS under topology shock.\n", + "- See [`09_topology_ablation.ipynb`](09_topology_ablation.ipynb) for encoder topology ablations.\n", + "- See [`06_epidemic_ring.ipynb`](06_epidemic_ring.ipynb) for training on rewiring contact networks.\n", + "- Explore the [API reference](https://koopmangraph.readthedocs.io/en/latest/api.html).\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "koopmangraph", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.13" } - ], - "source": [ - "# Use spectrum magnitudes (already sorted by descending |λ|). Avoid element-wise\n", - "# complex eig_path - eig_ring: independent sorts can mis-pair conjugate modes.\n", - "eig_path = np.asarray(spec_path.eigenvalues.detach().cpu().numpy(), dtype=np.complex128)\n", - "eig_ring = np.asarray(spec_ring.eigenvalues.detach().cpu().numpy(), dtype=np.complex128)\n", - "mag_path = np.asarray(spec_path.magnitudes.detach().cpu().numpy(), dtype=np.float64)\n", - "mag_ring = np.asarray(spec_ring.magnitudes.detach().cpu().numpy(), dtype=np.float64)\n", - "mag_diff = mag_path - mag_ring\n", - "\n", - "hausdorff = _eigset_hausdorff(eig_path, eig_ring)\n", - "\n", - "fig, axes = plt.subplots(1, 2, figsize=(11.0, 4.4), constrained_layout=True)\n", - "\n", - "theta = np.linspace(0.0, 2.0 * np.pi, 400)\n", - "axes[0].plot(np.cos(theta), np.sin(theta), color=\"0.6\", linewidth=1.0, label=\"unit circle\")\n", - "# Near-coincident spectra: draw open ring first, then filled path on top; zoom inset for detail.\n", - "axes[0].scatter(\n", - " eig_ring.real,\n", - " eig_ring.imag,\n", - " s=70,\n", - " facecolors=\"none\",\n", - " edgecolors=\"#F58518\",\n", - " linewidths=1.5,\n", - " marker=\"s\",\n", - " label=f\"ring (ρ={mag_ring[0]:.3f})\",\n", - " zorder=3,\n", - ")\n", - "axes[0].scatter(\n", - " eig_path.real,\n", - " eig_path.imag,\n", - " s=28,\n", - " c=\"#4C78A8\",\n", - " alpha=0.95,\n", - " marker=\"o\",\n", - " edgecolors=\"white\",\n", - " linewidths=0.35,\n", - " label=f\"path (ρ={mag_path[0]:.3f})\",\n", - " zorder=4,\n", - ")\n", - "axes[0].set_xlabel(r\"$\\mathrm{Re}(\\lambda)$\")\n", - "axes[0].set_ylabel(r\"$\\mathrm{Im}(\\lambda)$\")\n", - "axes[0].set_title(\"Effective spectrum overlay\")\n", - "axes[0].set_aspect(\"equal\")\n", - "_handles, _labels = axes[0].get_legend_handles_labels()\n", - "# Plot order is circle → ring → path; legend as circle → path → ring.\n", - "axes[0].legend(\n", - " [_handles[0], _handles[2], _handles[1]],\n", - " [_labels[0], _labels[2], _labels[1]],\n", - " frameon=False,\n", - " fontsize=8,\n", - " loc=\"upper left\",\n", - ")\n", - "\n", - "# Zoom where the eigenvalues actually live so path vs ring is readable.\n", - "re_all = np.concatenate([eig_path.real, eig_ring.real])\n", - "im_all = np.concatenate([eig_path.imag, eig_ring.imag])\n", - "re_pad = max(0.04, 0.15 * (re_all.max() - re_all.min() + 1e-6))\n", - "im_pad = max(0.04, 0.15 * (im_all.max() - im_all.min() + 1e-6))\n", - "axins = axes[0].inset_axes([0.52, 0.08, 0.45, 0.45])\n", - "axins.scatter(\n", - " eig_ring.real,\n", - " eig_ring.imag,\n", - " s=58,\n", - " facecolors=\"none\",\n", - " edgecolors=\"#F58518\",\n", - " linewidths=1.35,\n", - " marker=\"s\",\n", - " zorder=3,\n", - ")\n", - "axins.scatter(\n", - " eig_path.real,\n", - " eig_path.imag,\n", - " s=28,\n", - " c=\"#4C78A8\",\n", - " alpha=0.95,\n", - " marker=\"o\",\n", - " edgecolors=\"white\",\n", - " linewidths=0.35,\n", - " zorder=4,\n", - ")\n", - "axins.set_xlim(re_all.min() - re_pad, re_all.max() + re_pad)\n", - "axins.set_ylim(im_all.min() - im_pad, im_all.max() + im_pad)\n", - "axins.set_aspect(\"equal\")\n", - "axins.set_title(\"zoom\", fontsize=8, pad=2)\n", - "axins.tick_params(labelsize=7)\n", - "axes[0].indicate_inset_zoom(axins, edgecolor=\"0.45\")\n", - "\n", - "axes[1].plot(mag_diff, color=\"#54A24B\", marker=\"o\", markersize=2.5)\n", - "axes[1].axhline(0.0, color=\"0.5\", linestyle=\"--\", linewidth=1.0)\n", - "axes[1].set_xlabel(r\"mode index (sorted by $|\\lambda|$)\")\n", - "axes[1].set_ylabel(r\"$|\\lambda|_{\\mathrm{path}} - |\\lambda|_{\\mathrm{ring}}$\")\n", - "axes[1].set_title(\"Sorted-magnitude difference\")\n", - "plt.show()\n", - "\n", - "print(\n", - " f\"max |sorted |λ| difference| = {np.max(np.abs(mag_diff)):.4e}; \"\n", - " f\"Hausdorff distance between eigenvalue sets = {hausdorff:.4e}\"\n", - ")\n" - ] - }, - { - "cell_type": "markdown", - "id": "18-18", - "metadata": {}, - "source": [ - "## Interpret the results\n", - "\n", - "The latent `|Δz|(t)` curves answer the primary question directly: under path vs ring\n", - "advances with **no** decode, `pernode` stays at numerical zero while `graph`\n", - "separates over the horizon. That is topology entering the **linear** step.\n", - "\n", - "Physical hold-path panels and the coarse RMSE gate only show that both rollouts\n", - "remain finite (and typically damp faster than the true path field). The\n", - "`|ring − hold|` heatmaps stay mostly endpoint-dominated for both models, so they\n", - "are a weak coupling test — consistent with decode-only topology for `pernode`,\n", - "and with decode **plus** a modest linear gap for `graph`.\n", - "\n", - "Effective spectra of `I ⊗ K_self + Â ⊗ K_nbr` can shift when `Â` changes, but the\n", - "sorted-magnitude differences are often small when `K_nbr` is modest. Spectrum\n", - "overlays are supporting geometry, not a substitute for the latent `|Δz|` check.\n" - ] - }, - { - "cell_type": "markdown", - "id": "18-19", - "metadata": {}, - "source": [ - "## Takeaways\n", - "\n", - "- **Goal revisited:** `koopman=\"graph\"` makes mid-horizon rewiring affect the\n", - " **linear** Koopman step; `koopman=\"pernode\"` ignores topology in that step.\n", - "- **Decisive evidence:** near-zero vs nonzero latent `|Δz|(t)` under path vs ring\n", - " advances with no decode.\n", - "- **Supporting checks:** hold-path forecasts stay finite for both models (coarse\n", - " RMSE gate); physical `|ring−hold|` is mostly decode-dominated; effective spectra\n", - " can shift with `Â`, often only modestly.\n", - "- **Relation to literature:** Li et al. (2020) motivate relation-typed compositional\n", - " blocks; Mukherjee et al. (2022) motivate sparse agent-block operators with\n", - " non-neighbor zeros. This demo is a shared `K_self`/`K_nbr` factorization with\n", - " explicit `Â` — not a reproduction of their rope/control or multi-agent NDS results.\n", - "- **API:** `GraphKoopmanModel(..., koopman=\"graph\", koopman_parameterization=\"schur\")`\n", - " (or inject a `GraphKoopmanOperator`); pass `future_topologies` into `predict`.\n", - "- **Next steps:** train on sequences that themselves rewire\n", - " (`allow_dynamic_topology=True`); compare notebook 09 topology ablations and\n", - " notebook 13 online adaptation under topology shock.\n", - "\n", - "## Next steps\n", - "\n", - "- See [`13_online_adaptation_topology_shock.ipynb`](13_online_adaptation_topology_shock.ipynb) for RLS under topology shock.\n", - "- See [`09_topology_ablation.ipynb`](09_topology_ablation.ipynb) for encoder topology ablations.\n", - "- See [`06_epidemic_ring.ipynb`](06_epidemic_ring.ipynb) for training on rewiring contact networks.\n", - "- Explore the [API reference](https://koopmangraph.readthedocs.io/en/latest/api.html).\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "koopmangraph", - "language": "python", - "name": "python3" }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.13" - } - }, - "nbformat": 4, - "nbformat_minor": 5 + "nbformat": 4, + "nbformat_minor": 5 } diff --git a/examples/29_large_graph_block_diagonal.ipynb b/examples/29_large_graph_block_diagonal.ipynb index ac9ed20..be150fe 100644 --- a/examples/29_large_graph_block_diagonal.ipynb +++ b/examples/29_large_graph_block_diagonal.ipynb @@ -1,851 +1,996 @@ { - "cells": [ - { - "cell_type": "markdown", - "id": "8bf0ab86", - "metadata": {}, - "source": [ - "# Large-Graph Block-Diagonal Training\n", - "\n", - "This notebook is a **scale** tutorial: train a networked GraphKoopman model with\n", - "`koopman_sparsity=\"block_diagonal\"` and `NeighborWindowSampler` on a graph large\n", - "enough that a dense $N\\cdot d$ effective operator is painful. You will measure\n", - "memory/runtime against a dense inverse path on a mid-size probe, see the\n", - "approximate Jacobi inverse caveat for backward consistency, and evaluate\n", - "full-graph forecasts after neighbor-sampled training.\n", - "\n", - "**Prerequisites.** Encode → Koopman step → decode from\n", - "[`01_synthetic_graph.ipynb`](01_synthetic_graph.ipynb); windowed training ideas\n", - "from [`10_advanced_training.ipynb`](10_advanced_training.ipynb). Interactive runs\n", - "need the PEMS07 teaching cache (raw NPZ not bundled):\n", - "\n", - "```bash\n", - "python scripts/download_pems.py --benchmark 07 \\\n", - " --npz-path /path/to/PEMS07.npz --adj-csv /path/to/PEMS07.csv \\\n", - " --expected-sha256 \n", - "```\n" - ] - }, - { - "cell_type": "markdown", - "id": "db1489fe", - "metadata": {}, - "source": [ - "## Setup\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "e9be0d9d", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-25T23:58:09.514257Z", - "iopub.status.busy": "2026-07-25T23:58:09.513967Z", - "iopub.status.idle": "2026-07-25T23:58:13.079673Z", - "shell.execute_reply": "2026-07-25T23:58:13.079262Z" - } - }, - "outputs": [ + "cells": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "IS_TEST=False EPOCHS=20 PROBE_N=128 SAMPLER_SEEDS=48\n" - ] - } - ], - "source": [ - "import warnings\n", - "\n", - "from tqdm.std import TqdmWarning\n", - "\n", - "warnings.filterwarnings(\"ignore\", category=TqdmWarning)\n", - "\n", - "import os\n", - "import random\n", - "import time\n", - "import tracemalloc\n", - "from pathlib import Path\n", - "\n", - "import matplotlib\n", - "\n", - "if os.environ.get(\"PYTEST_CURRENT_TEST\") or os.environ.get(\"CI\"):\n", - " matplotlib.use(\"Agg\")\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import torch\n", - "from torch_geometric.data import Data\n", - "\n", - "from koopman_graph import GNNDecoder, GNNEncoder, GraphKoopmanModel\n", - "from koopman_graph.data import (\n", - " GraphSnapshotSequence,\n", - " NeighborWindowSampler,\n", - " temporal_split,\n", - ")\n", - "from koopman_graph.datasets.pems import (\n", - " PemsTrafficBenchmark,\n", - " default_variant_cache_dir,\n", - ")\n", - "from koopman_graph.datasets.topology import path_edge_index\n", - "from koopman_graph.metrics import rmse as kg_rmse\n", - "from koopman_graph.operators import GraphKoopmanOperator\n", - "from koopman_graph.training import constant_loss_weights\n", - "\n", - "IS_TEST = bool(\n", - " os.environ.get(\"PYTEST_CURRENT_TEST\")\n", - " or os.environ.get(\"CI\")\n", - " or os.environ.get(\"IS_TEST\")\n", - ")\n", - "SEED = 29\n", - "random.seed(SEED)\n", - "np.random.seed(SEED)\n", - "torch.manual_seed(SEED)\n", - "\n", - "LATENT = 4 if IS_TEST else 8\n", - "HIDDEN = 8 if IS_TEST else 32\n", - "NUM_LAYERS = 1\n", - "EPOCHS = 2 if IS_TEST else 20\n", - "HORIZONS = (1, 2) if IS_TEST else (3, 6, 12)\n", - "PROBE_N = 64 if IS_TEST else 128\n", - "SAMPLER_SEEDS = 16 if IS_TEST else 48\n", - "WINDOWS_PER_EPOCH = 4 if IS_TEST else 16\n", - "BATCH_SIZE = 2 if IS_TEST else 4\n", - "LR = 1e-2 if IS_TEST else 1e-3\n", - "LOSS_WEIGHTS = constant_loss_weights(reconstruction=1.0, forward=0.5)\n", - "print(\n", - " f\"IS_TEST={IS_TEST} EPOCHS={EPOCHS} PROBE_N={PROBE_N} \"\n", - " f\"SAMPLER_SEEDS={SAMPLER_SEEDS}\"\n", - ")\n" - ] - }, - { - "cell_type": "markdown", - "id": "0f7cf84a", - "metadata": {}, - "source": [ - "## Motivation and background\n", - "\n", - "A dense graph Koopman operator materializes (or factors) maps on\n", - "$\\mathbb{R}^{N\\cdot d}$. At PEMS07 scale ($N=883$) or a synthetic path with\n", - "$N=2000$, that budget grows as $(Nd)^2$. Two complementary tools keep\n", - "training tractable:\n", - "\n", - "1. **`koopman_sparsity=\"block_diagonal\"`** — forward advance stays a sparse\n", - " matvec; `inverse_advance` uses a **Jacobi / blockwise** approximate inverse\n", - " (exact only when neighbor coupling is negligible). See architecture docs and\n", - " Mukherjee et al. 2022 (`Mukherjee2022`) on sparse networked Koopman ideas;\n", - " Azarbahram et al. (arXiv:2509.20071) motivate distributed / consensus-style\n", - " extensions (out of scope for this notebook).\n", - "2. **`NeighborWindowSampler`** — each batch is a k-hop induced subgraph with\n", - " remapped indices, so losses never see the full $N$ at once. Predict /\n", - " evaluate remain full-graph.\n", - "\n", - "**Backward consistency** (Azencot et al., 2020) calls `inverse_advance`. With\n", - "`block_diagonal`, that inverse is approximate — this notebook keeps\n", - "`backward=0` for the main train and shows the approximation error separately.\n" - ] - }, - { - "cell_type": "markdown", - "id": "19e159a9", - "metadata": {}, - "source": [ - "## Helpers: synthetic path graph, timing, persistence\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "e8720686", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-25T23:58:13.080897Z", - "iopub.status.busy": "2026-07-25T23:58:13.080733Z", - "iopub.status.idle": "2026-07-25T23:58:13.148329Z", - "shell.execute_reply": "2026-07-25T23:58:13.147847Z" - } - }, - "outputs": [], - "source": [ - "def make_path_sequence(\n", - " *,\n", - " num_nodes: int,\n", - " num_timesteps: int,\n", - " in_channels: int = 1,\n", - " seed: int = SEED,\n", - ") -> GraphSnapshotSequence:\n", - " generator = torch.Generator().manual_seed(seed)\n", - " edge_index = path_edge_index(num_nodes)\n", - " features = torch.randn(\n", - " num_timesteps, num_nodes, in_channels, generator=generator\n", - " )\n", - " for time in range(1, num_timesteps):\n", - " features[time] = 0.9 * features[time - 1] + 0.1 * features[time]\n", - " return GraphSnapshotSequence.from_arrays(features, edge_index)\n", - "\n", - "\n", - "def dense_effective_bytes(num_nodes: int, latent_dim: int) -> int:\n", - " nd = num_nodes * latent_dim\n", - " return nd * nd * 4 # float32\n", - "\n", - "\n", - "def rss_mb() -> float:\n", - " # Prefer process RSS (platform units differ); fall back to tracemalloc.\n", - " try:\n", - " import resource\n", - " import sys\n", - "\n", - " usage = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss\n", - " # Darwin: bytes. Linux: kilobytes.\n", - " if sys.platform == \"darwin\":\n", - " return usage / (1024**2)\n", - " return usage / 1024.0\n", - " except Exception:\n", - " current, _peak = tracemalloc.get_traced_memory()\n", - " return current / (1024**2)\n", - "\n", - "\n", - "def time_inverse_advance(\n", - " op: GraphKoopmanOperator,\n", - " z_next: torch.Tensor,\n", - " edge_index: torch.Tensor,\n", - " *,\n", - " repeats: int = 3,\n", - ") -> tuple[float, float]:\n", - " # Warmup + timed repeats; return (median_ms, rss_mb_after).\n", - " with torch.no_grad():\n", - " _ = op.inverse_advance(z_next, edge_index=edge_index)\n", - " times: list[float] = []\n", - " for _ in range(repeats):\n", - " start = time.perf_counter()\n", - " _ = op.inverse_advance(z_next, edge_index=edge_index)\n", - " if torch.cuda.is_available():\n", - " torch.cuda.synchronize()\n", - " times.append((time.perf_counter() - start) * 1000.0)\n", - " return float(np.median(times)), rss_mb()\n", - "\n", - "\n", - "def persistence_predict(snapshot: Data, steps: int) -> list[Data]:\n", - " kwargs = {\"x\": snapshot.x.clone(), \"edge_index\": snapshot.edge_index}\n", - " edge_weight = getattr(snapshot, \"edge_weight\", None)\n", - " if edge_weight is not None:\n", - " kwargs[\"edge_weight\"] = edge_weight\n", - " return [Data(**kwargs) for _ in range(steps)]\n", - "\n", - "\n", - "def multi_origin_rmse(predict_fn, test_seq, horizons: tuple[int, ...]) -> dict[int, float]:\n", - " max_horizon = max(horizons)\n", - " origins = range(0, test_seq.num_timesteps - max_horizon)\n", - " sums = {horizon: 0.0 for horizon in horizons}\n", - " n_origins = 0\n", - " for origin in origins:\n", - " preds = predict_fn(test_seq[origin], max_horizon)\n", - " for horizon in horizons:\n", - " sums[horizon] += float(\n", - " kg_rmse(preds[horizon - 1].x, test_seq[origin + horizon].x)\n", - " )\n", - " n_origins += 1\n", - " if n_origins == 0:\n", - " raise ValueError(\"no valid forecast origins for the requested horizons\")\n", - " return {horizon: sums[horizon] / n_origins for horizon in horizons}\n", - "\n", - "\n", - "def build_block_model(in_channels: int) -> GraphKoopmanModel:\n", - " return GraphKoopmanModel(\n", - " encoder=GNNEncoder(\n", - " in_channels, HIDDEN, LATENT, num_layers=NUM_LAYERS\n", - " ),\n", - " decoder=GNNDecoder(\n", - " LATENT, HIDDEN, in_channels, num_layers=NUM_LAYERS\n", - " ),\n", - " latent_dim=LATENT,\n", - " time_step=300.0,\n", - " dynamics_mode=\"discrete\",\n", - " koopman=\"graph\",\n", - " koopman_sparsity=\"block_diagonal\",\n", - " )\n" - ] - }, - { - "cell_type": "markdown", - "id": "d78bed75", - "metadata": {}, - "source": [ - "## Load PEMS07 (or CI synthetic path, N=2000)\n", - "\n", - "Interactive runs load `data/pems07/traffic.pt`. Under pytest / CI we use a\n", - "seeded path graph with 2000 nodes so nbmake needs no PeMS assets.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "39aaa265", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-25T23:58:13.149438Z", - "iopub.status.busy": "2026-07-25T23:58:13.149356Z", - "iopub.status.idle": "2026-07-25T23:58:13.176156Z", - "shell.execute_reply": "2026-07-25T23:58:13.175750Z" - } - }, - "outputs": [ + "cell_type": "markdown", + "id": "8bf0ab86", + "metadata": {}, + "source": [ + "# Large-Graph Block-Diagonal Training\n", + "\n", + "This notebook is a **scale** tutorial: train a networked GraphKoopman model with\n", + "`koopman_sparsity=\"block_diagonal\"` and `NeighborWindowSampler` on a graph large\n", + "enough that a dense $N\\cdot d$ effective operator is painful. You will measure\n", + "memory/runtime against a dense inverse path on a mid-size probe, see the\n", + "approximate Jacobi inverse caveat for backward consistency, and evaluate\n", + "full-graph forecasts after neighbor-sampled training.\n", + "\n", + "**Prerequisites.** Encode → Koopman step → decode from\n", + "[`01_synthetic_graph.ipynb`](01_synthetic_graph.ipynb); windowed training ideas\n", + "from [`10_advanced_training.ipynb`](10_advanced_training.ipynb). Interactive runs\n", + "need the PEMS07 teaching cache (raw NPZ not bundled):\n", + "\n", + "```bash\n", + "python scripts/download_pems.py --benchmark 07 \\\n", + " --npz-path /path/to/PEMS07.npz --adj-csv /path/to/PEMS07.csv \\\n", + " --expected-sha256 \n", + "```\n" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "cache_dir=/Users/traviskessler/GitHub-Cursor/KoopmanGraph/data/pems07\n", - "DATA_SOURCE=pems07\n", - "T=288 N=883 F=1 E=1580\n", - "Dense effective matrix float32 budget at d=8: 199.6 MB (not allocated here)\n" - ] - } - ], - "source": [ - "FEATURE_UNIT = \"z-scored feature (dimensionless)\"\n", - "DATA_SOURCE = \"synthetic\"\n", - "\n", - "\n", - "def resolve_pems07_cache_dir() -> Path:\n", - " \"\"\"Locate ``data/pems07`` across package install and notebook cwd layouts.\"\"\"\n", - " candidates = (\n", - " default_variant_cache_dir(\"07\"),\n", - " Path.cwd() / \"data\" / \"pems07\",\n", - " Path.cwd().parent / \"data\" / \"pems07\",\n", - " )\n", - " for cache_dir in candidates:\n", - " if (cache_dir / \"traffic.pt\").is_file():\n", - " return cache_dir.resolve()\n", - " return candidates[0].resolve()\n", - "\n", - "\n", - "if IS_TEST:\n", - " sequence = make_path_sequence(num_nodes=2000, num_timesteps=24, seed=SEED)\n", - " DATA_SOURCE = \"synthetic_path_n2000\"\n", - "else:\n", - " cache_dir = resolve_pems07_cache_dir()\n", - " cache_path = cache_dir / \"traffic.pt\"\n", - " if not cache_path.is_file():\n", - " raise RuntimeError(\n", - " \"PEMS07 teaching cache is missing.\\n\"\n", - " f\"Looked for traffic.pt under:\\n\"\n", - " f\" - {default_variant_cache_dir('07')}\\n\"\n", - " f\" - {Path.cwd() / 'data' / 'pems07'}\\n\"\n", - " f\" - {Path.cwd().parent / 'data' / 'pems07'}\\n\"\n", - " \"Build it from the repo root with (NPZ not bundled):\\n\"\n", - " \" python scripts/download_pems.py --benchmark 07 \\\\\\n\"\n", - " \" --npz-path /path/to/PEMS07.npz --adj-csv /path/to/PEMS07.csv \\\\\\n\"\n", - " \" --expected-sha256 \\n\"\n", - " \"See docs/source/data.rst for the PEMS07 dataset card.\"\n", - " )\n", - " sequence = PemsTrafficBenchmark.load_sequence(variant=\"07\", cache_dir=cache_dir)\n", - " DATA_SOURCE = \"pems07\"\n", - " FEATURE_UNIT = \"z-scored flow (dimensionless)\"\n", - " print(f\"cache_dir={cache_dir}\")\n", - "\n", - "in_channels = sequence.in_channels\n", - "print(f\"DATA_SOURCE={DATA_SOURCE}\")\n", - "print(\n", - " f\"T={sequence.num_timesteps} N={sequence.num_nodes} F={in_channels} \"\n", - " f\"E={sequence.edge_index.shape[1]}\"\n", - ")\n", - "budget = dense_effective_bytes(sequence.num_nodes, LATENT)\n", - "print(\n", - " f\"Dense effective matrix float32 budget at d={LATENT}: \"\n", - " f\"{budget / 1e6:.1f} MB (not allocated here)\"\n", - ")\n" - ] - }, - { - "cell_type": "markdown", - "id": "8aa8bd07", - "metadata": {}, - "source": [ - "## Minimal example: sampler + block_diagonal fit step\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "dd2deb4c", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-25T23:58:13.177131Z", - "iopub.status.busy": "2026-07-25T23:58:13.177067Z", - "iopub.status.idle": "2026-07-25T23:58:13.287863Z", - "shell.execute_reply": "2026-07-25T23:58:13.287377Z" - } - }, - "outputs": [ + "cell_type": "markdown", + "id": "db1489fe", + "metadata": {}, + "source": [ + "## Setup\n" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "full N=883 sampled window N=186 (remapped subgraph)\n", - "minimal sampler fit OK\n" - ] - } - ], - "source": [ - "torch.manual_seed(SEED)\n", - "mini_sampler = NeighborWindowSampler(\n", - " sequence,\n", - " window_length=2,\n", - " num_nodes=SAMPLER_SEEDS,\n", - " num_hops=2,\n", - " batch_size=BATCH_SIZE,\n", - " windows_per_epoch=WINDOWS_PER_EPOCH,\n", - " seed=SEED,\n", - ")\n", - "sample_window = next(iter(mini_sampler.iter_epoch(0)))[0]\n", - "print(\n", - " f\"full N={sequence.num_nodes} sampled window N={sample_window.num_nodes} \"\n", - " f\"(remapped subgraph)\"\n", - ")\n", - "\n", - "mini_model = build_block_model(in_channels)\n", - "assert mini_model.koopman.sparsity == \"block_diagonal\"\n", - "_ = mini_model.fit(\n", - " sequence,\n", - " epochs=1,\n", - " sampler=mini_sampler,\n", - " lr=LR,\n", - " loss_weights=LOSS_WEIGHTS,\n", - ")\n", - "print(\"minimal sampler fit OK\")\n" - ] - }, - { - "cell_type": "markdown", - "id": "fc14f5b4", - "metadata": {}, - "source": [ - "## Mid-size probe: dense vs block_diagonal `inverse_advance`\n", - "\n", - "We **do not** materialize a dense $Nd\\times Nd$ inverse on the full teaching\n", - "graph. Instead we time both modes on a mid-size path (`PROBE_N`) with matched\n", - "$K_{\\mathrm{self}}, K_{\\mathrm{nbr}}$, and report relative recovery error for\n", - "the Jacobi approximation.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "98636efb", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-25T23:58:13.289279Z", - "iopub.status.busy": "2026-07-25T23:58:13.289190Z", - "iopub.status.idle": "2026-07-25T23:58:13.340649Z", - "shell.execute_reply": "2026-07-25T23:58:13.340029Z" - } - }, - "outputs": [ + "cell_type": "code", + "execution_count": 1, + "id": "e9be0d9d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-25T23:58:09.514257Z", + "iopub.status.busy": "2026-07-25T23:58:09.513967Z", + "iopub.status.idle": "2026-07-25T23:58:13.079673Z", + "shell.execute_reply": "2026-07-25T23:58:13.079262Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "IS_TEST=False EPOCHS=20 PROBE_N=128 SAMPLER_SEEDS=48\n" + ] + } + ], + "source": [ + "import warnings\n", + "\n", + "from tqdm.std import TqdmWarning\n", + "\n", + "warnings.filterwarnings(\"ignore\", category=TqdmWarning)\n", + "\n", + "import os\n", + "import random\n", + "import time\n", + "import tracemalloc\n", + "from pathlib import Path\n", + "\n", + "import matplotlib\n", + "\n", + "if os.environ.get(\"PYTEST_CURRENT_TEST\") or os.environ.get(\"CI\"):\n", + " matplotlib.use(\"Agg\")\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import torch\n", + "from torch_geometric.data import Data\n", + "\n", + "from koopman_graph import GNNDecoder, GNNEncoder, GraphKoopmanModel\n", + "from koopman_graph.data import (\n", + " GraphSnapshotSequence,\n", + " NeighborWindowSampler,\n", + " temporal_split,\n", + ")\n", + "from koopman_graph.datasets.pems import (\n", + " PemsTrafficBenchmark,\n", + " default_variant_cache_dir,\n", + ")\n", + "from koopman_graph.datasets.topology import path_edge_index\n", + "from koopman_graph.metrics import rmse as kg_rmse\n", + "from koopman_graph.operators import GraphKoopmanOperator\n", + "from koopman_graph.operators.kronecker_spectrum import spectrum_k_eff_kronecker_sum\n", + "from koopman_graph.spectrum_types import compute_spectrum\n", + "from koopman_graph.training import constant_loss_weights\n", + "\n", + "IS_TEST = bool(\n", + " os.environ.get(\"PYTEST_CURRENT_TEST\")\n", + " or os.environ.get(\"CI\")\n", + " or os.environ.get(\"IS_TEST\")\n", + ")\n", + "SEED = 29\n", + "random.seed(SEED)\n", + "np.random.seed(SEED)\n", + "torch.manual_seed(SEED)\n", + "\n", + "LATENT = 4 if IS_TEST else 8\n", + "HIDDEN = 8 if IS_TEST else 32\n", + "NUM_LAYERS = 1\n", + "EPOCHS = 2 if IS_TEST else 20\n", + "HORIZONS = (1, 2) if IS_TEST else (3, 6, 12)\n", + "PROBE_N = 64 if IS_TEST else 128\n", + "SAMPLER_SEEDS = 16 if IS_TEST else 48\n", + "WINDOWS_PER_EPOCH = 4 if IS_TEST else 16\n", + "BATCH_SIZE = 2 if IS_TEST else 4\n", + "LR = 1e-2 if IS_TEST else 1e-3\n", + "LOSS_WEIGHTS = constant_loss_weights(reconstruction=1.0, forward=0.5)\n", + "print(\n", + " f\"IS_TEST={IS_TEST} EPOCHS={EPOCHS} PROBE_N={PROBE_N} \"\n", + " f\"SAMPLER_SEEDS={SAMPLER_SEEDS}\"\n", + ")\n" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Probe N=128, d=8\n", - " dense inverse median: 5.36 ms rss≈445.9 MB\n", - " block inverse median: 0.07 ms rss≈445.9 MB\n", - " dense recovery rel-err: 1.17e-07 (should be ~0)\n", - " block Jacobi rel-err vs truth: 0.0433\n", - " dense Nd×Nd float32 budget — probe: 4.19 MB; full teaching graph: 199.6 MB\n" - ] - } - ], - "source": [ - "tracemalloc.start()\n", - "probe_edges = path_edge_index(PROBE_N)\n", - "k_self = torch.diag(torch.linspace(0.55, 0.85, LATENT))\n", - "k_nbr = 0.12 * torch.eye(LATENT)\n", - "dense_op = GraphKoopmanOperator(LATENT, init_mode=\"identity\", sparsity=\"dense\")\n", - "block_op = GraphKoopmanOperator(\n", - " LATENT, init_mode=\"identity\", sparsity=\"block_diagonal\"\n", - ")\n", - "dense_op.set_dense_matrices(k_self, k_nbr)\n", - "block_op.set_dense_matrices(k_self.clone(), k_nbr.clone())\n", - "\n", - "torch.manual_seed(SEED)\n", - "z = torch.randn(PROBE_N, LATENT)\n", - "z_next = dense_op.advance(z, edge_index=probe_edges)\n", - "\n", - "dense_ms, dense_rss = time_inverse_advance(dense_op, z_next, probe_edges)\n", - "block_ms, block_rss = time_inverse_advance(block_op, z_next, probe_edges)\n", - "\n", - "with torch.no_grad():\n", - " dense_rec = dense_op.inverse_advance(z_next, edge_index=probe_edges)\n", - " block_rec = block_op.inverse_advance(z_next, edge_index=probe_edges)\n", - " rel_err = float((block_rec - z).norm() / z.norm())\n", - " dense_rec_err = float((dense_rec - z).norm() / z.norm())\n", - "\n", - "probe_budget_mb = dense_effective_bytes(PROBE_N, LATENT) / 1e6\n", - "full_budget_mb = dense_effective_bytes(sequence.num_nodes, LATENT) / 1e6\n", - "\n", - "print(f\"Probe N={PROBE_N}, d={LATENT}\")\n", - "print(f\" dense inverse median: {dense_ms:.2f} ms rss≈{dense_rss:.1f} MB\")\n", - "print(f\" block inverse median: {block_ms:.2f} ms rss≈{block_rss:.1f} MB\")\n", - "print(f\" dense recovery rel-err: {dense_rec_err:.2e} (should be ~0)\")\n", - "print(f\" block Jacobi rel-err vs truth: {rel_err:.4f}\")\n", - "print(\n", - " f\" dense Nd×Nd float32 budget — probe: {probe_budget_mb:.2f} MB; \"\n", - " f\"full teaching graph: {full_budget_mb:.1f} MB\"\n", - ")\n", - "\n", - "timing_rows = [\n", - " {\n", - " \"mode\": \"dense\",\n", - " \"N\": PROBE_N,\n", - " \"median_ms\": dense_ms,\n", - " \"rss_mb\": dense_rss,\n", - " \"rel_err_to_z\": dense_rec_err,\n", - " },\n", - " {\n", - " \"mode\": \"block_diagonal\",\n", - " \"N\": PROBE_N,\n", - " \"median_ms\": block_ms,\n", - " \"rss_mb\": block_rss,\n", - " \"rel_err_to_z\": rel_err,\n", - " },\n", - "]\n" - ] - }, - { - "cell_type": "markdown", - "id": "4dba1900", - "metadata": {}, - "source": [ - "## Train with NeighborWindowSampler on the large graph\n", - "\n", - "Primary path: `block_diagonal` + sampler + forward/reconstruction losses only\n", - "(`backward=0`). Optional dense full-graph fit is restricted to a **synthetic\n", - "path** (`synthetic_path_n≤64`) — not an induced PEMS07 subgraph — so we never\n", - "allocate the full teaching-graph effective matrix.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "16b7748f", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-25T23:58:13.342021Z", - "iopub.status.busy": "2026-07-25T23:58:13.341836Z", - "iopub.status.idle": "2026-07-25T23:58:15.018868Z", - "shell.execute_reply": "2026-07-25T23:58:15.018081Z" - } - }, - "outputs": [ + "cell_type": "markdown", + "id": "0f7cf84a", + "metadata": {}, + "source": [ + "## Motivation and background\n", + "\n", + "A dense graph Koopman operator materializes (or factors) maps on\n", + "$\\mathbb{R}^{N\\cdot d}$. At PEMS07 scale ($N=883$) or a synthetic path with\n", + "$N=2000$, that budget grows as $(Nd)^2$. Two complementary tools keep\n", + "training tractable:\n", + "\n", + "1. **`koopman_sparsity=\"block_diagonal\"`** — forward advance stays a sparse\n", + " matvec; `inverse_advance` uses a **Jacobi / blockwise** approximate inverse\n", + " (exact only when neighbor coupling is negligible). See architecture docs and\n", + " Mukherjee et al. 2022 (`Mukherjee2022`) on sparse networked Koopman ideas;\n", + " Azarbahram et al. (arXiv:2509.20071) motivate distributed / consensus-style\n", + " extensions (out of scope for this notebook).\n", + "2. **`NeighborWindowSampler`** — each batch is a k-hop induced subgraph with\n", + " remapped indices, so losses never see the full $N$ at once. Predict /\n", + " evaluate remain full-graph.\n", + "\n", + "**Backward consistency** (Azencot et al., 2020) calls `inverse_advance`. With\n", + "`block_diagonal`, that inverse is approximate — this notebook keeps\n", + "`backward=0` for the main train and shows the approximation error separately.\n" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "train/val/test T = 201/28/59\n", - "block+sampler train: 1.34s final loss=0.0716 rss 454.0→458.3 MB\n", - "dense full-graph on synthetic_path_n64: 0.20s final loss=0.2015\n" - ] - } - ], - "source": [ - "split = temporal_split(sequence)\n", - "print(\n", - " f\"train/val/test T = \"\n", - " f\"{split.train.num_timesteps}/\"\n", - " f\"{split.val.num_timesteps}/\"\n", - " f\"{split.test.num_timesteps}\"\n", - ")\n", - "\n", - "sampler = NeighborWindowSampler(\n", - " split.train,\n", - " window_length=2,\n", - " num_nodes=SAMPLER_SEEDS,\n", - " num_hops=2,\n", - " batch_size=BATCH_SIZE,\n", - " windows_per_epoch=WINDOWS_PER_EPOCH,\n", - " seed=SEED,\n", - ")\n", - "\n", - "random.seed(SEED)\n", - "np.random.seed(SEED)\n", - "torch.manual_seed(SEED)\n", - "block_model = build_block_model(in_channels)\n", - "\n", - "rss_before = rss_mb()\n", - "t0 = time.perf_counter()\n", - "block_history = block_model.fit(\n", - " split.train,\n", - " epochs=EPOCHS,\n", - " sampler=sampler,\n", - " lr=LR,\n", - " loss_weights=LOSS_WEIGHTS,\n", - " validation_sequence=split.val,\n", - " early_stopping_patience=max(3, EPOCHS // 2),\n", - " restore_best_weights=True,\n", - ")\n", - "block_train_s = time.perf_counter() - t0\n", - "rss_after = rss_mb()\n", - "print(\n", - " f\"block+sampler train: {block_train_s:.2f}s \"\n", - " f\"final loss={block_history.loss[-1]:.4f} \"\n", - " f\"rss {rss_before:.1f}→{rss_after:.1f} MB\"\n", - ")\n", - "\n", - "# Small-slice dense comparator (feasible memory).\n", - "small_n = min(64, sequence.num_nodes)\n", - "small_seq = make_path_sequence(\n", - " num_nodes=small_n,\n", - " num_timesteps=min(16, sequence.num_timesteps),\n", - " in_channels=in_channels,\n", - " seed=SEED + 1,\n", - ")\n", - "small_split = temporal_split(small_seq)\n", - "random.seed(SEED)\n", - "np.random.seed(SEED)\n", - "torch.manual_seed(SEED)\n", - "dense_small = GraphKoopmanModel(\n", - " encoder=GNNEncoder(in_channels, HIDDEN, LATENT, num_layers=NUM_LAYERS),\n", - " decoder=GNNDecoder(LATENT, HIDDEN, in_channels, num_layers=NUM_LAYERS),\n", - " latent_dim=LATENT,\n", - " time_step=300.0,\n", - " dynamics_mode=\"discrete\",\n", - " koopman=\"graph\",\n", - " koopman_sparsity=\"dense\",\n", - ")\n", - "t1 = time.perf_counter()\n", - "dense_hist = dense_small.fit(\n", - " small_split.train,\n", - " epochs=EPOCHS,\n", - " lr=LR,\n", - " loss_weights=LOSS_WEIGHTS,\n", - ")\n", - "dense_small_s = time.perf_counter() - t1\n", - "DENSE_COMPARATOR_SOURCE = f\"synthetic_path_n{small_n}\"\n", - "print(\n", - " f\"dense full-graph on {DENSE_COMPARATOR_SOURCE}: {dense_small_s:.2f}s \"\n", - " f\"final loss={dense_hist.loss[-1]:.4f}\"\n", - ")\n" - ] - }, - { - "cell_type": "markdown", - "id": "3dd77955", - "metadata": {}, - "source": [ - "## Results: holdout metrics and scale table\n", - "\n", - "`evaluate` / `predict` use the **full** graph even after neighbor-sampled\n", - "training. Metrics use named units; persistence (repeat the last observation) is\n", - "the short-horizon reference.\n", - "\n", - "**What to look at in the figure.** On this PEMS07 teaching window the\n", - "`block+sampler` aggregate RMSE bar sits **above** persistence — the scale demo\n", - "is not a claim that the short train beats a trivial baseline. Prefer the\n", - "per-horizon table for how the gap grows with $h$, and the scale table for\n", - "inverse timing / Jacobi error (RSS should be process-sized, not $10^5$ MB).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "1fa5a0d3", - "metadata": { - "execution": { - "iopub.execute_input": "2026-07-25T23:58:15.020393Z", - "iopub.status.busy": "2026-07-25T23:58:15.020200Z", - "iopub.status.idle": "2026-07-25T23:58:15.469707Z", - "shell.execute_reply": "2026-07-25T23:58:15.469092Z" - } - }, - "outputs": [ + "cell_type": "markdown", + "id": "19e159a9", + "metadata": {}, + "source": [ + "## Helpers: synthetic path graph, timing, persistence\n" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Units: MAE/RMSE in z-scored flow (dimensionless)\n", - "block+sampler agg_mae=0.3992 agg_rmse=0.5035\n", - "persistence agg_rmse=0.3467 (mean over horizons (3, 6, 12))\n", - "Forecast quality vs persistence: persistence wins (expected for this short teaching train)\n", - " h=3 mae=0.2094 rmse=0.2825 persist_rmse=0.2556 Δrmse=+0.0269\n", - " h=6 mae=0.3342 rmse=0.4251 persist_rmse=0.3193 Δrmse=+0.1058\n", - " h=12 mae=0.6540 rmse=0.8027 persist_rmse=0.4651 Δrmse=+0.3376\n" - ] + "cell_type": "code", + "execution_count": 2, + "id": "e8720686", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-25T23:58:13.080897Z", + "iopub.status.busy": "2026-07-25T23:58:13.080733Z", + "iopub.status.idle": "2026-07-25T23:58:13.148329Z", + "shell.execute_reply": "2026-07-25T23:58:13.147847Z" + } + }, + "outputs": [], + "source": [ + "def make_path_sequence(\n", + " *,\n", + " num_nodes: int,\n", + " num_timesteps: int,\n", + " in_channels: int = 1,\n", + " seed: int = SEED,\n", + ") -> GraphSnapshotSequence:\n", + " generator = torch.Generator().manual_seed(seed)\n", + " edge_index = path_edge_index(num_nodes)\n", + " features = torch.randn(\n", + " num_timesteps, num_nodes, in_channels, generator=generator\n", + " )\n", + " for time in range(1, num_timesteps):\n", + " features[time] = 0.9 * features[time - 1] + 0.1 * features[time]\n", + " return GraphSnapshotSequence.from_arrays(features, edge_index)\n", + "\n", + "\n", + "def dense_effective_bytes(num_nodes: int, latent_dim: int) -> int:\n", + " nd = num_nodes * latent_dim\n", + " return nd * nd * 4 # float32\n", + "\n", + "\n", + "def rss_mb() -> float:\n", + " # Prefer process RSS (platform units differ); fall back to tracemalloc.\n", + " try:\n", + " import resource\n", + " import sys\n", + "\n", + " usage = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss\n", + " # Darwin: bytes. Linux: kilobytes.\n", + " if sys.platform == \"darwin\":\n", + " return usage / (1024**2)\n", + " return usage / 1024.0\n", + " except Exception:\n", + " current, _peak = tracemalloc.get_traced_memory()\n", + " return current / (1024**2)\n", + "\n", + "\n", + "def time_inverse_advance(\n", + " op: GraphKoopmanOperator,\n", + " z_next: torch.Tensor,\n", + " edge_index: torch.Tensor,\n", + " *,\n", + " repeats: int = 3,\n", + ") -> tuple[float, float]:\n", + " # Warmup + timed repeats; return (median_ms, rss_mb_after).\n", + " with torch.no_grad():\n", + " _ = op.inverse_advance(z_next, edge_index=edge_index)\n", + " times: list[float] = []\n", + " for _ in range(repeats):\n", + " start = time.perf_counter()\n", + " _ = op.inverse_advance(z_next, edge_index=edge_index)\n", + " if torch.cuda.is_available():\n", + " torch.cuda.synchronize()\n", + " times.append((time.perf_counter() - start) * 1000.0)\n", + " return float(np.median(times)), rss_mb()\n", + "\n", + "\n", + "def time_spectrum_call(\n", + " fn,\n", + " *,\n", + " repeats: int = 3,\n", + ") -> tuple[float, float]:\n", + " \"\"\"Warmup + timed repeats for a zero-arg spectrum callable.\n", + "\n", + " Returns\n", + " -------\n", + " tuple[float, float]\n", + " ``(median_ms, rss_mb_after)``.\n", + " \"\"\"\n", + " with torch.no_grad():\n", + " _ = fn()\n", + " times: list[float] = []\n", + " for _ in range(repeats):\n", + " start = time.perf_counter()\n", + " _ = fn()\n", + " if torch.cuda.is_available():\n", + " torch.cuda.synchronize()\n", + " times.append((time.perf_counter() - start) * 1000.0)\n", + " return float(np.median(times)), rss_mb()\n", + "\n", + "\n", + "def persistence_predict(snapshot: Data, steps: int) -> list[Data]:\n", + " kwargs = {\"x\": snapshot.x.clone(), \"edge_index\": snapshot.edge_index}\n", + " edge_weight = getattr(snapshot, \"edge_weight\", None)\n", + " if edge_weight is not None:\n", + " kwargs[\"edge_weight\"] = edge_weight\n", + " return [Data(**kwargs) for _ in range(steps)]\n", + "\n", + "\n", + "def multi_origin_rmse(predict_fn, test_seq, horizons: tuple[int, ...]) -> dict[int, float]:\n", + " max_horizon = max(horizons)\n", + " origins = range(0, test_seq.num_timesteps - max_horizon)\n", + " sums = {horizon: 0.0 for horizon in horizons}\n", + " n_origins = 0\n", + " for origin in origins:\n", + " preds = predict_fn(test_seq[origin], max_horizon)\n", + " for horizon in horizons:\n", + " sums[horizon] += float(\n", + " kg_rmse(preds[horizon - 1].x, test_seq[origin + horizon].x)\n", + " )\n", + " n_origins += 1\n", + " if n_origins == 0:\n", + " raise ValueError(\"no valid forecast origins for the requested horizons\")\n", + " return {horizon: sums[horizon] / n_origins for horizon in horizons}\n", + "\n", + "\n", + "def build_block_model(in_channels: int) -> GraphKoopmanModel:\n", + " return GraphKoopmanModel(\n", + " encoder=GNNEncoder(\n", + " in_channels, HIDDEN, LATENT, num_layers=NUM_LAYERS\n", + " ),\n", + " decoder=GNNDecoder(\n", + " LATENT, HIDDEN, in_channels, num_layers=NUM_LAYERS\n", + " ),\n", + " latent_dim=LATENT,\n", + " time_step=300.0,\n", + " dynamics_mode=\"discrete\",\n", + " koopman=\"graph\",\n", + " koopman_sparsity=\"block_diagonal\",\n", + " )\n" + ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "markdown", + "id": "d78bed75", + "metadata": {}, + "source": [ + "## Load PEMS07 (or CI synthetic path, N=2000)\n", + "\n", + "Interactive runs load `data/pems07/traffic.pt`. Under pytest / CI we use a\n", + "seeded path graph with 2000 nodes so nbmake needs no PeMS assets.\n" ] - }, - "metadata": {}, - "output_type": "display_data" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Scale / inverse probe summary\n", - "mode N median_ms rss_mb rel_err\n", - "dense 128 5.36 445.9 0.0000\n", - "block_diagonal 128 0.07 445.9 0.0433\n", - "\n", - "Train wall times — block+sampler (N=883): 1.34s; dense synthetic_path_n64: 0.20s\n", - "Jacobi caveat: block inverse rel-err on probe was 0.0433 (dense recovery 1.17e-07).\n" - ] + "cell_type": "code", + "execution_count": 3, + "id": "39aaa265", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-25T23:58:13.149438Z", + "iopub.status.busy": "2026-07-25T23:58:13.149356Z", + "iopub.status.idle": "2026-07-25T23:58:13.176156Z", + "shell.execute_reply": "2026-07-25T23:58:13.175750Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cache_dir=/Users/traviskessler/GitHub-Cursor/KoopmanGraph/data/pems07\n", + "DATA_SOURCE=pems07\n", + "T=288 N=883 F=1 E=1580\n", + "Dense effective matrix float32 budget at d=8: 199.6 MB (not allocated here)\n" + ] + } + ], + "source": [ + "FEATURE_UNIT = \"z-scored feature (dimensionless)\"\n", + "DATA_SOURCE = \"synthetic\"\n", + "\n", + "\n", + "def resolve_pems07_cache_dir() -> Path:\n", + " \"\"\"Locate ``data/pems07`` across package install and notebook cwd layouts.\"\"\"\n", + " candidates = (\n", + " default_variant_cache_dir(\"07\"),\n", + " Path.cwd() / \"data\" / \"pems07\",\n", + " Path.cwd().parent / \"data\" / \"pems07\",\n", + " )\n", + " for cache_dir in candidates:\n", + " if (cache_dir / \"traffic.pt\").is_file():\n", + " return cache_dir.resolve()\n", + " return candidates[0].resolve()\n", + "\n", + "\n", + "if IS_TEST:\n", + " sequence = make_path_sequence(num_nodes=2000, num_timesteps=24, seed=SEED)\n", + " DATA_SOURCE = \"synthetic_path_n2000\"\n", + "else:\n", + " cache_dir = resolve_pems07_cache_dir()\n", + " cache_path = cache_dir / \"traffic.pt\"\n", + " if not cache_path.is_file():\n", + " raise RuntimeError(\n", + " \"PEMS07 teaching cache is missing.\\n\"\n", + " f\"Looked for traffic.pt under:\\n\"\n", + " f\" - {default_variant_cache_dir('07')}\\n\"\n", + " f\" - {Path.cwd() / 'data' / 'pems07'}\\n\"\n", + " f\" - {Path.cwd().parent / 'data' / 'pems07'}\\n\"\n", + " \"Build it from the repo root with (NPZ not bundled):\\n\"\n", + " \" python scripts/download_pems.py --benchmark 07 \\\\\\n\"\n", + " \" --npz-path /path/to/PEMS07.npz --adj-csv /path/to/PEMS07.csv \\\\\\n\"\n", + " \" --expected-sha256 \\n\"\n", + " \"See docs/source/data.rst for the PEMS07 dataset card.\"\n", + " )\n", + " sequence = PemsTrafficBenchmark.load_sequence(variant=\"07\", cache_dir=cache_dir)\n", + " DATA_SOURCE = \"pems07\"\n", + " FEATURE_UNIT = \"z-scored flow (dimensionless)\"\n", + " print(f\"cache_dir={cache_dir}\")\n", + "\n", + "in_channels = sequence.in_channels\n", + "print(f\"DATA_SOURCE={DATA_SOURCE}\")\n", + "print(\n", + " f\"T={sequence.num_timesteps} N={sequence.num_nodes} F={in_channels} \"\n", + " f\"E={sequence.edge_index.shape[1]}\"\n", + ")\n", + "budget = dense_effective_bytes(sequence.num_nodes, LATENT)\n", + "print(\n", + " f\"Dense effective matrix float32 budget at d={LATENT}: \"\n", + " f\"{budget / 1e6:.1f} MB (not allocated here)\"\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "8aa8bd07", + "metadata": {}, + "source": [ + "## Minimal example: sampler + block_diagonal fit step\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "dd2deb4c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-25T23:58:13.177131Z", + "iopub.status.busy": "2026-07-25T23:58:13.177067Z", + "iopub.status.idle": "2026-07-25T23:58:13.287863Z", + "shell.execute_reply": "2026-07-25T23:58:13.287377Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "full N=883 sampled window N=186 (remapped subgraph)\n", + "minimal sampler fit OK\n" + ] + } + ], + "source": [ + "torch.manual_seed(SEED)\n", + "mini_sampler = NeighborWindowSampler(\n", + " sequence,\n", + " window_length=2,\n", + " num_nodes=SAMPLER_SEEDS,\n", + " num_hops=2,\n", + " batch_size=BATCH_SIZE,\n", + " windows_per_epoch=WINDOWS_PER_EPOCH,\n", + " seed=SEED,\n", + ")\n", + "sample_window = next(iter(mini_sampler.iter_epoch(0)))[0]\n", + "print(\n", + " f\"full N={sequence.num_nodes} sampled window N={sample_window.num_nodes} \"\n", + " f\"(remapped subgraph)\"\n", + ")\n", + "\n", + "mini_model = build_block_model(in_channels)\n", + "assert mini_model.koopman.sparsity == \"block_diagonal\"\n", + "_ = mini_model.fit(\n", + " sequence,\n", + " epochs=1,\n", + " sampler=mini_sampler,\n", + " lr=LR,\n", + " loss_weights=LOSS_WEIGHTS,\n", + ")\n", + "print(\"minimal sampler fit OK\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "fc14f5b4", + "metadata": {}, + "source": [ + "## Mid-size probe: dense vs block_diagonal `inverse_advance`\n", + "\n", + "We **do not** materialize a dense $Nd\\times Nd$ inverse on the full teaching\n", + "graph. Instead we time both modes on a mid-size path (`PROBE_N`) with matched\n", + "$K_{\\mathrm{self}}, K_{\\mathrm{nbr}}$, and report relative recovery error for\n", + "the Jacobi approximation.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "98636efb", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-25T23:58:13.289279Z", + "iopub.status.busy": "2026-07-25T23:58:13.289190Z", + "iopub.status.idle": "2026-07-25T23:58:13.340649Z", + "shell.execute_reply": "2026-07-25T23:58:13.340029Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Probe N=128, d=8\n", + " dense inverse median: 5.51 ms rss≈482.1 MB\n", + " block inverse median: 0.07 ms rss≈482.1 MB\n", + " dense recovery rel-err: 1.17e-07 (should be ~0)\n", + " block Jacobi rel-err vs truth: 0.0433\n", + " dense Nd×Nd float32 budget — probe: 4.19 MB; full teaching graph: 199.6 MB\n" + ] + } + ], + "source": [ + "tracemalloc.start()\n", + "probe_edges = path_edge_index(PROBE_N)\n", + "k_self = torch.diag(torch.linspace(0.55, 0.85, LATENT))\n", + "k_nbr = 0.12 * torch.eye(LATENT)\n", + "dense_op = GraphKoopmanOperator(LATENT, init_mode=\"identity\", sparsity=\"dense\")\n", + "block_op = GraphKoopmanOperator(\n", + " LATENT, init_mode=\"identity\", sparsity=\"block_diagonal\"\n", + ")\n", + "dense_op.set_dense_matrices(k_self, k_nbr)\n", + "block_op.set_dense_matrices(k_self.clone(), k_nbr.clone())\n", + "\n", + "torch.manual_seed(SEED)\n", + "z = torch.randn(PROBE_N, LATENT)\n", + "z_next = dense_op.advance(z, edge_index=probe_edges)\n", + "\n", + "dense_ms, dense_rss = time_inverse_advance(dense_op, z_next, probe_edges)\n", + "block_ms, block_rss = time_inverse_advance(block_op, z_next, probe_edges)\n", + "\n", + "with torch.no_grad():\n", + " dense_rec = dense_op.inverse_advance(z_next, edge_index=probe_edges)\n", + " block_rec = block_op.inverse_advance(z_next, edge_index=probe_edges)\n", + " rel_err = float((block_rec - z).norm() / z.norm())\n", + " dense_rec_err = float((dense_rec - z).norm() / z.norm())\n", + "\n", + "probe_budget_mb = dense_effective_bytes(PROBE_N, LATENT) / 1e6\n", + "full_budget_mb = dense_effective_bytes(sequence.num_nodes, LATENT) / 1e6\n", + "\n", + "print(f\"Probe N={PROBE_N}, d={LATENT}\")\n", + "print(f\" dense inverse median: {dense_ms:.2f} ms rss≈{dense_rss:.1f} MB\")\n", + "print(f\" block inverse median: {block_ms:.2f} ms rss≈{block_rss:.1f} MB\")\n", + "print(f\" dense recovery rel-err: {dense_rec_err:.2e} (should be ~0)\")\n", + "print(f\" block Jacobi rel-err vs truth: {rel_err:.4f}\")\n", + "print(\n", + " f\" dense Nd×Nd float32 budget — probe: {probe_budget_mb:.2f} MB; \"\n", + " f\"full teaching graph: {full_budget_mb:.1f} MB\"\n", + ")\n", + "\n", + "timing_rows = [\n", + " {\n", + " \"mode\": \"dense\",\n", + " \"N\": PROBE_N,\n", + " \"median_ms\": dense_ms,\n", + " \"rss_mb\": dense_rss,\n", + " \"rel_err_to_z\": dense_rec_err,\n", + " },\n", + " {\n", + " \"mode\": \"block_diagonal\",\n", + " \"N\": PROBE_N,\n", + " \"median_ms\": block_ms,\n", + " \"rss_mb\": block_rss,\n", + " \"rel_err_to_z\": rel_err,\n", + " },\n", + "]\n" + ] + }, + { + "cell_type": "markdown", + "id": "570c2f23", + "metadata": {}, + "source": [ + "## Mid-size probe: dense vs Kronecker `spectrum`\n", + "\n", + "Same teaching path (`PROBE_N`) and matched factors as the inverse probe.\n", + "Compare wall time for:\n", + "\n", + "1. **Dense path** — assemble `effective_matrix` then `compute_spectrum`\n", + "2. **Kronecker path** — `spectrum_k_eff_kronecker_sum` (what eligible\n", + " `GraphKoopmanOperator.spectrum` uses under `symmetric` / shared self)\n", + "\n", + "This is a **single-\\(N\\)** laptop demo, not a multi-\\(N\\) scaling study.\n", + "Printed milliseconds are machine-dependent — not publication numbers.\n", + "Under `IS_TEST` / CI (`PROBE_N=64`, small `LATENT`) the two paths may be\n", + "comparable (noise-dominated). Interactive defaults (`PROBE_N=128`, larger\n", + "`LATENT`) typically show a clearer qualitative Kronecker wall-time win.\n", + "\n", + "**Inverse honesty.** Kronecker reduction speeds **spectrum only**. Exact\n", + "inverse, Jacobi (`block_diagonal`), and Richardson / Neumann\n", + "(`distributed`) ceilings are unchanged — see Sphinx `limitations` (Scale).\n", + "\n", + "This notebook is **outside** the default nbmake matrix (CI shards cover\n", + "`examples/20`–`26`). Run interactively or\n", + "`IS_TEST=1 pytest --nbmake examples/29_large_graph_block_diagonal.ipynb`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a9bd4d1b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Probe N=128, d=8 (spectrum, single-N demo)\n", + " dense assemble+eig median: 120.44 ms rss≈548.1 MB\n", + " Kronecker spectrum median: 48.39 ms rss≈548.1 MB\n", + " dense/Kronecker wall-time ratio ≈ 2.5× (qualitative only)\n", + " sorted |λ| match (rtol=atol=1e-4): True\n" + ] + } + ], + "source": [ + "def _dense_spectrum():\n", + " return compute_spectrum(\n", + " dense_op.effective_matrix(probe_edges, PROBE_N),\n", + " time_step=1.0,\n", + " )\n", + "\n", + "\n", + "def _kronecker_spectrum():\n", + " return spectrum_k_eff_kronecker_sum(\n", + " k_self=dense_op.K_self,\n", + " k_nbr=dense_op.K_nbr,\n", + " edge_index=probe_edges,\n", + " num_nodes=PROBE_N,\n", + " adjacency=\"symmetric\",\n", + " time_step=1.0,\n", + " )\n", + "\n", + "\n", + "dense_spec_ms, dense_spec_rss = time_spectrum_call(_dense_spectrum)\n", + "kron_spec_ms, kron_spec_rss = time_spectrum_call(_kronecker_spectrum)\n", + "\n", + "with torch.no_grad():\n", + " dense_spec = _dense_spectrum()\n", + " kron_spec = _kronecker_spectrum()\n", + " assert kron_spec is not None\n", + " # Order-invariant magnitude check (phases need not match).\n", + " mag_ok = torch.allclose(\n", + " dense_spec.magnitudes.sort().values,\n", + " kron_spec.magnitudes.sort().values,\n", + " rtol=1e-4,\n", + " atol=1e-4,\n", + " )\n", + "\n", + "ratio = dense_spec_ms / max(kron_spec_ms, 1e-9)\n", + "print(f\"Probe N={PROBE_N}, d={LATENT} (spectrum, single-N demo)\")\n", + "print(f\" dense assemble+eig median: {dense_spec_ms:.2f} ms rss≈{dense_spec_rss:.1f} MB\")\n", + "print(f\" Kronecker spectrum median: {kron_spec_ms:.2f} ms rss≈{kron_spec_rss:.1f} MB\")\n", + "print(f\" dense/Kronecker wall-time ratio ≈ {ratio:.1f}× (qualitative only)\")\n", + "print(f\" sorted |λ| match (rtol=atol=1e-4): {mag_ok}\")\n", + "\n", + "timing_rows.extend(\n", + " [\n", + " {\n", + " \"mode\": \"spectrum_dense\",\n", + " \"N\": PROBE_N,\n", + " \"median_ms\": dense_spec_ms,\n", + " \"rss_mb\": dense_spec_rss,\n", + " \"rel_err_to_z\": float(\"nan\"),\n", + " },\n", + " {\n", + " \"mode\": \"spectrum_kronecker\",\n", + " \"N\": PROBE_N,\n", + " \"median_ms\": kron_spec_ms,\n", + " \"rss_mb\": kron_spec_rss,\n", + " \"rel_err_to_z\": float(\"nan\"),\n", + " },\n", + " ]\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "4dba1900", + "metadata": {}, + "source": [ + "## Train with NeighborWindowSampler on the large graph\n", + "\n", + "Primary path: `block_diagonal` + sampler + forward/reconstruction losses only\n", + "(`backward=0`). Optional dense full-graph fit is restricted to a **synthetic\n", + "path** (`synthetic_path_n≤64`) — not an induced PEMS07 subgraph — so we never\n", + "allocate the full teaching-graph effective matrix.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "16b7748f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-25T23:58:13.342021Z", + "iopub.status.busy": "2026-07-25T23:58:13.341836Z", + "iopub.status.idle": "2026-07-25T23:58:15.018868Z", + "shell.execute_reply": "2026-07-25T23:58:15.018081Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train/val/test T = 201/28/59\n", + "block+sampler train: 1.86s final loss=0.0716 rss 548.1→548.1 MB\n", + "dense full-graph on synthetic_path_n64: 0.20s final loss=0.2015\n" + ] + } + ], + "source": [ + "split = temporal_split(sequence)\n", + "print(\n", + " f\"train/val/test T = \"\n", + " f\"{split.train.num_timesteps}/\"\n", + " f\"{split.val.num_timesteps}/\"\n", + " f\"{split.test.num_timesteps}\"\n", + ")\n", + "\n", + "sampler = NeighborWindowSampler(\n", + " split.train,\n", + " window_length=2,\n", + " num_nodes=SAMPLER_SEEDS,\n", + " num_hops=2,\n", + " batch_size=BATCH_SIZE,\n", + " windows_per_epoch=WINDOWS_PER_EPOCH,\n", + " seed=SEED,\n", + ")\n", + "\n", + "random.seed(SEED)\n", + "np.random.seed(SEED)\n", + "torch.manual_seed(SEED)\n", + "block_model = build_block_model(in_channels)\n", + "\n", + "rss_before = rss_mb()\n", + "t0 = time.perf_counter()\n", + "block_history = block_model.fit(\n", + " split.train,\n", + " epochs=EPOCHS,\n", + " sampler=sampler,\n", + " lr=LR,\n", + " loss_weights=LOSS_WEIGHTS,\n", + " validation_sequence=split.val,\n", + " early_stopping_patience=max(3, EPOCHS // 2),\n", + " restore_best_weights=True,\n", + ")\n", + "block_train_s = time.perf_counter() - t0\n", + "rss_after = rss_mb()\n", + "print(\n", + " f\"block+sampler train: {block_train_s:.2f}s \"\n", + " f\"final loss={block_history.loss[-1]:.4f} \"\n", + " f\"rss {rss_before:.1f}→{rss_after:.1f} MB\"\n", + ")\n", + "\n", + "# Small-slice dense comparator (feasible memory).\n", + "small_n = min(64, sequence.num_nodes)\n", + "small_seq = make_path_sequence(\n", + " num_nodes=small_n,\n", + " num_timesteps=min(16, sequence.num_timesteps),\n", + " in_channels=in_channels,\n", + " seed=SEED + 1,\n", + ")\n", + "small_split = temporal_split(small_seq)\n", + "random.seed(SEED)\n", + "np.random.seed(SEED)\n", + "torch.manual_seed(SEED)\n", + "dense_small = GraphKoopmanModel(\n", + " encoder=GNNEncoder(in_channels, HIDDEN, LATENT, num_layers=NUM_LAYERS),\n", + " decoder=GNNDecoder(LATENT, HIDDEN, in_channels, num_layers=NUM_LAYERS),\n", + " latent_dim=LATENT,\n", + " time_step=300.0,\n", + " dynamics_mode=\"discrete\",\n", + " koopman=\"graph\",\n", + " koopman_sparsity=\"dense\",\n", + ")\n", + "t1 = time.perf_counter()\n", + "dense_hist = dense_small.fit(\n", + " small_split.train,\n", + " epochs=EPOCHS,\n", + " lr=LR,\n", + " loss_weights=LOSS_WEIGHTS,\n", + ")\n", + "dense_small_s = time.perf_counter() - t1\n", + "DENSE_COMPARATOR_SOURCE = f\"synthetic_path_n{small_n}\"\n", + "print(\n", + " f\"dense full-graph on {DENSE_COMPARATOR_SOURCE}: {dense_small_s:.2f}s \"\n", + " f\"final loss={dense_hist.loss[-1]:.4f}\"\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "3dd77955", + "metadata": {}, + "source": [ + "## Results: holdout metrics and scale table\n", + "\n", + "`evaluate` / `predict` use the **full** graph even after neighbor-sampled\n", + "training. Metrics use named units; persistence (repeat the last observation) is\n", + "the short-horizon reference.\n", + "\n", + "**What to look at in the figure.** On this PEMS07 teaching window the\n", + "`block+sampler` aggregate RMSE bar sits **above** persistence — the scale demo\n", + "is not a claim that the short train beats a trivial baseline. Prefer the\n", + "per-horizon table for how the gap grows with $h$, and the scale table for\n", + "inverse timing / Jacobi error (RSS should be process-sized, not $10^5$ MB).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "1fa5a0d3", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-25T23:58:15.020393Z", + "iopub.status.busy": "2026-07-25T23:58:15.020200Z", + "iopub.status.idle": "2026-07-25T23:58:15.469707Z", + "shell.execute_reply": "2026-07-25T23:58:15.469092Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Units: MAE/RMSE in z-scored flow (dimensionless)\n", + "block+sampler agg_mae=0.3992 agg_rmse=0.5035\n", + "persistence agg_rmse=0.3467 (mean over horizons (3, 6, 12))\n", + "Forecast quality vs persistence: persistence wins (expected for this short teaching train)\n", + " h=3 mae=0.2094 rmse=0.2825 persist_rmse=0.2556 Δrmse=+0.0269\n", + " h=6 mae=0.3342 rmse=0.4251 persist_rmse=0.3193 Δrmse=+0.1058\n", + " h=12 mae=0.6540 rmse=0.8027 persist_rmse=0.4651 Δrmse=+0.3376\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Scale / inverse probe summary\n", + "mode N median_ms rss_mb rel_err\n", + "dense 128 5.51 482.1 0.0000\n", + "block_diagonal 128 0.07 482.1 0.0433\n", + "spectrum_dense 128 120.44 548.1 nan\n", + "spectrum_kronecker 128 48.39 548.1 nan\n", + "\n", + "Train wall times — block+sampler (N=883): 1.86s; dense synthetic_path_n64: 0.20s\n", + "Jacobi caveat: block inverse rel-err on probe was 0.0433 (dense recovery 1.17e-07).\n" + ] + } + ], + "source": [ + "block_eval = block_model.evaluate(split.test, horizons=HORIZONS)\n", + "persist_rmses = multi_origin_rmse(persistence_predict, split.test, HORIZONS)\n", + "persist_agg = float(np.mean(list(persist_rmses.values())))\n", + "beats_persist = block_eval.aggregate_rmse < persist_agg\n", + "\n", + "print(f\"Units: MAE/RMSE in {FEATURE_UNIT}\")\n", + "print(\n", + " f\"block+sampler agg_mae={block_eval.aggregate_mae:.4f} \"\n", + " f\"agg_rmse={block_eval.aggregate_rmse:.4f}\"\n", + ")\n", + "print(\n", + " f\"persistence agg_rmse={persist_agg:.4f} \"\n", + " f\"(mean over horizons {HORIZONS})\"\n", + ")\n", + "print(\n", + " \"Forecast quality vs persistence: \"\n", + " + (\n", + " \"model aggregate RMSE is lower\"\n", + " if beats_persist\n", + " else \"persistence wins (expected for this short teaching train)\"\n", + " )\n", + ")\n", + "for metric in block_eval.horizons:\n", + " gap = metric.rmse - persist_rmses[metric.horizon]\n", + " print(\n", + " f\" h={metric.horizon} mae={metric.mae:.4f} rmse={metric.rmse:.4f} \"\n", + " f\"persist_rmse={persist_rmses[metric.horizon]:.4f} \"\n", + " f\"Δrmse={gap:+.4f}\"\n", + " )\n", + "\n", + "labels = [\"block+sampler\", \"persistence\"]\n", + "vals = [block_eval.aggregate_rmse, persist_agg]\n", + "fig, ax = plt.subplots(figsize=(6.5, 3.5))\n", + "ax.bar(labels, vals, color=[\"#2a6f97\", \"#adb5bd\"])\n", + "ax.set_ylabel(f\"Aggregate RMSE\\n({FEATURE_UNIT})\")\n", + "ax.set_title(\"Large-graph block-diagonal forecast (honest teaching run)\")\n", + "ax.grid(axis=\"y\", alpha=0.3)\n", + "fig.tight_layout()\n", + "plt.show()\n", + "\n", + "print(\"\\nScale / inverse probe summary\")\n", + "print(\n", + " f\"{'mode':16s} {'N':>5s} {'median_ms':>10s} {'rss_mb':>8s} \"\n", + " f\"{'rel_err':>10s}\"\n", + ")\n", + "for row in timing_rows:\n", + " print(\n", + " f\"{row['mode']:16s} {row['N']:5d} {row['median_ms']:10.2f} \"\n", + " f\"{row['rss_mb']:8.1f} {row['rel_err_to_z']:10.4f}\"\n", + " )\n", + "print(\n", + " f\"\\nTrain wall times — block+sampler (N={sequence.num_nodes}): \"\n", + " f\"{block_train_s:.2f}s; dense {DENSE_COMPARATOR_SOURCE}: \"\n", + " f\"{dense_small_s:.2f}s\"\n", + ")\n", + "print(\n", + " f\"Jacobi caveat: block inverse rel-err on probe was {rel_err:.4f} \"\n", + " f\"(dense recovery {dense_rec_err:.2e}).\"\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "e50456f1", + "metadata": {}, + "source": [ + "## Interpretation\n", + "\n", + "- **Forward is shared.** Dense and `block_diagonal` use the same sparse advance;\n", + " sparsity mainly changes `inverse_advance` and what you can afford at scale.\n", + "- **Approximate inverse.** One Jacobi step is **not** the exact whole-network\n", + " inverse. Keep `backward=0` unless you accept that bias (Azencot-style\n", + " bidirectional training needs the caveat).\n", + "- **Kronecker spectrum ≠ cheaper inverse.** The mid-size spectrum probe shows\n", + " a qualitative wall-time win for eligible exact spectrum only. Inverse\n", + " remains dense / Jacobi / Richardson as before (Sphinx `limitations` Scale).\n", + "- **Sampler ≠ smaller model at test time.** Training losses see subgraphs;\n", + " evaluation still rolls out on the full sensor graph.\n", + "- **Teaching forecast vs persistence.** On the default PEMS07 window (short\n", + " $T$, modest epochs, `backward=0`), persistence typically wins aggregate and\n", + " per-horizon RMSE. The notebook’s goal is tractable large $N$ training and\n", + " inverse / spectrum timing — not a traffic SOTA claim. Longer data, richer\n", + " losses, or denser schedules may change the gap; they are out of scope here.\n", + "- **Dense comparator is synthetic.** The `synthetic_path_n≤64` dense fit only\n", + " shows that a small dense operator is cheap; it is not dense-on-PEMS07.\n", + "- **When dense is fine.** Tiny $N$ (IEEE 118, small synthetics): prefer\n", + " `koopman_sparsity=\"dense\"` for exact inverse and simpler mental model.\n" + ] + }, + { + "cell_type": "markdown", + "id": "d574ac6d", + "metadata": {}, + "source": [ + "## Takeaways\n", + "\n", + "- Pair `koopman_sparsity=\"block_diagonal\"` with `NeighborWindowSampler` when\n", + " $N$ makes dense $N\\cdot d$ operators or full-graph windows expensive.\n", + "- Measure mid-size inverse timings and the dense $Nd\\times Nd$ byte budget —\n", + " never allocate the full teaching-graph effective matrix “just to compare.”\n", + " Process RSS should stay on the order of hundreds of MB on a laptop demo, not\n", + " $10^5$ MB.\n", + "- At interactive `PROBE_N`, eligible Kronecker spectrum is often faster than\n", + " assemble-then-`eig`; under `IS_TEST` sizes the ratio may be ~1×. Treat the\n", + " printed ratio as qualitative evidence only (single $N$, laptop demo).\n", + "- Kronecker spectrum does **not** shrink inverse or eig-regularization ceilings.\n", + "- State the Jacobi approximate-inverse caveat whenever backward consistency is\n", + " on the table.\n", + "- Do not read a short PEMS07 teaching run as a forecast win: persistence often\n", + " beats `block+sampler` RMSE here; treat the bar chart as an honest baseline\n", + " check, not a leaderboard result.\n", + "- Dense wall-time comparisons in this notebook use `synthetic_path_n≤64`, not\n", + " dense PEMS07.\n", + "- PEMS07 is the largest PEMS0X teaching graph in this repo; fetch the cache\n", + " rather than bundling Caltrans/community archives.\n" + ] + }, + { + "cell_type": "markdown", + "id": "fe2635f9", + "metadata": {}, + "source": [ + "## Further reading\n", + "\n", + "- API: `GraphKoopmanModel(..., koopman=\"graph\", koopman_sparsity=\"block_diagonal\")`,\n", + " `koopman_graph.data.NeighborWindowSampler`,\n", + " `GraphKoopmanOperator.inverse_advance`,\n", + " `koopman_graph.operators.kronecker_spectrum`\n", + "- Architecture: Sphinx `architecture` — sparsity matrix and spectrum routing;\n", + " Sphinx `limitations` — Scale (Kronecker vs inverse ceilings)\n", + "- Dataset card: Sphinx `data` — PEMS07\n", + "- Related notebooks: [`10_advanced_training.ipynb`](10_advanced_training.ipynb),\n", + " [`18_networked_koopman_dynamic_topology.ipynb`](18_networked_koopman_dynamic_topology.ipynb),\n", + " [`28_adaptive_topology_learning.ipynb`](28_adaptive_topology_learning.ipynb)\n", + "- Citations (`paper.bib`): `Mukherjee2022`, `Azarbahram2025`, `Azencot2020`\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "koopmangraph", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.13" } - ], - "source": [ - "block_eval = block_model.evaluate(split.test, horizons=HORIZONS)\n", - "persist_rmses = multi_origin_rmse(persistence_predict, split.test, HORIZONS)\n", - "persist_agg = float(np.mean(list(persist_rmses.values())))\n", - "beats_persist = block_eval.aggregate_rmse < persist_agg\n", - "\n", - "print(f\"Units: MAE/RMSE in {FEATURE_UNIT}\")\n", - "print(\n", - " f\"block+sampler agg_mae={block_eval.aggregate_mae:.4f} \"\n", - " f\"agg_rmse={block_eval.aggregate_rmse:.4f}\"\n", - ")\n", - "print(\n", - " f\"persistence agg_rmse={persist_agg:.4f} \"\n", - " f\"(mean over horizons {HORIZONS})\"\n", - ")\n", - "print(\n", - " \"Forecast quality vs persistence: \"\n", - " + (\n", - " \"model aggregate RMSE is lower\"\n", - " if beats_persist\n", - " else \"persistence wins (expected for this short teaching train)\"\n", - " )\n", - ")\n", - "for metric in block_eval.horizons:\n", - " gap = metric.rmse - persist_rmses[metric.horizon]\n", - " print(\n", - " f\" h={metric.horizon} mae={metric.mae:.4f} rmse={metric.rmse:.4f} \"\n", - " f\"persist_rmse={persist_rmses[metric.horizon]:.4f} \"\n", - " f\"Δrmse={gap:+.4f}\"\n", - " )\n", - "\n", - "labels = [\"block+sampler\", \"persistence\"]\n", - "vals = [block_eval.aggregate_rmse, persist_agg]\n", - "fig, ax = plt.subplots(figsize=(6.5, 3.5))\n", - "ax.bar(labels, vals, color=[\"#2a6f97\", \"#adb5bd\"])\n", - "ax.set_ylabel(f\"Aggregate RMSE\\n({FEATURE_UNIT})\")\n", - "ax.set_title(\"Large-graph block-diagonal forecast (honest teaching run)\")\n", - "ax.grid(axis=\"y\", alpha=0.3)\n", - "fig.tight_layout()\n", - "plt.show()\n", - "\n", - "print(\"\\nScale / inverse probe summary\")\n", - "print(\n", - " f\"{'mode':16s} {'N':>5s} {'median_ms':>10s} {'rss_mb':>8s} \"\n", - " f\"{'rel_err':>10s}\"\n", - ")\n", - "for row in timing_rows:\n", - " print(\n", - " f\"{row['mode']:16s} {row['N']:5d} {row['median_ms']:10.2f} \"\n", - " f\"{row['rss_mb']:8.1f} {row['rel_err_to_z']:10.4f}\"\n", - " )\n", - "print(\n", - " f\"\\nTrain wall times — block+sampler (N={sequence.num_nodes}): \"\n", - " f\"{block_train_s:.2f}s; dense {DENSE_COMPARATOR_SOURCE}: \"\n", - " f\"{dense_small_s:.2f}s\"\n", - ")\n", - "print(\n", - " f\"Jacobi caveat: block inverse rel-err on probe was {rel_err:.4f} \"\n", - " f\"(dense recovery {dense_rec_err:.2e}).\"\n", - ")\n" - ] - }, - { - "cell_type": "markdown", - "id": "e50456f1", - "metadata": {}, - "source": [ - "## Interpretation\n", - "\n", - "- **Forward is shared.** Dense and `block_diagonal` use the same sparse advance;\n", - " sparsity mainly changes `inverse_advance` and what you can afford at scale.\n", - "- **Approximate inverse.** One Jacobi step is **not** the exact whole-network\n", - " inverse. Keep `backward=0` unless you accept that bias (Azencot-style\n", - " bidirectional training needs the caveat).\n", - "- **Sampler ≠ smaller model at test time.** Training losses see subgraphs;\n", - " evaluation still rolls out on the full sensor graph.\n", - "- **Teaching forecast vs persistence.** On the default PEMS07 window (short\n", - " $T$, modest epochs, `backward=0`), persistence typically wins aggregate and\n", - " per-horizon RMSE. The notebook’s goal is tractable large $N$ training and\n", - " inverse timing — not a traffic SOTA claim. Longer data, richer losses, or\n", - " denser schedules may change the gap; they are out of scope here.\n", - "- **Dense comparator is synthetic.** The `synthetic_path_n≤64` dense fit only\n", - " shows that a small dense operator is cheap; it is not dense-on-PEMS07.\n", - "- **When dense is fine.** Tiny $N$ (IEEE 118, small synthetics): prefer\n", - " `koopman_sparsity=\"dense\"` for exact inverse and simpler mental model.\n" - ] - }, - { - "cell_type": "markdown", - "id": "d574ac6d", - "metadata": {}, - "source": [ - "## Takeaways\n", - "\n", - "- Pair `koopman_sparsity=\"block_diagonal\"` with `NeighborWindowSampler` when\n", - " $N$ makes dense $N\\cdot d$ operators or full-graph windows expensive.\n", - "- Measure mid-size inverse timings and the dense $Nd\\times Nd$ byte budget —\n", - " never allocate the full teaching-graph effective matrix “just to compare.”\n", - " Process RSS should stay on the order of hundreds of MB on a laptop demo, not\n", - " $10^5$ MB.\n", - "- State the Jacobi approximate-inverse caveat whenever backward consistency is\n", - " on the table.\n", - "- Do not read a short PEMS07 teaching run as a forecast win: persistence often\n", - " beats `block+sampler` RMSE here; treat the bar chart as an honest baseline\n", - " check, not a leaderboard result.\n", - "- Dense wall-time comparisons in this notebook use `synthetic_path_n≤64`, not\n", - " dense PEMS07.\n", - "- PEMS07 is the largest PEMS0X teaching graph in this repo; fetch the cache\n", - " rather than bundling Caltrans/community archives.\n" - ] - }, - { - "cell_type": "markdown", - "id": "fe2635f9", - "metadata": {}, - "source": [ - "## Further reading\n", - "\n", - "- API: `GraphKoopmanModel(..., koopman=\"graph\", koopman_sparsity=\"block_diagonal\")`,\n", - " `koopman_graph.data.NeighborWindowSampler`,\n", - " `GraphKoopmanOperator.inverse_advance`\n", - "- Architecture: Sphinx `architecture` — sparsity matrix (dense vs block_diagonal)\n", - "- Dataset card: Sphinx `data` — PEMS07\n", - "- Related notebooks: [`10_advanced_training.ipynb`](10_advanced_training.ipynb),\n", - " [`18_networked_koopman_dynamic_topology.ipynb`](18_networked_koopman_dynamic_topology.ipynb),\n", - " [`28_adaptive_topology_learning.ipynb`](28_adaptive_topology_learning.ipynb)\n", - "- Citations (`paper.bib`): `Mukherjee2022`, `Azarbahram2025`, `Azencot2020`\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "koopmangraph", - "language": "python", - "name": "python3" }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.13" - } - }, - "nbformat": 4, - "nbformat_minor": 5 + "nbformat": 4, + "nbformat_minor": 5 } diff --git a/paper.bib b/paper.bib index 714996d..3738b4c 100644 --- a/paper.bib +++ b/paper.bib @@ -864,3 +864,17 @@ @book{Serre1977LinearRepresentations isbn = {978-1-4684-9458-7} } +@article{Ghosh2025, + author = {Ghosh, Ramen}, + title = {Neural {Koopman} forecasting for critical transitions in + infrastructure networks}, + journal = {Intelligent Systems with Applications}, + volume = {27}, + pages = {200575}, + year = {2025}, + month = sep, + doi = {10.1016/j.iswa.2025.200575}, + url = {https://doi.org/10.1016/j.iswa.2025.200575}, + publisher = {Elsevier BV} +} + diff --git a/src/koopman_graph/__init__.py b/src/koopman_graph/__init__.py index 734a327..aa859f6 100644 --- a/src/koopman_graph/__init__.py +++ b/src/koopman_graph/__init__.py @@ -157,4 +157,4 @@ "__version__", "compute_spectrum", ] -__version__ = "0.11.0" +__version__ = "0.12.0" diff --git a/src/koopman_graph/operators/__init__.py b/src/koopman_graph/operators/__init__.py index d0cffa8..6006c3a 100644 --- a/src/koopman_graph/operators/__init__.py +++ b/src/koopman_graph/operators/__init__.py @@ -61,6 +61,16 @@ for networked effective operators (primitives for ``sparsity="distributed"``; **not** trainer DDP / ``[distributed]`` extras; does **not** enable multi-GPU training). +``kronecker_spectrum`` + Exact Kronecker-sum spectrum reduction for eligible networked + operators (``I⊗M_self + Â⊗M_nbr`` for discrete ``K`` or continuous + generator ``L``). Auto-routed from + :meth:`~koopman_graph.operators.graph.GraphKoopmanOperator.spectrum` + and + :meth:`~koopman_graph.operators.continuous_graph.ContinuousGraphKoopmanOperator.spectrum` + when eligible; also available as a power-user import from + ``koopman_graph.operators.kronecker_spectrum`` (not in package + ``__all__``). Distinct from Arnoldi ``matrix_free`` surrogates. ``global_local`` :class:`~koopman_graph.operators.global_local.GlobalLocalKoopmanOperator` (discrete global backbone + low-rank local window correction). diff --git a/src/koopman_graph/operators/continuous_graph.py b/src/koopman_graph/operators/continuous_graph.py index f9998ff..fa7ee05 100644 --- a/src/koopman_graph/operators/continuous_graph.py +++ b/src/koopman_graph/operators/continuous_graph.py @@ -39,6 +39,10 @@ per_node_effective_bilinear_matrices, ) from koopman_graph.operators.graph_types import GRAPH_ADJACENCY_MODES, GraphAdjacency +from koopman_graph.operators.kronecker_spectrum import ( + kronecker_sum_spectrum_eligible, + spectrum_l_eff_kronecker_sum, +) from koopman_graph.spectrum_types import KoopmanSpectrum, compute_generator_spectrum ContinuousGraphSparsity = Literal["dense", "block_diagonal", "distributed"] @@ -750,7 +754,26 @@ def spectrum( """Eigendecomposition of the effective ``N·d`` networked generator. Directed / dual modes may yield complex spectra; growth rates and - frequencies come from the complex eigendecomposition. + frequencies come from the complex eigendecomposition (generator + conventions: real-part growth rates). + + Routing (auto; no path-selection kwarg): + + 1. If Kronecker-sum eligible (shared ``L_self``, + ``adjacency`` in ``{"symmetric", "random_walk"}``, + ``sparsity`` in ``{"dense", "block_diagonal"}``) — exact + reduction via + :func:`~koopman_graph.operators.kronecker_spectrum.spectrum_l_eff_kronecker_sum` + when the helper succeeds. + 2. Else — dense + :func:`~koopman_graph.spectrum_types.compute_generator_spectrum` + on :meth:`effective_generator` (``dual_random_walk``, + ``sparsity="distributed"`` — continuous has no Arnoldi spectrum + path — or Kronecker helper fall-back). + + This routing covers **spectrum only**. ``transition_matrix`` / + :math:`\\exp(\\Delta t\\, L_{\\mathrm{eff}})` caching and inverse + ceilings are unchanged. Parameters ---------- @@ -766,6 +789,22 @@ def spectrum( KoopmanSpectrum Magnitude-sorted spectrum of ``L_eff``. """ + if kronecker_sum_spectrum_eligible( + adjacency=self.adjacency, + sparsity=self.sparsity, + shared_self=True, + ): + kronecker = spectrum_l_eff_kronecker_sum( + l_self=self.L_self, + l_nbr=self.L_nbr, + edge_index=edge_index, + num_nodes=num_nodes, + adjacency=self.adjacency, + edge_weight=edge_weight, + ) + if kronecker is not None: + return kronecker + return compute_generator_spectrum( self.effective_generator(edge_index, num_nodes, edge_weight=edge_weight) ) diff --git a/src/koopman_graph/operators/graph.py b/src/koopman_graph/operators/graph.py index 30d7971..b9b57cf 100644 --- a/src/koopman_graph/operators/graph.py +++ b/src/koopman_graph/operators/graph.py @@ -31,6 +31,10 @@ GraphAdjacency, GraphSparsity, ) +from koopman_graph.operators.kronecker_spectrum import ( + kronecker_sum_spectrum_eligible, + spectrum_k_eff_kronecker_sum, +) from koopman_graph.operators.matrix_free import ( DEFAULT_DISTRIBUTED_SPECTRUM_NUM_MODES, flatten_node_latents, @@ -874,11 +878,26 @@ def spectrum( frequencies are taken from the complex eigendecomposition (no real-dtype assumption on the eigenvalues). - When ``sparsity="distributed"``, returns the ``num_modes`` - largest-modulus Ritz values from matrix-free Arnoldi (eigenvectors - are a placeholder identity of size ``num_modes``, not ambient Ritz - vectors). Dense / ``block_diagonal`` still assemble - :meth:`effective_matrix` (``num_modes`` ignored). + Routing (auto; no path-selection kwarg): + + 1. ``sparsity="distributed"`` — matrix-free Arnoldi + (:func:`~koopman_graph.operators.matrix_free.spectrum_k_eff_graph`): + ``num_modes`` largest-modulus Ritz values; eigenvectors are a + placeholder identity of size ``num_modes``, not ambient Ritz + vectors. + 2. Else if Kronecker-sum eligible (shared ``K_self``, + ``adjacency`` in ``{"symmetric", "random_walk"}``, + ``sparsity`` in ``{"dense", "block_diagonal"}``) — + exact reduction via + :func:`~koopman_graph.operators.kronecker_spectrum.spectrum_k_eff_kronecker_sum` + when the helper succeeds. + 3. Else — dense + :func:`~koopman_graph.spectrum_types.compute_spectrum` on + :meth:`effective_matrix` (``dual_random_walk``, orbit / isotypic + self banks, Kronecker helper fall-back, ``num_modes`` ignored). + + This routing covers **spectrum only**. Exact Kronecker inverse and + eig-regularization assembly ceilings are unchanged. Parameters ---------- @@ -897,7 +916,7 @@ def spectrum( Returns ------- KoopmanSpectrum - Full dense spectrum, or distributed leading-modulus surrogate. + Full ambient spectrum, or distributed leading-modulus surrogate. """ if self.sparsity == "distributed": result = spectrum_k_eff_graph( @@ -911,6 +930,25 @@ def spectrum( k_bwd=None if self._bwd is None else self.K_bwd, ) return _koopman_spectrum_from_eigenvalues(result.eigenvalues, time_step) + + self.ensure_orbit_binding(num_nodes, edge_index=edge_index) + if kronecker_sum_spectrum_eligible( + adjacency=self.adjacency, + sparsity=self.sparsity, + shared_self=not self.uses_orbit_selves, + ): + kronecker = spectrum_k_eff_kronecker_sum( + k_self=self.K_self, + k_nbr=self.K_nbr, + edge_index=edge_index, + num_nodes=num_nodes, + adjacency=self.adjacency, + edge_weight=edge_weight, + time_step=time_step, + ) + if kronecker is not None: + return kronecker + return compute_spectrum( self.effective_matrix(edge_index, num_nodes, edge_weight=edge_weight), time_step, diff --git a/src/koopman_graph/operators/kronecker_spectrum.py b/src/koopman_graph/operators/kronecker_spectrum.py new file mode 100644 index 0000000..a93bdab --- /dev/null +++ b/src/koopman_graph/operators/kronecker_spectrum.py @@ -0,0 +1,545 @@ +"""Kronecker-sum exact spectrum helpers for networked graph operators. + +For the factorized form (discrete ``K`` or continuous generator ``L``) + +.. math:: + + M_{\\mathrm{eff}} + = I_N \\otimes M_{\\mathrm{self}} + + \\widehat{A} \\otimes M_{\\mathrm{nbr}}, + +if :math:`\\widehat{A} v_i = \\lambda_i v_i` and +:math:`(M_{\\mathrm{self}} + \\lambda_i M_{\\mathrm{nbr}}) w_{ij} += \\mu_{ij} w_{ij}`, then + +.. math:: + + M_{\\mathrm{eff}} (v_i \\otimes w_{ij}) = \\mu_{ij}\\, (v_i \\otimes w_{ij}) + +under the package's node-block ``vec`` stacking (C-order ``Z.reshape(-1)`` +with shape ``(N·d,)``, matching +:meth:`~koopman_graph.operators.graph.GraphKoopmanOperator.effective_matrix` +/ +:meth:`~koopman_graph.operators.continuous_graph.ContinuousGraphKoopmanOperator.effective_generator` +and ``torch.kron`` assembly). Ambient eigenvector columns are unit-normalized +``torch.kron(v_i, w_{ij})``. Discrete spectra fill growth rates via +:func:`~koopman_graph.spectrum_types.compute_spectrum`; continuous generator +spectra use :func:`~koopman_graph.spectrum_types.compute_generator_spectrum` +conventions (real-part growth rates). + +Eligibility (callers must gate before use) +----------------------------------------- +* ``sparsity in {"dense", "block_diagonal"}`` (not ``"distributed"``) +* ``adjacency in {"symmetric", "random_walk"}`` (not dual) +* Shared self factor only (no orbit / isotypic per-orbit self banks) + +Honesty +------- +* Exact when eligible; not a ``sparsity=`` mode and not Arnoldi + (``matrix_free`` / ``sparsity="distributed"``). Continuous graph has no + Arnoldi spectrum path — ineligible / failed reduction falls back to dense + ``effective_generator`` eigendecomposition. +* Returns ``None`` when the reduction is unreliable so callers can fall back + to dense assembly — never a silent wrong spectrum. +* Random-walk :math:`\\widehat{A}` is checked with a residual on + ``eig``; symmetric :math:`\\widehat{A}` uses ``eigh`` (Hermitian) with + non-finite checks only. +* Eigenvector columns are defined up to complex phase; consumers should not + assume alignment with dense ``torch.linalg.eig`` phases. +""" + +from __future__ import annotations + +import torch +from torch import Tensor + +from koopman_graph.graph_utils.topology import ( + dense_random_walk_normalized_adjacency, + dense_symmetric_normalized_adjacency, +) +from koopman_graph.operators.graph_types import ( + GRAPH_ADJACENCY_MODES, + GraphAdjacency, + GraphSparsity, +) +from koopman_graph.spectrum_types import KoopmanSpectrum + +__all__ = [ + "DEFAULT_KRONECKER_ADJ_RESIDUAL_TOL", + "eigenvalues_k_eff_kronecker_sum", + "kronecker_sum_spectrum_eligible", + "spectrum_k_eff_kronecker_sum", + "spectrum_l_eff_kronecker_sum", +] + +# Frobenius residual ||Â V - V Λ||_F / ||Â V||_F for random-walk eig. +# Justified as a loose float32 diagonalization sanity check (not a certificate). +DEFAULT_KRONECKER_ADJ_RESIDUAL_TOL = 1e-4 + +_ELIGIBLE_SPARSITY: frozenset[str] = frozenset({"dense", "block_diagonal"}) +_ELIGIBLE_ADJACENCY: frozenset[str] = frozenset({"symmetric", "random_walk"}) + + +def kronecker_sum_spectrum_eligible( + *, + adjacency: GraphAdjacency | str, + sparsity: GraphSparsity | str, + shared_self: bool, +) -> bool: + """Return whether the Kronecker-sum exact spectrum path may be used. + + Parameters + ---------- + adjacency : {"symmetric", "random_walk", "dual_random_walk"} + Neighbor-coupling normalization. Dual mode has two non-commuting + adjacency factors and is never eligible. + sparsity : {"dense", "block_diagonal", "distributed"} + Operator realization. ``"distributed"`` keeps the Arnoldi surrogate. + shared_self : bool + ``True`` when the self term is a single shared ``K_self`` + (``I ⊗ K_self``). ``False`` when orbit / isotypic per-orbit self + banks replace that structure. + + Returns + ------- + bool + ``True`` only when shared-self single-adjacency eligibility holds. + """ + if adjacency not in GRAPH_ADJACENCY_MODES: + return False + if sparsity not in {"dense", "block_diagonal", "distributed"}: + return False + return ( + shared_self + and sparsity in _ELIGIBLE_SPARSITY + and adjacency in _ELIGIBLE_ADJACENCY + ) + + +def _factors_finite(*tensors: Tensor) -> bool: + """Return whether every tensor is finite. + + Parameters + ---------- + *tensors : Tensor + Tensors to check elementwise for finiteness. + + Returns + ------- + bool + ``True`` when every element of every tensor is finite. + """ + return all(bool(torch.isfinite(tensor).all().item()) for tensor in tensors) + + +def _complex_dtype(dtype: torch.dtype) -> torch.dtype: + """Map a real floating dtype to its complex counterpart. + + Parameters + ---------- + dtype : torch.dtype + Real floating dtype (``float32`` or ``float64``). + + Returns + ------- + torch.dtype + Matching complex dtype (``complex64`` or ``complex128``). + """ + return torch.complex64 if dtype == torch.float32 else torch.complex128 + + +def _random_walk_eigendecomposition( + adj: Tensor, + *, + residual_tol: float, +) -> tuple[Tensor, Tensor] | None: + """Eigendecompose a (possibly non-symmetric) adjacency with residual check. + + Parameters + ---------- + adj : Tensor + Dense :math:`N \\times N` random-walk normalized adjacency. + residual_tol : float + Maximum allowed relative Frobenius residual. + + Returns + ------- + tuple[Tensor, Tensor] or None + ``(eigenvalues, eigenvectors)`` with columns of ``eigenvectors`` the + right eigenvectors, or ``None`` if the factorization is unusable. + """ + eigenvalues, eigenvectors = torch.linalg.eig(adj) + if not _factors_finite(eigenvalues, eigenvectors): + return None + reconstructed = eigenvectors @ torch.diag(eigenvalues) + target = adj.to(dtype=eigenvectors.dtype) @ eigenvectors + denom = torch.linalg.vector_norm(target).clamp_min(1e-30) + residual = torch.linalg.vector_norm(target - reconstructed) / denom + if not bool(torch.isfinite(residual).item()): + return None + if float(residual) > residual_tol: + return None + return eigenvalues, eigenvectors + + +def _adjacency_eigenpairs( + edge_index: Tensor, + num_nodes: int, + *, + adjacency: GraphAdjacency | str, + edge_weight: Tensor | None, + dtype: torch.dtype, + residual_tol: float, +) -> tuple[Tensor, Tensor] | None: + """Return eigenpairs of :math:`\\widehat{A}`, or ``None`` on failure. + + Parameters + ---------- + edge_index : Tensor + COO edge index of shape ``(2, E)``. + num_nodes : int + Number of graph nodes ``N``. + adjacency : {"symmetric", "random_walk"} or str + Normalized adjacency mode (eligible Kronecker modes only). + edge_weight : Tensor or None + Optional edge weights of length ``E``. + dtype : torch.dtype + Real floating dtype for dense adjacency assembly. + residual_tol : float + Relative Frobenius residual threshold for non-symmetric + eigendecomposition. + + Returns + ------- + tuple[Tensor, Tensor] or None + Complex ``(eigenvalues, eigenvectors)`` with eigenvector columns, or + ``None`` when the factorization is unusable. + """ + complex_dtype = _complex_dtype(dtype) + if adjacency == "symmetric": + adj = dense_symmetric_normalized_adjacency( + edge_index, + num_nodes, + edge_weight=edge_weight, + dtype=dtype, + ) + if not _factors_finite(adj): + return None + eigenvalues, eigenvectors = torch.linalg.eigh(adj) + if not _factors_finite(eigenvalues, eigenvectors): + return None + return ( + eigenvalues.to(dtype=complex_dtype), + eigenvectors.to(dtype=complex_dtype), + ) + + if adjacency == "random_walk": + adj = dense_random_walk_normalized_adjacency( + edge_index, + num_nodes, + edge_weight=edge_weight, + dtype=dtype, + direction="forward", + ) + if not _factors_finite(adj): + return None + return _random_walk_eigendecomposition(adj, residual_tol=residual_tol) + + return None + + +def _k_eff_eigenpairs_kronecker_sum( + *, + k_self: Tensor, + k_nbr: Tensor, + edge_index: Tensor, + num_nodes: int, + adjacency: GraphAdjacency | str, + edge_weight: Tensor | None, + residual_tol: float, +) -> tuple[Tensor, Tensor] | None: + """Assemble unsorted ambient eigenpairs via Kronecker-sum reduction. + + Parameters + ---------- + k_self : Tensor + Shared self factor of shape ``(d, d)``. + k_nbr : Tensor + Neighbor factor of shape ``(d, d)``. + edge_index : Tensor + COO edge index of shape ``(2, E)``. + num_nodes : int + Number of graph nodes ``N``. + adjacency : {"symmetric", "random_walk"} or str + Normalized adjacency mode. + edge_weight : Tensor or None + Optional edge weights of length ``E``. + residual_tol : float + Relative residual threshold for adjacency eigendecomposition. + + Returns + ------- + tuple[Tensor, Tensor] or None + ``(eigenvalues, eigenvectors)`` with shapes ``(N·d,)`` and + ``(N·d, N·d)`` (unit columns), or ``None`` on failure. + """ + if adjacency not in _ELIGIBLE_ADJACENCY: + return None + if k_self.ndim != 2 or k_nbr.ndim != 2: + return None + if k_self.shape != k_nbr.shape or k_self.shape[0] != k_self.shape[1]: + return None + if num_nodes < 1: + return None + if not _factors_finite(k_self, k_nbr): + return None + + adj_pairs = _adjacency_eigenpairs( + edge_index, + num_nodes, + adjacency=adjacency, + edge_weight=edge_weight, + dtype=k_self.dtype, + residual_tol=residual_tol, + ) + if adj_pairs is None: + return None + adj_eigs, adj_vecs = adj_pairs + + latent_dim = k_self.shape[0] + factor_dtype = _complex_dtype(k_self.dtype) + k_self_c = k_self.to(dtype=factor_dtype) + k_nbr_c = k_nbr.to(dtype=factor_dtype) + ambient_dim = num_nodes * latent_dim + + eigenvalues: list[Tensor] = [] + eigenvectors: list[Tensor] = [] + for index, lam in enumerate(adj_eigs): + block = k_self_c + lam * k_nbr_c + block_eigs, block_vecs = torch.linalg.eig(block) + if not _factors_finite(block_eigs, block_vecs): + return None + node_vec = adj_vecs[:, index] + for mode in range(latent_dim): + ambient = torch.kron(node_vec, block_vecs[:, mode]) + norm = torch.linalg.vector_norm(ambient).clamp_min(1e-30) + ambient = ambient / norm + if not _factors_finite(ambient): + return None + eigenvalues.append(block_eigs[mode].reshape(())) + eigenvectors.append(ambient) + + evals = torch.stack(eigenvalues) + evecs = torch.stack(eigenvectors, dim=1) + if evals.numel() != ambient_dim or evecs.shape != (ambient_dim, ambient_dim): + return None + return evals, evecs + + +def eigenvalues_k_eff_kronecker_sum( + *, + k_self: Tensor, + k_nbr: Tensor, + edge_index: Tensor, + num_nodes: int, + adjacency: GraphAdjacency | str, + edge_weight: Tensor | None = None, + residual_tol: float = DEFAULT_KRONECKER_ADJ_RESIDUAL_TOL, +) -> Tensor | None: + """Compute :math:`K_{\\mathrm{eff}}` eigenvalues via Kronecker-sum reduction. + + Thin wrapper over the shared eigenpair core. Does **not** check + ``sparsity`` / orbit eligibility — callers must gate with + :func:`kronecker_sum_spectrum_eligible` (and ``shared_self``) first. + Returns ``None`` when the reduction is unreliable so the caller can fall + back to dense assembly. + + Parameters + ---------- + k_self : Tensor + Shared self factor with shape ``(d, d)``. + k_nbr : Tensor + Neighbor factor with shape ``(d, d)``. + edge_index : Tensor + Edge index ``(2, E)``. + num_nodes : int + Node count ``N``. + adjacency : {"symmetric", "random_walk"} + Single-factor adjacency mode. Dual mode is unsupported here. + edge_weight : Tensor or None, optional + Optional edge weights ``(E,)``. + residual_tol : float, optional + Random-walk adjacency residual tolerance. Default + :data:`DEFAULT_KRONECKER_ADJ_RESIDUAL_TOL`. + + Returns + ------- + Tensor or None + Complex eigenvalues with shape ``(N·d,)`` (unsorted), or ``None`` + when the reduction is unreliable. + """ + pairs = _k_eff_eigenpairs_kronecker_sum( + k_self=k_self, + k_nbr=k_nbr, + edge_index=edge_index, + num_nodes=num_nodes, + adjacency=adjacency, + edge_weight=edge_weight, + residual_tol=residual_tol, + ) + if pairs is None: + return None + return pairs[0] + + +def spectrum_k_eff_kronecker_sum( + *, + k_self: Tensor, + k_nbr: Tensor, + edge_index: Tensor, + num_nodes: int, + adjacency: GraphAdjacency | str, + edge_weight: Tensor | None = None, + time_step: float = 1.0, + residual_tol: float = DEFAULT_KRONECKER_ADJ_RESIDUAL_TOL, +) -> KoopmanSpectrum | None: + """Exact :math:`K_{\\mathrm{eff}}` spectrum via Kronecker-sum reduction. + + Builds ambient eigenvectors as unit-normalized ``kron(v_i, w_ij)``, sorts + by descending magnitude, and fills growth rates / frequencies with the + same discrete conventions as + :func:`~koopman_graph.spectrum_types.compute_spectrum`. + + Does **not** check ``sparsity`` / orbit eligibility — callers must gate + with :func:`kronecker_sum_spectrum_eligible`. Returns ``None`` when the + reduction is unreliable. + + Parameters + ---------- + k_self : Tensor + Shared self factor with shape ``(d, d)``. + k_nbr : Tensor + Neighbor factor with shape ``(d, d)``. + edge_index : Tensor + Edge index ``(2, E)``. + num_nodes : int + Node count ``N``. + adjacency : {"symmetric", "random_walk"} + Single-factor adjacency mode. + edge_weight : Tensor or None, optional + Optional edge weights ``(E,)``. + time_step : float, optional + Positive discrete sampling interval for growth rates / frequencies. + residual_tol : float, optional + Random-walk adjacency residual tolerance. + + Returns + ------- + KoopmanSpectrum or None + Magnitude-sorted spectrum with ambient eigenvectors, or ``None``. + """ + if time_step <= 0: + return None + pairs = _k_eff_eigenpairs_kronecker_sum( + k_self=k_self, + k_nbr=k_nbr, + edge_index=edge_index, + num_nodes=num_nodes, + adjacency=adjacency, + edge_weight=edge_weight, + residual_tol=residual_tol, + ) + if pairs is None: + return None + eigenvalues, eigenvectors = pairs + magnitudes = eigenvalues.abs() + order = torch.argsort(magnitudes, descending=True) + eigenvalues = eigenvalues[order] + eigenvectors = eigenvectors[:, order] + magnitudes = magnitudes[order] + growth_rates = torch.log(magnitudes.clamp_min(1e-30)) / time_step + frequencies = torch.angle(eigenvalues) / (2 * torch.pi * time_step) + return KoopmanSpectrum( + eigenvalues=eigenvalues, + eigenvectors=eigenvectors, + magnitudes=magnitudes, + growth_rates=growth_rates, + frequencies=frequencies, + time_step=float(time_step), + ) + + +def spectrum_l_eff_kronecker_sum( + *, + l_self: Tensor, + l_nbr: Tensor, + edge_index: Tensor, + num_nodes: int, + adjacency: GraphAdjacency | str, + edge_weight: Tensor | None = None, + residual_tol: float = DEFAULT_KRONECKER_ADJ_RESIDUAL_TOL, +) -> KoopmanSpectrum | None: + """Exact :math:`L_{\\mathrm{eff}}` spectrum via Kronecker-sum reduction. + + Reuses the same eigenpair core as :func:`spectrum_k_eff_kronecker_sum` + (identical Kronecker-sum algebra for generator factors). Sorts by + descending magnitude and fills growth rates / frequencies with the same + continuous conventions as + :func:`~koopman_graph.spectrum_types.compute_generator_spectrum` + (``growth_rates = Re(λ)``, ``frequencies = Im(λ)/(2π)``, + ``time_step=1.0``). + + Does **not** check ``sparsity`` eligibility — callers must gate with + :func:`kronecker_sum_spectrum_eligible`. Returns ``None`` when the + reduction is unreliable. + + Parameters + ---------- + l_self : Tensor + Shared self generator with shape ``(d, d)``. + l_nbr : Tensor + Neighbor generator with shape ``(d, d)``. + edge_index : Tensor + Edge index ``(2, E)``. + num_nodes : int + Node count ``N``. + adjacency : {"symmetric", "random_walk"} + Single-factor adjacency mode. + edge_weight : Tensor or None, optional + Optional edge weights ``(E,)``. + residual_tol : float, optional + Random-walk adjacency residual tolerance. + + Returns + ------- + KoopmanSpectrum or None + Magnitude-sorted generator spectrum with ambient eigenvectors, or + ``None``. + """ + pairs = _k_eff_eigenpairs_kronecker_sum( + k_self=l_self, + k_nbr=l_nbr, + edge_index=edge_index, + num_nodes=num_nodes, + adjacency=adjacency, + edge_weight=edge_weight, + residual_tol=residual_tol, + ) + if pairs is None: + return None + eigenvalues, eigenvectors = pairs + magnitudes = eigenvalues.abs() + order = torch.argsort(magnitudes, descending=True) + eigenvalues = eigenvalues[order] + eigenvectors = eigenvectors[:, order] + magnitudes = magnitudes[order] + growth_rates = eigenvalues.real + frequencies = eigenvalues.imag / (2 * torch.pi) + return KoopmanSpectrum( + eigenvalues=eigenvalues, + eigenvectors=eigenvectors, + magnitudes=magnitudes, + growth_rates=growth_rates, + frequencies=frequencies, + time_step=1.0, + ) diff --git a/tests/test_continuous_graph.py b/tests/test_continuous_graph.py index dbc2d91..281663c 100644 --- a/tests/test_continuous_graph.py +++ b/tests/test_continuous_graph.py @@ -16,7 +16,10 @@ GraphKoopmanOperator, HypergraphKoopmanOperator, ) -from koopman_graph.spectrum_types import discrete_spectrum_at_delta_t +from koopman_graph.spectrum_types import ( + compute_generator_spectrum, + discrete_spectrum_at_delta_t, +) def _path_edge_index(num_nodes: int) -> torch.Tensor: @@ -27,6 +30,47 @@ def _path_edge_index(num_nodes: int) -> torch.Tensor: return torch.tensor(edges, dtype=torch.long).t().contiguous() +def _ring_edge_index(num_nodes: int) -> torch.Tensor: + """Build an undirected ring graph edge index.""" + edges: list[list[int]] = [] + for node in range(num_nodes): + nxt = (node + 1) % num_nodes + edges.extend([[node, nxt], [nxt, node]]) + return torch.tensor(edges, dtype=torch.long).t().contiguous() + + +def _eigvals_match( + left: torch.Tensor, + right: torch.Tensor, + *, + rtol: float, + atol: float, +) -> bool: + """Greedy multiset match of complex eigenvalues (order-invariant).""" + if left.shape != right.shape: + return False + remaining = right.detach().clone() + for value in left.detach(): + diffs = (remaining - value).abs() + index = int(torch.argmin(diffs)) + if not torch.isclose(value, remaining[index], rtol=rtol, atol=atol): + return False + remaining[index] = complex(float("inf"), float("inf")) + return True + + +def _stable_continuous_factors(latent_dim: int) -> tuple[torch.Tensor, torch.Tensor]: + """Return a mildly dissipative self factor and small neighbor coupling.""" + if latent_dim == 2: + l_self = torch.tensor([[-0.4, 0.1], [-0.05, -0.5]]) + else: + torch.manual_seed(11 + latent_dim) + l_self = -0.5 * torch.eye(latent_dim) + 0.05 * torch.randn( + latent_dim, latent_dim + ) + return l_self, 0.12 * torch.eye(latent_dim) + + def _tiny_continuous_graph_model( *, koopman: str = "continuous_graph", @@ -320,6 +364,196 @@ def test_adjacency_modes_advance_match_expm_and_generator_spectrum() -> None: assert torch.isfinite(spectrum.magnitudes).all() +def test_continuous_spectrum_eligible_uses_kronecker_path( + monkeypatch: pytest.MonkeyPatch, +) -> None: + """Default eligible continuous spectrum routes through Kronecker helper.""" + from koopman_graph.operators import continuous_graph as cont_mod + + calls: list[int] = [] + original = cont_mod.spectrum_l_eff_kronecker_sum + + def _spy(**kwargs: object): + calls.append(1) + return original(**kwargs) + + monkeypatch.setattr(cont_mod, "spectrum_l_eff_kronecker_sum", _spy) + edge_index = _path_edge_index(3) + op = ContinuousGraphKoopmanOperator(2, init_mode="identity") + op.set_dense_matrices(*_stable_continuous_factors(2)) + spectrum = op.spectrum(edge_index, 3) + assert len(calls) == 1 + assert spectrum.eigenvalues.shape == (6,) + assert spectrum.eigenvectors.shape == (6, 6) + assert torch.allclose(spectrum.growth_rates, spectrum.eigenvalues.real, atol=0.0) + + +@pytest.mark.parametrize("topology", ["path", "ring"]) +@pytest.mark.parametrize("adjacency", ["symmetric", "random_walk"]) +@pytest.mark.parametrize(("num_nodes", "latent_dim"), [(4, 2), (6, 3)]) +def test_continuous_operator_spectrum_parity_vs_dense_oracle( + topology: str, + adjacency: str, + num_nodes: int, + latent_dim: int, +) -> None: + """ContinuousGraphKoopmanOperator.spectrum matches dense generator oracle. + + Tolerance rtol=atol=1e-5 justified by float32 eig accumulation on N·d ≤ 18. + Orbit / isotypic self banks are N/A on continuous graph. + """ + edge_index = ( + _path_edge_index(num_nodes) + if topology == "path" + else _ring_edge_index(num_nodes) + ) + op = ContinuousGraphKoopmanOperator( + latent_dim, + init_mode="identity", + adjacency=adjacency, # type: ignore[arg-type] + ) + op.set_dense_matrices(*_stable_continuous_factors(latent_dim)) + got = op.spectrum(edge_index, num_nodes) + oracle = compute_generator_spectrum(op.effective_generator(edge_index, num_nodes)) + ambient = num_nodes * latent_dim + assert got.eigenvalues.shape == (ambient,) + assert got.eigenvectors.shape == (ambient, ambient) + assert got.time_step == 1.0 + assert _eigvals_match( + got.eigenvalues, + oracle.eigenvalues, + rtol=1e-5, + atol=1e-5, + ) + assert torch.allclose(got.growth_rates, got.eigenvalues.real, atol=0.0) + assert torch.allclose( + got.frequencies, + got.eigenvalues.imag / (2 * torch.pi), + atol=1e-6, + ) + + +def test_continuous_spectrum_block_diagonal_uses_kronecker( + monkeypatch: pytest.MonkeyPatch, +) -> None: + """Eligible block_diagonal continuous spectrum still routes through Kronecker.""" + from koopman_graph.operators import continuous_graph as cont_mod + + calls: list[int] = [] + original = cont_mod.spectrum_l_eff_kronecker_sum + + def _spy(**kwargs: object): + calls.append(1) + return original(**kwargs) + + monkeypatch.setattr(cont_mod, "spectrum_l_eff_kronecker_sum", _spy) + edge_index = _path_edge_index(4) + op = ContinuousGraphKoopmanOperator( + 2, + init_mode="identity", + sparsity="block_diagonal", + ) + op.set_dense_matrices(*_stable_continuous_factors(2)) + spectrum = op.spectrum(edge_index, 4) + assert len(calls) == 1 + oracle = compute_generator_spectrum(op.effective_generator(edge_index, 4)) + assert _eigvals_match( + spectrum.eigenvalues, + oracle.eigenvalues, + rtol=1e-5, + atol=1e-5, + ) + + +def test_continuous_spectrum_ineligible_skips_kronecker( + monkeypatch: pytest.MonkeyPatch, +) -> None: + """Dual and distributed continuous spectrum dense-route (no Arnoldi). + + Orbit / isotypic banks are N/A on continuous graph; distributed has no + continuous Arnoldi spectrum path and falls back to dense L_eff eigendecomp. + """ + from koopman_graph.operators import continuous_graph as cont_mod + + def _boom(**_kwargs: object): + msg = "kronecker helper should not run on ineligible continuous spectrum" + raise AssertionError(msg) + + monkeypatch.setattr(cont_mod, "spectrum_l_eff_kronecker_sum", _boom) + edge_index = _path_edge_index(3) + l_self, l_nbr = _stable_continuous_factors(2) + + dual = ContinuousGraphKoopmanOperator( + 2, + init_mode="identity", + adjacency="dual_random_walk", + ) + dual.set_dense_matrices(l_self, l_nbr, l_bwd=0.08 * torch.eye(2)) + dual_spec = dual.spectrum(edge_index, 3) + dual_oracle = compute_generator_spectrum(dual.effective_generator(edge_index, 3)) + assert dual_spec.eigenvalues.shape == (6,) + assert _eigvals_match( + dual_spec.eigenvalues, + dual_oracle.eigenvalues, + rtol=1e-5, + atol=1e-5, + ) + + distributed = ContinuousGraphKoopmanOperator( + 2, + init_mode="identity", + sparsity="distributed", + ) + distributed.set_dense_matrices(l_self, l_nbr) + dist_spec = distributed.spectrum(edge_index, 3) + dist_oracle = compute_generator_spectrum( + distributed.effective_generator(edge_index, 3) + ) + assert dist_spec.eigenvalues.shape == (6,) + assert _eigvals_match( + dist_spec.eigenvalues, + dist_oracle.eigenvalues, + rtol=1e-5, + atol=1e-5, + ) + + +def test_continuous_spectrum_moderate_n_kronecker_smoke( + monkeypatch: pytest.MonkeyPatch, +) -> None: + """Moderate-N eligible continuous spectrum finishes via Kronecker (R7). + + N=100, d=2 → ambient 200. Assert finite shapes only; skip dense eigvals. + """ + from koopman_graph.operators import continuous_graph as cont_mod + + calls: list[int] = [] + original = cont_mod.spectrum_l_eff_kronecker_sum + + def _spy(**kwargs: object): + calls.append(1) + return original(**kwargs) + + monkeypatch.setattr(cont_mod, "spectrum_l_eff_kronecker_sum", _spy) + num_nodes = 100 + latent_dim = 2 + ambient = num_nodes * latent_dim + edge_index = _path_edge_index(num_nodes) + op = ContinuousGraphKoopmanOperator( + latent_dim, + init_mode="identity", + adjacency="symmetric", + ) + op.set_dense_matrices(*_stable_continuous_factors(latent_dim)) + spectrum = op.spectrum(edge_index, num_nodes) + assert len(calls) == 1 + assert spectrum.eigenvalues.shape == (ambient,) + assert spectrum.eigenvectors.shape == (ambient, ambient) + assert bool(torch.isfinite(spectrum.eigenvalues).all()) + assert bool(torch.isfinite(spectrum.eigenvectors).all()) + assert bool(torch.isfinite(spectrum.growth_rates).all()) + + def test_directed_discrete_spectrum_matches_transition_eigvals() -> None: """``discrete_spectrum_at_delta_t(L_eff)`` matches ``eigvals(exp(L_eff Δt))``. diff --git a/tests/test_graph_operator.py b/tests/test_graph_operator.py index 3abc69a..cf8a8fc 100644 --- a/tests/test_graph_operator.py +++ b/tests/test_graph_operator.py @@ -2,6 +2,7 @@ from __future__ import annotations +import importlib.util import tempfile from pathlib import Path @@ -21,6 +22,9 @@ dense_symmetric_normalized_adjacency, propagate_latent, ) +from koopman_graph.spectrum_types import compute_spectrum + +_HAS_PYNAUTY = importlib.util.find_spec("pynauty") is not None def _path_edge_index(num_nodes: int) -> torch.Tensor: @@ -31,6 +35,43 @@ def _path_edge_index(num_nodes: int) -> torch.Tensor: return torch.tensor(edges, dtype=torch.long).t().contiguous() +def _ring_edge_index(num_nodes: int) -> torch.Tensor: + """Build an undirected ring graph edge index.""" + edges: list[list[int]] = [] + for node in range(num_nodes): + nxt = (node + 1) % num_nodes + edges.extend([[node, nxt], [nxt, node]]) + return torch.tensor(edges, dtype=torch.long).t().contiguous() + + +def _star_edge_index(num_nodes: int) -> torch.Tensor: + """Build an undirected star with center 0 and leaves 1..N-1.""" + edges: list[list[int]] = [] + for leaf in range(1, num_nodes): + edges.extend([[0, leaf], [leaf, 0]]) + return torch.tensor(edges, dtype=torch.long).t().contiguous() + + +def _eigvals_match( + left: torch.Tensor, + right: torch.Tensor, + *, + rtol: float, + atol: float, +) -> bool: + """Greedy multiset match of complex eigenvalues (order-invariant).""" + if left.shape != right.shape: + return False + remaining = right.detach().clone() + for value in left.detach(): + diffs = (remaining - value).abs() + index = int(torch.argmin(diffs)) + if not torch.isclose(value, remaining[index], rtol=rtol, atol=atol): + return False + remaining[index] = complex(float("inf"), float("inf")) + return True + + def test_k_nbr_zero_matches_pernode_operator() -> None: """Verify K_nbr=0 recovers the per-node Koopman map exactly.""" torch.manual_seed(0) @@ -105,6 +146,218 @@ def test_spectrum_smoke_matches_effective_eigvals() -> None: ) +def test_spectrum_eligible_default_uses_kronecker_path( + monkeypatch: pytest.MonkeyPatch, +) -> None: + """Default shared-self symmetric spectrum routes through Kronecker helper.""" + from koopman_graph.operators import graph as graph_mod + + calls: list[dict[str, object]] = [] + original = graph_mod.spectrum_k_eff_kronecker_sum + + def _spy(**kwargs: object): + calls.append(kwargs) + return original(**kwargs) + + monkeypatch.setattr(graph_mod, "spectrum_k_eff_kronecker_sum", _spy) + edge_index = _path_edge_index(3) + op = GraphKoopmanOperator(2, init_mode="identity") + spectrum = op.spectrum(edge_index, 3, time_step=0.25) + assert len(calls) == 1 + assert spectrum.eigenvalues.shape == (6,) + assert spectrum.eigenvectors.shape == (6, 6) + + +def test_spectrum_ineligible_paths_skip_kronecker( + monkeypatch: pytest.MonkeyPatch, +) -> None: + """Dual, orbit banks, and distributed do not call the Kronecker helper.""" + from koopman_graph.operators import graph as graph_mod + + def _boom(**_kwargs: object): + msg = "kronecker helper should not run on ineligible spectrum paths" + raise AssertionError(msg) + + monkeypatch.setattr(graph_mod, "spectrum_k_eff_kronecker_sum", _boom) + edge_index = _path_edge_index(3) + time_step = 0.1 + + dual = GraphKoopmanOperator(2, init_mode="identity", adjacency="dual_random_walk") + dual_spec = dual.spectrum(edge_index, 3, time_step=time_step) + dual_oracle = compute_spectrum( + dual.effective_matrix(edge_index, 3), + time_step, + ) + assert dual_spec.eigenvalues.shape == (6,) + assert _eigvals_match( + dual_spec.eigenvalues, + dual_oracle.eigenvalues, + rtol=1e-5, + atol=1e-5, + ) + + orbit = GraphKoopmanOperator( + 2, + init_mode="identity", + orbit_partition=((0, 1), (2,)), + ) + orbit_spec = orbit.spectrum(edge_index, 3, time_step=time_step) + orbit_oracle = compute_spectrum( + orbit.effective_matrix(edge_index, 3), + time_step, + ) + assert orbit_spec.eigenvalues.shape == (6,) + assert _eigvals_match( + orbit_spec.eigenvalues, + orbit_oracle.eigenvalues, + rtol=1e-5, + atol=1e-5, + ) + + distributed = GraphKoopmanOperator(2, init_mode="identity", sparsity="distributed") + distributed.set_dense_matrices( + torch.tensor([[0.45, 0.20], [0.05, 0.35]]), + torch.tensor([[0.25, 0.10], [0.15, 0.05]]), + ) + dist_spec = distributed.spectrum(edge_index, 3, num_modes=2) + assert dist_spec.eigenvalues.shape == (2,) + assert dist_spec.eigenvectors.shape == (2, 2) + + +@pytest.mark.skipif(not _HAS_PYNAUTY, reason="pynauty not installed") +def test_spectrum_isotypic_skips_kronecker_and_matches_dense( + monkeypatch: pytest.MonkeyPatch, +) -> None: + """Isotypic self banks dense-route (shared_self False) and match oracle.""" + from koopman_graph.operators import graph as graph_mod + + def _boom(**_kwargs: object): + msg = "kronecker helper should not run for isotypic self banks" + raise AssertionError(msg) + + monkeypatch.setattr(graph_mod, "spectrum_k_eff_kronecker_sum", _boom) + star = _star_edge_index(5) + time_step = 0.1 + op = GraphKoopmanOperator(2, init_mode="identity", isotypic_symmetry=True) + got = op.spectrum(star, 5, time_step=time_step) + oracle = compute_spectrum(op.effective_matrix(star, 5), time_step) + assert op.uses_orbit_selves + assert got.eigenvalues.shape == (10,) + assert _eigvals_match( + got.eigenvalues, + oracle.eigenvalues, + rtol=1e-5, + atol=1e-5, + ) + + +@pytest.mark.parametrize("topology", ["path", "ring"]) +@pytest.mark.parametrize("adjacency", ["symmetric", "random_walk"]) +@pytest.mark.parametrize(("num_nodes", "latent_dim"), [(4, 2), (6, 3)]) +def test_operator_spectrum_parity_vs_dense_oracle( + topology: str, + adjacency: str, + num_nodes: int, + latent_dim: int, +) -> None: + """GraphKoopmanOperator.spectrum matches dense compute_spectrum (small N). + + Tolerance rtol=atol=1e-5 justified by float32 eig accumulation on N·d ≤ 18 + (same contract as helper-level Kronecker parity). + """ + torch.manual_seed(3) + time_step = 0.1 + edge_index = ( + _path_edge_index(num_nodes) + if topology == "path" + else _ring_edge_index(num_nodes) + ) + op = GraphKoopmanOperator( + latent_dim, + init_mode="identity_noise", + init_scale=0.05, + adjacency=adjacency, # type: ignore[arg-type] + ) + got = op.spectrum(edge_index, num_nodes, time_step=time_step) + oracle = compute_spectrum( + op.effective_matrix(edge_index, num_nodes), + time_step, + ) + ambient = num_nodes * latent_dim + assert got.eigenvalues.shape == (ambient,) + assert got.eigenvectors.shape == (ambient, ambient) + assert got.time_step == time_step + assert _eigvals_match( + got.eigenvalues, + oracle.eigenvalues, + rtol=1e-5, + atol=1e-5, + ) + + +def test_operator_spectrum_block_diagonal_uses_kronecker( + monkeypatch: pytest.MonkeyPatch, +) -> None: + """Eligible block_diagonal sparsity still routes through Kronecker.""" + from koopman_graph.operators import graph as graph_mod + + calls: list[int] = [] + original = graph_mod.spectrum_k_eff_kronecker_sum + + def _spy(**kwargs: object): + calls.append(1) + return original(**kwargs) + + monkeypatch.setattr(graph_mod, "spectrum_k_eff_kronecker_sum", _spy) + edge_index = _path_edge_index(4) + op = GraphKoopmanOperator(2, init_mode="identity", sparsity="block_diagonal") + spectrum = op.spectrum(edge_index, 4, time_step=0.1) + assert len(calls) == 1 + oracle = compute_spectrum(op.effective_matrix(edge_index, 4), 0.1) + assert _eigvals_match( + spectrum.eigenvalues, + oracle.eigenvalues, + rtol=1e-5, + atol=1e-5, + ) + + +def test_operator_spectrum_moderate_n_kronecker_smoke( + monkeypatch: pytest.MonkeyPatch, +) -> None: + """Moderate-N eligible spectrum finishes via Kronecker (no tight dense oracle). + + N=100, d=2 → ambient 200. R7: assert finite shapes only; skip dense eigvals. + """ + from koopman_graph.operators import graph as graph_mod + + calls: list[int] = [] + original = graph_mod.spectrum_k_eff_kronecker_sum + + def _spy(**kwargs: object): + calls.append(1) + return original(**kwargs) + + monkeypatch.setattr(graph_mod, "spectrum_k_eff_kronecker_sum", _spy) + num_nodes = 100 + latent_dim = 2 + ambient = num_nodes * latent_dim + edge_index = _path_edge_index(num_nodes) + op = GraphKoopmanOperator( + latent_dim, + init_mode="identity_noise", + init_scale=0.05, + adjacency="symmetric", + ) + spectrum = op.spectrum(edge_index, num_nodes, time_step=1.0) + assert len(calls) == 1 + assert spectrum.eigenvalues.shape == (ambient,) + assert spectrum.eigenvectors.shape == (ambient, ambient) + assert bool(torch.isfinite(spectrum.eigenvalues).all()) + assert bool(torch.isfinite(spectrum.eigenvectors).all()) + assert bool(torch.isfinite(spectrum.magnitudes).all()) + + def test_graph_requires_edge_index_on_advance() -> None: """Networked advance without topology raises.""" op = GraphKoopmanOperator(2, init_mode="identity") diff --git a/tests/test_kronecker_spectrum.py b/tests/test_kronecker_spectrum.py new file mode 100644 index 0000000..766fa3b --- /dev/null +++ b/tests/test_kronecker_spectrum.py @@ -0,0 +1,440 @@ +"""Tests for Kronecker-sum eigenvalue reduction helpers.""" + +from __future__ import annotations + +from unittest.mock import patch + +import pytest +import torch + +from koopman_graph.operators.continuous_graph import ContinuousGraphKoopmanOperator +from koopman_graph.operators.graph import GraphKoopmanOperator +from koopman_graph.operators.kronecker_spectrum import ( + DEFAULT_KRONECKER_ADJ_RESIDUAL_TOL, + eigenvalues_k_eff_kronecker_sum, + kronecker_sum_spectrum_eligible, + spectrum_k_eff_kronecker_sum, + spectrum_l_eff_kronecker_sum, +) +from koopman_graph.spectrum_types import compute_generator_spectrum, compute_spectrum + + +def _path_edge_index(num_nodes: int) -> torch.Tensor: + """Undirected path edge index.""" + src = list(range(num_nodes - 1)) + dst = list(range(1, num_nodes)) + return torch.tensor([src + dst, dst + src], dtype=torch.long) + + +def _ring_edge_index(num_nodes: int) -> torch.Tensor: + """Undirected ring edge index.""" + src = list(range(num_nodes)) + dst = [(i + 1) % num_nodes for i in range(num_nodes)] + return torch.tensor([src + dst, dst + src], dtype=torch.long) + + +def _eigvals_match( + left: torch.Tensor, + right: torch.Tensor, + *, + rtol: float, + atol: float, +) -> bool: + """Greedy multiset match of complex eigenvalues (phase/order invariant). + + Sorting by real/imag flips conjugate-pair order under float noise; matching + each left value to the nearest unused right value is stable for small N·d. + """ + if left.shape != right.shape: + return False + remaining = right.detach().clone() + for value in left.detach(): + diffs = (remaining - value).abs() + index = int(torch.argmin(diffs)) + if not torch.isclose(value, remaining[index], rtol=rtol, atol=atol): + return False + remaining[index] = complex(float("inf"), float("inf")) + return True + + +@pytest.mark.parametrize( + ("adjacency", "sparsity", "shared_self", "expected"), + [ + ("symmetric", "dense", True, True), + ("symmetric", "block_diagonal", True, True), + ("random_walk", "dense", True, True), + ("dual_random_walk", "dense", True, False), + ("symmetric", "distributed", True, False), + ("symmetric", "dense", False, False), + ("random_walk", "block_diagonal", False, False), + ], +) +def test_eligibility_appendix_c( + adjacency: str, + sparsity: str, + shared_self: bool, + expected: bool, +) -> None: + """Eligibility matches design Appendix C.""" + assert ( + kronecker_sum_spectrum_eligible( + adjacency=adjacency, + sparsity=sparsity, + shared_self=shared_self, + ) + is expected + ) + + +@pytest.mark.parametrize("topology", ["path", "ring"]) +@pytest.mark.parametrize("adjacency", ["symmetric", "random_walk"]) +@pytest.mark.parametrize(("num_nodes", "latent_dim"), [(4, 2), (6, 3)]) +def test_eigenvalues_match_dense_effective_matrix( + topology: str, + adjacency: str, + num_nodes: int, + latent_dim: int, +) -> None: + """Kronecker eigvals match dense effective_matrix within float32 noise. + + Tolerance: relative 1e-5 with absolute floor 1e-5 — justified by float32 + ``eigh``/``eig`` accumulation on small teaching graphs (N·d ≤ 18). + """ + torch.manual_seed(0) + if topology == "path": + edge_index = _path_edge_index(num_nodes) + else: + edge_index = _ring_edge_index(num_nodes) + op = GraphKoopmanOperator( + latent_dim, + init_mode="identity_noise", + init_scale=0.05, + adjacency=adjacency, # type: ignore[arg-type] + ) + dense = torch.linalg.eigvals(op.effective_matrix(edge_index, num_nodes)) + reduced = eigenvalues_k_eff_kronecker_sum( + k_self=op.K_self, + k_nbr=op.K_nbr, + edge_index=edge_index, + num_nodes=num_nodes, + adjacency=adjacency, + ) + assert reduced is not None + assert reduced.shape == (num_nodes * latent_dim,) + assert _eigvals_match(reduced, dense, rtol=1e-5, atol=1e-5) + + +def test_nonfinite_factors_return_none() -> None: + """NaN factors refuse the reduction.""" + edge_index = _path_edge_index(3) + k_self = torch.eye(2) + k_nbr = torch.zeros(2, 2) + k_self[0, 0] = torch.nan + assert ( + eigenvalues_k_eff_kronecker_sum( + k_self=k_self, + k_nbr=k_nbr, + edge_index=edge_index, + num_nodes=3, + adjacency="symmetric", + ) + is None + ) + + +def test_dual_adjacency_returns_none() -> None: + """Dual adjacency is unsupported by the eigenvalue helper.""" + edge_index = _path_edge_index(3) + assert ( + eigenvalues_k_eff_kronecker_sum( + k_self=torch.eye(2), + k_nbr=torch.zeros(2, 2), + edge_index=edge_index, + num_nodes=3, + adjacency="dual_random_walk", + ) + is None + ) + + +def test_random_walk_residual_failure_returns_none() -> None: + """Failed random-walk residual check returns None for dense fall-back.""" + edge_index = _path_edge_index(4) + k_self = torch.eye(2) + k_nbr = 0.1 * torch.randn(2, 2) + + def _bad_decomp(adj: torch.Tensor, *, residual_tol: float): + _ = residual_tol + # Valid shapes but deliberately failing residual via mock return of None + # through a huge residual path: return eigenvectors that do not diagonalize. + eigenvalues = torch.ones(adj.shape[0], dtype=torch.complex64) + eigenvectors = torch.eye(adj.shape[0], dtype=torch.complex64) + reconstructed = eigenvectors @ torch.diag(eigenvalues) + target = adj.to(dtype=eigenvectors.dtype) @ eigenvectors + # Force residual path by patching vector_norm ratio — instead return None + # from the private helper by calling through with tiny tol after bad V. + _ = reconstructed, target + return None + + with patch( + "koopman_graph.operators.kronecker_spectrum._random_walk_eigendecomposition", + side_effect=_bad_decomp, + ): + result = eigenvalues_k_eff_kronecker_sum( + k_self=k_self, + k_nbr=k_nbr, + edge_index=edge_index, + num_nodes=4, + adjacency="random_walk", + residual_tol=DEFAULT_KRONECKER_ADJ_RESIDUAL_TOL, + ) + assert result is None + + +def test_random_walk_residual_tol_rejects_bad_basis() -> None: + """Injected identity 'eigenbasis' fails residual and yields None.""" + edge_index = _path_edge_index(5) + k_self = torch.eye(2) + k_nbr = torch.zeros(2, 2) + + real_eig = torch.linalg.eig + + def _spoof_eig(matrix: torch.Tensor): + # Preserve dtype/device but replace V with I so ÂV ≠ VΛ for RW Â. + values, _vectors = real_eig(matrix) + identity = torch.eye( + matrix.shape[0], + dtype=_vectors.dtype, + device=matrix.device, + ) + return values, identity + + with patch("torch.linalg.eig", side_effect=_spoof_eig): + result = eigenvalues_k_eff_kronecker_sum( + k_self=k_self, + k_nbr=k_nbr, + edge_index=edge_index, + num_nodes=5, + adjacency="random_walk", + residual_tol=1e-6, + ) + assert result is None + + +def test_orbit_shared_self_false_is_ineligible() -> None: + """Orbit / isotypic self banks are gated by shared_self=False.""" + assert not kronecker_sum_spectrum_eligible( + adjacency="symmetric", + sparsity="dense", + shared_self=False, + ) + + +@pytest.mark.parametrize("topology", ["path", "ring"]) +@pytest.mark.parametrize("adjacency", ["symmetric", "random_walk"]) +@pytest.mark.parametrize(("num_nodes", "latent_dim"), [(4, 2), (6, 3)]) +def test_spectrum_matches_compute_spectrum_and_residuals( + topology: str, + adjacency: str, + num_nodes: int, + latent_dim: int, +) -> None: + """Full Kronecker spectrum matches dense compute_spectrum; modes residual-small. + + Eigenvalue / metadata tolerance: rtol=atol=1e-5 (float32). Ambient mode + residual ||K_eff u - μ u|| / ||u|| ≤ 1e-4 — phase-invariant subspace + check justified by float32 kron + eig accumulation on N·d ≤ 18. + """ + torch.manual_seed(1) + time_step = 0.1 + if topology == "path": + edge_index = _path_edge_index(num_nodes) + else: + edge_index = _ring_edge_index(num_nodes) + op = GraphKoopmanOperator( + latent_dim, + init_mode="identity_noise", + init_scale=0.05, + adjacency=adjacency, # type: ignore[arg-type] + ) + effective = op.effective_matrix(edge_index, num_nodes) + dense = compute_spectrum(effective, time_step) + reduced = spectrum_k_eff_kronecker_sum( + k_self=op.K_self, + k_nbr=op.K_nbr, + edge_index=edge_index, + num_nodes=num_nodes, + adjacency=adjacency, + time_step=time_step, + ) + assert reduced is not None + ambient = num_nodes * latent_dim + assert reduced.eigenvalues.shape == (ambient,) + assert reduced.eigenvectors.shape == (ambient, ambient) + assert reduced.time_step == time_step + assert _eigvals_match( + reduced.eigenvalues, + dense.eigenvalues, + rtol=1e-5, + atol=1e-5, + ) + assert torch.allclose(reduced.magnitudes, reduced.eigenvalues.abs(), atol=0.0) + assert torch.allclose( + reduced.growth_rates, + torch.log(reduced.magnitudes.clamp_min(1e-30)) / time_step, + atol=1e-6, + ) + assert torch.allclose( + reduced.frequencies, + torch.angle(reduced.eigenvalues) / (2 * torch.pi * time_step), + atol=1e-6, + ) + # Columns are unit-normalized. + col_norms = torch.linalg.vector_norm(reduced.eigenvectors, dim=0) + assert torch.allclose(col_norms, torch.ones_like(col_norms), atol=1e-5) + + effective_c = effective.to(dtype=reduced.eigenvectors.dtype) + for mode in range(ambient): + vector = reduced.eigenvectors[:, mode] + residual = torch.linalg.vector_norm( + effective_c @ vector - reduced.eigenvalues[mode] * vector + ) / torch.linalg.vector_norm(vector).clamp_min(1e-30) + assert float(residual.detach()) <= 1e-4 + + +def test_spectrum_nonfinite_time_step_or_factors_return_none() -> None: + """Invalid time_step or NaN factors yield None.""" + edge_index = _path_edge_index(3) + k_self = torch.eye(2) + k_nbr = torch.zeros(2, 2) + assert ( + spectrum_k_eff_kronecker_sum( + k_self=k_self, + k_nbr=k_nbr, + edge_index=edge_index, + num_nodes=3, + adjacency="symmetric", + time_step=0.0, + ) + is None + ) + k_self = k_self.clone() + k_self[0, 0] = torch.nan + assert ( + spectrum_k_eff_kronecker_sum( + k_self=k_self, + k_nbr=k_nbr, + edge_index=edge_index, + num_nodes=3, + adjacency="symmetric", + time_step=1.0, + ) + is None + ) + + +def test_spectrum_random_walk_residual_failure_returns_none() -> None: + """Spectrum helper returns None when RW adjacency residual fails.""" + edge_index = _path_edge_index(4) + with patch( + "koopman_graph.operators.kronecker_spectrum._random_walk_eigendecomposition", + return_value=None, + ): + result = spectrum_k_eff_kronecker_sum( + k_self=torch.eye(2), + k_nbr=torch.zeros(2, 2), + edge_index=edge_index, + num_nodes=4, + adjacency="random_walk", + time_step=1.0, + ) + assert result is None + + +def test_mode_amplitudes_roundtrip_smoke() -> None: + """Reconstructed eigenvectors support KoopmanSpectrum.mode_amplitudes.""" + torch.manual_seed(2) + num_nodes = 4 + latent_dim = 2 + edge_index = _path_edge_index(num_nodes) + op = GraphKoopmanOperator(latent_dim, init_mode="identity_noise", init_scale=0.05) + spectrum = spectrum_k_eff_kronecker_sum( + k_self=op.K_self, + k_nbr=op.K_nbr, + edge_index=edge_index, + num_nodes=num_nodes, + adjacency="symmetric", + time_step=1.0, + ) + assert spectrum is not None + flat = torch.randn(num_nodes * latent_dim, dtype=torch.float32) + amplitudes = spectrum.mode_amplitudes(flat) + coeffs = amplitudes.to(spectrum.eigenvectors.dtype) + reconstructed = (spectrum.eigenvectors @ coeffs).real + assert torch.allclose(reconstructed, flat, rtol=1e-4, atol=1e-4) + + +@pytest.mark.parametrize("topology", ["path", "ring"]) +@pytest.mark.parametrize("adjacency", ["symmetric", "random_walk"]) +@pytest.mark.parametrize(("num_nodes", "latent_dim"), [(4, 2), (6, 3)]) +def test_spectrum_l_eff_matches_generator_spectrum_and_residuals( + topology: str, + adjacency: str, + num_nodes: int, + latent_dim: int, +) -> None: + """Continuous Kronecker spectrum matches dense generator oracle + residuals. + + Tolerance rtol=atol=1e-5 (float32); residual ≤ 1e-4 on ambient columns. + """ + torch.manual_seed(4) + edge_index = ( + _path_edge_index(num_nodes) + if topology == "path" + else _ring_edge_index(num_nodes) + ) + op = ContinuousGraphKoopmanOperator( + latent_dim, + init_mode="identity", + adjacency=adjacency, # type: ignore[arg-type] + ) + if latent_dim == 2: + l_self = torch.tensor([[-0.4, 0.1], [-0.05, -0.5]]) + else: + l_self = -0.5 * torch.eye(latent_dim) + 0.05 * torch.randn( + latent_dim, latent_dim + ) + op.set_dense_matrices(l_self, 0.12 * torch.eye(latent_dim)) + generator = op.effective_generator(edge_index, num_nodes) + dense = compute_generator_spectrum(generator) + reduced = spectrum_l_eff_kronecker_sum( + l_self=op.L_self, + l_nbr=op.L_nbr, + edge_index=edge_index, + num_nodes=num_nodes, + adjacency=adjacency, + ) + assert reduced is not None + ambient = num_nodes * latent_dim + assert reduced.eigenvalues.shape == (ambient,) + assert reduced.eigenvectors.shape == (ambient, ambient) + assert reduced.time_step == 1.0 + assert _eigvals_match( + reduced.eigenvalues, + dense.eigenvalues, + rtol=1e-5, + atol=1e-5, + ) + assert torch.allclose(reduced.growth_rates, reduced.eigenvalues.real, atol=0.0) + assert torch.allclose( + reduced.frequencies, + reduced.eigenvalues.imag / (2 * torch.pi), + atol=1e-6, + ) + generator_c = generator.to(dtype=reduced.eigenvectors.dtype) + for mode in range(ambient): + vector = reduced.eigenvectors[:, mode] + residual = torch.linalg.vector_norm( + generator_c @ vector - reduced.eigenvalues[mode] * vector + ) / torch.linalg.vector_norm(vector).clamp_min(1e-30) + assert float(residual.detach()) <= 1e-4 From c87d0499cf1d4a5afd16fc59383c11bb3ae76689 Mon Sep 17 00:00:00 2001 From: tjkessler Date: Wed, 5 Aug 2026 13:24:48 -0400 Subject: [PATCH 2/2] Raise 0.12 patch coverage for Kronecker spectrum helpers Add Codecov patch-gate tests for eligibility/shape fall-backs, non-finite adjacency paths, and discrete/continuous dense spectrum routing when the Kronecker helper returns None. Co-authored-by: Cursor --- tests/test_patch_coverage_012.py | 334 +++++++++++++++++++++++++++++++ 1 file changed, 334 insertions(+) create mode 100644 tests/test_patch_coverage_012.py diff --git a/tests/test_patch_coverage_012.py b/tests/test_patch_coverage_012.py new file mode 100644 index 0000000..4c71484 --- /dev/null +++ b/tests/test_patch_coverage_012.py @@ -0,0 +1,334 @@ +"""Patch-coverage guards for the 0.12.0 Codecov patch gate (target ≥ 90%).""" + +from __future__ import annotations + +from unittest.mock import patch + +import pytest +import torch + +from koopman_graph.operators import continuous_graph as continuous_graph_mod +from koopman_graph.operators import graph as graph_mod +from koopman_graph.operators.continuous_graph import ContinuousGraphKoopmanOperator +from koopman_graph.operators.graph import GraphKoopmanOperator +from koopman_graph.operators.kronecker_spectrum import ( + _adjacency_eigenpairs, + _complex_dtype, + _factors_finite, + _k_eff_eigenpairs_kronecker_sum, + _random_walk_eigendecomposition, + eigenvalues_k_eff_kronecker_sum, + kronecker_sum_spectrum_eligible, + spectrum_k_eff_kronecker_sum, + spectrum_l_eff_kronecker_sum, +) + + +def _path_edge_index(num_nodes: int) -> torch.Tensor: + src = list(range(num_nodes - 1)) + dst = list(range(1, num_nodes)) + return torch.tensor([src + dst, dst + src], dtype=torch.long) + + +def test_eligibility_rejects_unknown_adjacency_and_sparsity() -> None: + """Unknown adjacency / sparsity tokens short-circuit to False.""" + assert not kronecker_sum_spectrum_eligible( + adjacency="not_an_adjacency", + sparsity="dense", + shared_self=True, + ) + assert not kronecker_sum_spectrum_eligible( + adjacency="symmetric", + sparsity="not_a_sparsity", + shared_self=True, + ) + + +def test_factors_finite_and_complex_dtype_helpers() -> None: + """Private finite-check and dtype helpers cover float32 / float64 paths.""" + assert _factors_finite(torch.ones(2), torch.zeros(3, 3)) + assert not _factors_finite(torch.tensor([1.0, float("nan")])) + assert _complex_dtype(torch.float32) == torch.complex64 + assert _complex_dtype(torch.float64) == torch.complex128 + + +def test_random_walk_eigendecomposition_nonfinite_residual() -> None: + """Non-finite residual ratio refuses the random-walk factorization.""" + adj = torch.eye(2) + real_norm = torch.linalg.vector_norm + calls = {"n": 0} + + def _nan_norm( + tensor: torch.Tensor, + *args: object, + **kwargs: object, + ) -> torch.Tensor: + calls["n"] += 1 + # Second call is ||ÂV - VΛ||; return NaN so the residual is non-finite. + if calls["n"] >= 2: + return torch.tensor(float("nan"), dtype=torch.float32) + return real_norm(tensor, *args, **kwargs) + + with patch("torch.linalg.vector_norm", side_effect=_nan_norm): + assert _random_walk_eigendecomposition(adj, residual_tol=1e-6) is None + + +def test_adjacency_eigenpairs_symmetric_nonfinite_adj() -> None: + """Non-finite symmetric adjacency assembly yields None.""" + edge_index = _path_edge_index(3) + with patch( + "koopman_graph.operators.kronecker_spectrum.dense_symmetric_normalized_adjacency", + return_value=torch.full((3, 3), float("nan")), + ): + assert ( + _adjacency_eigenpairs( + edge_index, + 3, + adjacency="symmetric", + edge_weight=None, + dtype=torch.float32, + residual_tol=1e-6, + ) + is None + ) + + +def test_adjacency_eigenpairs_symmetric_nonfinite_eigh() -> None: + """Non-finite symmetric eigenpairs yield None.""" + edge_index = _path_edge_index(3) + with patch( + "torch.linalg.eigh", + return_value=( + torch.tensor([float("nan"), 1.0, 1.0]), + torch.eye(3), + ), + ): + assert ( + _adjacency_eigenpairs( + edge_index, + 3, + adjacency="symmetric", + edge_weight=None, + dtype=torch.float32, + residual_tol=1e-6, + ) + is None + ) + + +def test_adjacency_eigenpairs_random_walk_nonfinite_adj() -> None: + """Non-finite random-walk adjacency assembly yields None.""" + edge_index = _path_edge_index(3) + with patch( + "koopman_graph.operators.kronecker_spectrum." + "dense_random_walk_normalized_adjacency", + return_value=torch.full((3, 3), float("nan")), + ): + assert ( + _adjacency_eigenpairs( + edge_index, + 3, + adjacency="random_walk", + edge_weight=None, + dtype=torch.float32, + residual_tol=1e-6, + ) + is None + ) + + +def test_adjacency_eigenpairs_unknown_mode_returns_none() -> None: + """Unsupported adjacency tokens fall through to None.""" + edge_index = _path_edge_index(2) + assert ( + _adjacency_eigenpairs( + edge_index, + 2, + adjacency="dual_random_walk", + edge_weight=None, + dtype=torch.float32, + residual_tol=1e-6, + ) + is None + ) + + +@pytest.mark.parametrize( + ("k_self", "k_nbr", "num_nodes"), + [ + (torch.ones(2), torch.eye(2), 2), # ndim != 2 + (torch.eye(2), torch.eye(3), 2), # shape mismatch + (torch.ones(2, 3), torch.ones(2, 3), 2), # non-square + (torch.eye(2), torch.eye(2), 0), # num_nodes < 1 + ], +) +def test_k_eff_eigenpairs_rejects_bad_shapes( + k_self: torch.Tensor, + k_nbr: torch.Tensor, + num_nodes: int, +) -> None: + """Shape / node-count guards refuse the Kronecker eigenpair core.""" + assert ( + _k_eff_eigenpairs_kronecker_sum( + k_self=k_self, + k_nbr=k_nbr, + edge_index=_path_edge_index(max(num_nodes, 2)), + num_nodes=num_nodes, + adjacency="symmetric", + edge_weight=None, + residual_tol=1e-6, + ) + is None + ) + + +def test_k_eff_eigenpairs_block_eig_nonfinite_returns_none() -> None: + """Non-finite per-λ block eigendecomposition aborts the reduction.""" + edge_index = _path_edge_index(3) + k_self = torch.eye(2) + k_nbr = 0.1 * torch.eye(2) + real_eig = torch.linalg.eig + calls = {"n": 0} + + def _spoof(matrix: torch.Tensor): + calls["n"] += 1 + # First call is adjacency (random_walk path unused); for symmetric, + # adjacency uses eigh. Block eig uses eig — first eig call is a block. + values, vectors = real_eig(matrix) + if matrix.shape == (2, 2): + values = values.clone() + values[0] = complex(float("nan"), 0.0) + return values, vectors + + with patch("torch.linalg.eig", side_effect=_spoof): + assert ( + _k_eff_eigenpairs_kronecker_sum( + k_self=k_self, + k_nbr=k_nbr, + edge_index=edge_index, + num_nodes=3, + adjacency="symmetric", + edge_weight=None, + residual_tol=1e-6, + ) + is None + ) + assert calls["n"] >= 1 + + +def test_k_eff_eigenpairs_nonfinite_ambient_returns_none() -> None: + """Non-finite ambient Kronecker product columns abort the reduction.""" + edge_index = _path_edge_index(3) + with patch( + "torch.kron", + return_value=torch.full((6,), float("nan"), dtype=torch.complex64), + ): + assert ( + _k_eff_eigenpairs_kronecker_sum( + k_self=torch.eye(2), + k_nbr=torch.zeros(2, 2), + edge_index=edge_index, + num_nodes=3, + adjacency="symmetric", + edge_weight=None, + residual_tol=1e-6, + ) + is None + ) + + +def test_k_eff_eigenpairs_shape_mismatch_returns_none() -> None: + """Mismatched stacked ambient dimension refuses the assembled spectrum.""" + edge_index = _path_edge_index(3) + real_stack = torch.stack + + def _short_stack(tensors: list[torch.Tensor], *args: object, **kwargs: object): + if args or kwargs.get("dim") == 1: + # Eigenvector stack path uses dim=1; shorten eigenvalues stack only. + pass + stacked = real_stack(tensors, *args, **kwargs) + if stacked.ndim == 1 and stacked.numel() > 1: + return stacked[:1] + return stacked + + with patch("torch.stack", side_effect=_short_stack): + assert ( + _k_eff_eigenpairs_kronecker_sum( + k_self=torch.eye(2), + k_nbr=torch.zeros(2, 2), + edge_index=edge_index, + num_nodes=3, + adjacency="symmetric", + edge_weight=None, + residual_tol=1e-6, + ) + is None + ) + + +def test_spectrum_helpers_return_none_when_pairs_fail() -> None: + """Public spectrum wrappers propagate None from the eigenpair core.""" + edge_index = _path_edge_index(3) + with patch( + "koopman_graph.operators.kronecker_spectrum._k_eff_eigenpairs_kronecker_sum", + return_value=None, + ): + assert ( + eigenvalues_k_eff_kronecker_sum( + k_self=torch.eye(2), + k_nbr=torch.zeros(2, 2), + edge_index=edge_index, + num_nodes=3, + adjacency="symmetric", + ) + is None + ) + assert ( + spectrum_k_eff_kronecker_sum( + k_self=torch.eye(2), + k_nbr=torch.zeros(2, 2), + edge_index=edge_index, + num_nodes=3, + adjacency="symmetric", + time_step=1.0, + ) + is None + ) + assert ( + spectrum_l_eff_kronecker_sum( + l_self=torch.eye(2), + l_nbr=torch.zeros(2, 2), + edge_index=edge_index, + num_nodes=3, + adjacency="symmetric", + ) + is None + ) + + +def test_operator_spectrum_falls_back_when_kronecker_returns_none( + monkeypatch: pytest.MonkeyPatch, +) -> None: + """Eligible discrete spectrum dense-routes when the helper returns None.""" + + monkeypatch.setattr(graph_mod, "spectrum_k_eff_kronecker_sum", lambda **_: None) + edge_index = _path_edge_index(3) + op = GraphKoopmanOperator(2, init_mode="identity") + spectrum = op.spectrum(edge_index, 3, time_step=0.2) + assert spectrum.eigenvalues.shape == (6,) + assert spectrum.eigenvectors.shape == (6, 6) + + +def test_continuous_spectrum_falls_back_when_kronecker_returns_none( + monkeypatch: pytest.MonkeyPatch, +) -> None: + """Eligible continuous spectrum dense-routes when the helper returns None.""" + + monkeypatch.setattr( + continuous_graph_mod, "spectrum_l_eff_kronecker_sum", lambda **_: None + ) + edge_index = _path_edge_index(3) + op = ContinuousGraphKoopmanOperator(2, init_mode="identity") + spectrum = op.spectrum(edge_index, 3) + assert spectrum.eigenvalues.shape == (6,) + assert spectrum.eigenvectors.shape == (6, 6)