Switch lambda to eigenvalue of L (graph Laplacian), not W

Previously lambda was the eigenvalue of the mixing matrix W.
Now lambda is the eigenvalue of the graph Laplacian L, with W = I - L.

Parser:
- L → lam (was L → 1-lam)
- W → 1-lam (was W → lam)

Library:
- All distributed TFs updated: substitute lam → (1-lam) and regenerate
- Cross-category check uses lambda=0 (trivial one-node graph) instead
  of lambda=1 (which was the old fully-connected-graph edge case)
- Notes updated to reference L instead of W

Display:
- "Linear oracle: L (eigenvalue λ)" instead of W
- About section: add L and W to supported oracles table

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: LaurentLessard

webapp/data/algorithms.json

@@ -613,7 +613,7 @@
     "citation": "Li et al. 2019",
     "doi": "https://doi.org/10.1109/TSP.2019.2926022",
     "bibtex": "@article{li2019decentralized,\n  title={A decentralized proximal-gradient method with network independent step-sizes and separated convergence rates},\n  author={Li, Zhi and Shi, Wei and Yan, Ming},\n  journal={IEEE Transactions on Signal Processing},\n  volume={67},\n  number={17},\n  pages={4494--4506},\n  year={2019},\n  publisher={IEEE}\n}",
-    "notes": "Decentralized algorithm. The transfer function characterizes behavior per spectral mode of the mixing matrix W (eigenvalue λ).",
+    "notes": "Decentralized algorithm. The transfer function characterizes behavior per spectral mode of the graph Laplacian L (eigenvalue λ).",
     "oracles": [
       "grad_f"
     ],
@@ -625,7 +625,7 @@
     "parameters": [
       "alpha"
     ],
-    "transferFunction": "-alpha*lam*(z - 1)/(z**2 - 2*lam*z + lam)",
+    "transferFunction": "(alpha*lam*z - alpha*lam - alpha*z + alpha)/(2*lam*z - lam + z**2 - 2*z + 1)",
     "tfIsMatrix": false,
     "equivalences": {
       "oracle": [
@@ -635,7 +635,7 @@
       "lft": []
     },
     "catalogOnly": false,
-    "tf_latex": "\\frac{- \\alpha \\lambda z + \\alpha \\lambda}{z^{2} - 2 \\lambda z + \\lambda}"
+    "tf_latex": "\\frac{\\alpha \\left(\\lambda - 1\\right) z - \\alpha \\left(\\lambda - 1\\right)}{z^{2} + 2 \\left(\\lambda - 1\\right) z -\\left(\\lambda - 1\\right)}"
   },
   {
     "id": "exact_diffusion",
@@ -644,7 +644,7 @@
     "citation": "Yuan et al. 2018",
     "doi": "https://doi.org/10.1109/TSP.2018.2875898",
     "bibtex": "@article{yuan2018exact,\n  title={Exact diffusion for distributed optimization and learning---{P}art {I}: Algorithm development},\n  author={Yuan, Kun and Ying, Bicheng and Zhao, Xiaochuan and Sayed, Ali H},\n  journal={IEEE Transactions on Signal Processing},\n  volume={67},\n  number={3},\n  pages={708--723},\n  year={2018},\n  publisher={IEEE}\n}",
-    "notes": "Decentralized algorithm using adapt-correct-combine steps. The transfer function characterizes behavior per spectral mode of the mixing matrix W (eigenvalue λ). Oracle-equivalent to NIDS.",
+    "notes": "Decentralized algorithm using adapt-correct-combine steps. The transfer function characterizes behavior per spectral mode of the graph Laplacian L (eigenvalue λ). Oracle-equivalent to NIDS.",
     "oracles": [
       "grad_f"
     ],
@@ -658,7 +658,7 @@
     "parameters": [
       "alpha"
     ],
-    "transferFunction": "-alpha*lam*(z - 1)/(z**2 - 2*lam*z + lam)",
+    "transferFunction": "(alpha*lam*z - alpha*lam - alpha*z + alpha)/(2*lam*z - lam + z**2 - 2*z + 1)",
     "tfIsMatrix": false,
     "equivalences": {
       "oracle": [
@@ -668,7 +668,7 @@
       "lft": []
     },
     "catalogOnly": false,
-    "tf_latex": "\\frac{- \\alpha \\lambda z + \\alpha \\lambda}{z^{2} - 2 \\lambda z + \\lambda}"
+    "tf_latex": "\\frac{\\alpha \\left(\\lambda - 1\\right) z - \\alpha \\left(\\lambda - 1\\right)}{z^{2} + 2 \\left(\\lambda - 1\\right) z -\\left(\\lambda - 1\\right)}"
   },
   {
     "id": "extra_distributed",
@@ -691,15 +691,15 @@
     "parameters": [
       "alpha"
     ],
-    "transferFunction": "(-2*alpha*z + 2*alpha)/(-2*lam*z + lam + 2*z**2 - 2*z + 1)",
+    "transferFunction": "(-2*alpha*z + 2*alpha)/(2*lam*z - lam + 2*z**2 - 4*z + 2)",
     "tfIsMatrix": false,
     "equivalences": {
       "oracle": [],
       "shift": [],
       "lft": []
     },
     "catalogOnly": false,
-    "tf_latex": "\\frac{- 2 \\alpha z + 2 \\alpha}{2 z^{2} - 2 \\left(\\lambda + 1\\right) z + \\lambda + 1}"
+    "tf_latex": "\\frac{- 2 \\alpha z + 2 \\alpha}{2 z^{2} + 2 \\left(\\lambda - 2\\right) z -\\left(\\lambda - 2\\right)}"
   },
   {
     "id": "diging",
@@ -723,15 +723,15 @@
     "parameters": [
       "alpha"
     ],
-    "transferFunction": "(-alpha*z + alpha)/(lam**2 - 2*lam*z + z**2)",
+    "transferFunction": "(-alpha*z + alpha)/(lam**2 + 2*lam*z - 2*lam + z**2 - 2*z + 1)",
     "tfIsMatrix": false,
     "equivalences": {
       "oracle": [],
       "shift": [],
       "lft": []
     },
     "catalogOnly": false,
-    "tf_latex": "\\frac{- \\alpha z + \\alpha}{z^{2} - 2 \\lambda z + \\lambda^{2}}"
+    "tf_latex": "\\frac{- \\alpha z + \\alpha}{z^{2} + 2 \\left(\\lambda - 1\\right) z + \\left(\\lambda - 1\\right)^{2}}"
   },
   {
     "id": "augdgm",
@@ -755,15 +755,15 @@
     "parameters": [
       "alpha"
     ],
-    "transferFunction": "(-alpha*lam*z + alpha*lam)/(lam**2 - 2*lam*z + z**2)",
+    "transferFunction": "(alpha*lam*z - alpha*lam - alpha*z + alpha)/(lam**2 + 2*lam*z - 2*lam + z**2 - 2*z + 1)",
     "tfIsMatrix": false,
     "equivalences": {
       "oracle": [],
       "shift": [],
       "lft": []
     },
     "catalogOnly": false,
-    "tf_latex": "\\frac{- \\alpha \\lambda z + \\alpha \\lambda}{z^{2} - 2 \\lambda z + \\lambda^{2}}"
+    "tf_latex": "\\frac{\\alpha \\left(\\lambda - 1\\right) z - \\alpha \\left(\\lambda - 1\\right)}{z^{2} + 2 \\left(\\lambda - 1\\right) z + \\left(\\lambda - 1\\right)^{2}}"
   },
   {
     "id": "svl",
@@ -790,15 +790,15 @@
       "gamma",
       "delta"
     ],
-    "transferFunction": "(-alpha*delta*lam*z + alpha*delta*lam + alpha*delta*z - alpha*delta - alpha*z + alpha)/(-beta*lam + beta - gamma*lam*z + gamma*lam + gamma*z - gamma + z**2 - 2*z + 1)",
+    "transferFunction": "(alpha*delta*lam*z - alpha*delta*lam - alpha*z + alpha)/(beta*lam + gamma*lam*z - gamma*lam + z**2 - 2*z + 1)",
     "tfIsMatrix": false,
     "equivalences": {
       "oracle": [],
       "shift": [],
       "lft": []
     },
     "catalogOnly": false,
-    "tf_latex": "\\frac{- \\alpha \\left(\\delta \\lambda - \\delta + 1\\right) z + \\alpha \\left(\\delta \\lambda - \\delta + 1\\right)}{z^{2} -\\left(\\gamma \\lambda - \\gamma + 2\\right) z - \\beta \\lambda + \\beta + \\gamma \\lambda - \\gamma + 1}"
+    "tf_latex": "\\frac{\\alpha \\left(\\delta \\lambda - 1\\right) z - \\alpha \\left(\\delta \\lambda - 1\\right)}{z^{2} + \\left(\\gamma \\lambda - 2\\right) z + \\beta \\lambda - \\gamma \\lambda + 1}"
   },
   {
     "id": "unified_extra",
@@ -824,15 +824,15 @@
       "l",
       "mu"
     ],
-    "transferFunction": "(-alpha*z + alpha)/(-alpha*l*lam**2*mu**2 + 2*alpha*l*lam*mu**2 - alpha*l*lam*mu - alpha*l*mu**2 + alpha*l*mu + lam**2*mu**2 - 2*lam*mu**2 - 2*lam*mu*z + 2*lam*mu + mu**2 + 2*mu*z - 2*mu + z**2 - 2*z + 1)",
+    "transferFunction": "(-alpha*z + alpha)/(-alpha*l*lam**2*mu**2 + alpha*l*lam*mu + lam**2*mu**2 + 2*lam*mu*z - 2*lam*mu + z**2 - 2*z + 1)",
     "tfIsMatrix": false,
     "equivalences": {
       "oracle": [],
       "shift": [],
       "lft": []
     },
     "catalogOnly": false,
-    "tf_latex": "\\frac{- \\alpha z + \\alpha}{z^{2} - 2 \\left(\\lambda \\mu - \\mu + 1\\right) z - \\left(\\lambda \\mu - \\mu + 1\\right) \\left(\\alpha l \\lambda \\mu - \\alpha l \\mu - \\lambda \\mu + \\mu - 1\\right)}"
+    "tf_latex": "\\frac{- \\alpha z + \\alpha}{z^{2} + 2 \\left(\\lambda \\mu - 1\\right) z - \\left(\\lambda \\mu - 1\\right) \\left(\\alpha l \\lambda \\mu - \\lambda \\mu + 1\\right)}"
   },
   {
     "id": "unified_diging",
@@ -858,14 +858,14 @@
       "l",
       "mu"
     ],
-    "transferFunction": "(-alpha*z + alpha)/(-alpha*l*lam*mu + alpha*l*mu + lam**2*mu**2 - 2*lam*mu**2 - 2*lam*mu*z + 2*lam*mu + mu**2 + 2*mu*z - 2*mu + z**2 - 2*z + 1)",
+    "transferFunction": "(-alpha*z + alpha)/(alpha*l*lam*mu + lam**2*mu**2 + 2*lam*mu*z - 2*lam*mu + z**2 - 2*z + 1)",
     "tfIsMatrix": false,
     "equivalences": {
       "oracle": [],
       "shift": [],
       "lft": []
     },
     "catalogOnly": false,
-    "tf_latex": "\\frac{- \\alpha z + \\alpha}{z^{2} - 2 \\left(\\lambda \\mu - \\mu + 1\\right) z - \\alpha l \\lambda \\mu + \\alpha l \\mu + \\lambda^{2} \\mu^{2} - 2 \\lambda \\mu^{2} + 2 \\lambda \\mu + \\mu^{2} - 2 \\mu + 1}"
+    "tf_latex": "\\frac{- \\alpha z + \\alpha}{z^{2} + 2 \\left(\\lambda \\mu - 1\\right) z + \\alpha l \\lambda \\mu + \\lambda^{2} \\mu^{2} - 2 \\lambda \\mu + 1}"
   }
 ]

webapp/index.html

@@ -130,6 +130,8 @@ <h3>Supported Oracles</h3>
           <tr><td><code>prox_f(x)</code>, <code>prox_g(x)</code></td><td>Proximal operator</td></tr>
           <tr><td><code>prox_fstar(x)</code>, <code>prox_gstar(x)</code></td><td>Proximal operator of the conjugate</td></tr>
           <tr><td><code>subgrad_f(x)</code></td><td>Subdifferential</td></tr>
+          <tr><td><code>L</code></td><td>Graph Laplacian (linear oracle, eigenvalue &lambda;)</td></tr>
+          <tr><td><code>W</code></td><td>Mixing matrix (linear oracle, W = I &minus; L)</td></tr>
         </tbody>
       </table>
 

webapp/js/katex-helpers.js

@@ -21,7 +21,7 @@ function oracleToLatex(name) {
 
 /**
  * Build the composition LaTeX: [matrix] \diamond \begin{bmatrix} oracles \end{bmatrix}
- * For distributed algorithms, appends: Linear oracle: W (eigenvalue λ)
+ * For distributed algorithms, appends: Linear oracle: L (eigenvalue λ)
  * @param {string} tfLatex - LaTeX for the transfer function matrix
  * @param {string[]} oracles - oracle name strings, e.g. ["prox_f", "prox_g"]
  * @param {boolean} [distributed] - whether this is a distributed algorithm
@@ -37,7 +37,7 @@ function compositionLatex(tfLatex, oracles, distributed) {
 }
 
 /**
- * Render a "Linear oracle: W (eigenvalue λ)" line as a separate KaTeX element.
+ * Render a "Linear oracle: L (eigenvalue λ)" line as a separate KaTeX element.
  * @returns {HTMLElement|null} A div with the rendered line, or null if not distributed.
  */
 function linearOracleElement(distributed) {
@@ -46,11 +46,11 @@ function linearOracleElement(distributed) {
   div.style.cssText = 'margin-top:0.3rem;font-size:0.85rem;color:#0d47a1;';
   try {
     katex.render(
-      '\\text{Linear oracle: } W \\text{ (eigenvalue } \\lambda \\text{)}',
+      '\\text{Linear oracle: } L \\text{ (eigenvalue } \\lambda \\text{)}',
       div, { throwOnError: false }
     );
   } catch (e) {
-    div.textContent = 'Linear oracle: W (eigenvalue λ)';
+    div.textContent = 'Linear oracle: L (eigenvalue λ)';
   }
   return div;
 }

webapp/python/library.py

@@ -140,32 +140,32 @@ def check_all_equivalences(H_user, user_oracles, library, z_var,
         # Determine universal params for this comparison.
         # Both distributed: lambda is universal (must match for all values).
         # Neither distributed: no universal params.
-        # Cross-category: try lambda=1 substitution (fully connected graph).
+        # Cross-category: try lambda=0 substitution (trivial one-node graph).
         if user_distributed and lib_distributed:
             universal_params = user_universal_set | set(algo.get('universal_params', []))
         elif not user_distributed and not lib_distributed:
             universal_params = set()
         else:
-            # Cross-category: substitute lambda=1 in the distributed TF
+            # Cross-category: substitute lambda=0 in the distributed TF
             lam_sym = PARAMS['lam']
             if lib_distributed:
-                H_lib_cross = H_lib.applyfunc(lambda e: _cancel(e.subs(lam_sym, 1)))
+                H_lib_cross = H_lib.applyfunc(lambda e: _cancel(e.subs(lam_sym, 0)))
             else:
                 H_lib_cross = H_lib
             if user_distributed:
-                H_user_cross = H_user.applyfunc(lambda e: _cancel(e.subs(lam_sym, 1)))
+                H_user_cross = H_user.applyfunc(lambda e: _cancel(e.subs(lam_sym, 0)))
             else:
                 H_user_cross = H_user
-            # Try oracle equivalence with lambda=1 substitution
+            # Try oracle equivalence with lambda=0 substitution
             if sorted(user_oracles) == sorted(lib_oracles):
                 result = check_oracle_equivalence(
                     H_user_cross, H_lib_cross, z_var,
                     lib_params=algo.get('param_symbols')
                 )
                 if result['match']:
                     result['condition_note'] = (
-                        '\\text{Equivalent when } \\lambda=1 '
-                        '\\text{ (fully connected graph)}')
+                        '\\text{Equivalent when } \\lambda=0 '
+                        '\\text{ (trivial one-node graph)}')
                     matches.append({
                         'algorithm': algo,
                         'type': 'oracle',

webapp/python/parser.py

@@ -135,8 +135,8 @@ def parse_equations(equations):
     # for correct LaTeX rendering, consistent with library.py).
     equations = [re.sub(r'\blambda\b', 'lam', eq) for eq in equations]
 
-    # Detect linear oracles W (mixing matrix) and L (graph Laplacian).
-    # W has eigenvalue lambda; L has eigenvalue 1-lambda (since W = I - L
+    # Detect linear oracles L (graph Laplacian) and W (mixing matrix).
+    # L has eigenvalue lambda; W has eigenvalue 1-lambda (since W = I - L
     # in the simplest case, or W = I - mu*L with mu as a free parameter).
     # After rewriting, lam flows through the z-domain pipeline normally
     # but is marked as a universal parameter (must match for ALL lambda).
@@ -146,12 +146,12 @@ def parse_equations(equations):
     has_L = any(re.search(r'\bL\b', eq) for eq in equations)
     has_mixing_matrix = has_W or has_L
     if has_mixing_matrix:
-        # Replace W -> lam, L -> (1-lam), I -> 1
-        # Order matters: do L before I to avoid I in (1-lam) being replaced
-        if has_L:
-            equations = [re.sub(r'\bL\b', '(1-lam)', eq) for eq in equations]
+        # Replace L -> lam, W -> (1-lam), I -> 1
+        # Order matters: do W before I to avoid I in (1-lam) being replaced
         if has_W:
-            equations = [re.sub(r'\bW\b', 'lam', eq) for eq in equations]
+            equations = [re.sub(r'\bW\b', '(1-lam)', eq) for eq in equations]
+        if has_L:
+            equations = [re.sub(r'\bL\b', 'lam', eq) for eq in equations]
         equations = [re.sub(r'\bI\b', '1', eq) for eq in equations]
 
     # Pre-process: merge shifted oracle calls into single oracles