fix xc_equal bug

Author: jeanwsr

pyscf/dh/test/test_xccode.py

@@ -1,5 +1,5 @@
 import unittest
-from pyscf.dh.xccode import XCList, parse_xc_dh
+from pyscf.dh.xccode import XCList, parse_xc_dh, xc_equal
 
 
 class TestXCCode(unittest.TestCase):
@@ -46,6 +46,14 @@ def xc_io(inp, out, code_scf=False):
         xc_io("0.5*Slater + 0.8*B88, 0.3*DFTD4(rs6=1.5)", "0.8*B88 + 0.5*SLATER, 0.3*DFTD4(RS6=1.5)")
         xc_io("0.75*HF + 0.25*PBE,", "0.75*HF + 0.25*PBE,")
 
+    def test_xc_equal(self):
+        # alias canonicalization through pyscf XC_CODES
+        self.assertTrue(xc_equal("B3LYP", "B3LYPg"))
+        self.assertTrue(xc_equal("PBE0", "PBE1PBE"))
+        self.assertTrue(xc_equal("HF", "HF,"))
+        self.assertFalse(xc_equal("B3LYP", "B3LYP5"))
+        self.assertFalse(xc_equal("B3LYP", "PBE0"))
+
     def test_d3_behavior(self):
         # Code string + D3 without XC= → NotImplementedError
         with self.assertRaises(NotImplementedError):

pyscf/dh/xccode/parse.py

@@ -82,11 +82,17 @@ def _hash_val(xid):
 
 
 def xc_equal(a, b):
+    r"""Compare two SCF-level XC functionals for equality after alias canonicalization.
+
+    Both arguments must be plain SCF functional names or code strings; DH
+    functional names are not accepted here. Extract the SCF part first, e.g.
+    ``XCList("XYG3", code_scf=True).token``.
+    """
     if a is None and b is None:
         return True
     if a is None or b is None:
         return False
-    return XCList(a, code_scf=True) == XCList(b, code_scf=True)
+    return XCList(a, code_scf=False) == XCList(b, code_scf=False)
 
 
 def _check_unsupported(name):

pyscf/dh/xccode/xccode.py

@@ -27,7 +27,7 @@
 import warnings
 from typing import List
 from .xctype import XCType
-from .xcinfo import XCInfo, REGEX_XC
+from .xcinfo import XCInfo, REGEX_XC, _canonical_xc_name
 from .xcjson import _NAME_WITH_DASH, FUNCTIONALS_DICT
 
 
@@ -339,11 +339,17 @@ def __imul__(self, other: float):
         return self
 
     def __eq__(self, other: "XCList"):
-        tokens_self = [str(info) for info in self.xc_list]
-        tokens_other = [str(info) for info in other.xc_list]
-        tokens_self.sort()
-        tokens_other.sort()
-        return "".join(tokens_self) == "".join(tokens_other)
+        def info_key(info: XCInfo):
+            return (
+                info.fac,
+                _canonical_xc_name(info.name),
+                tuple(str(p) for p in info.parameters),
+                tuple(sorted((k.upper(), str(v)) for k, v in info.parameters_keyword.items())),
+            )
+
+        tokens_self = sorted(info_key(info) for info in self.xc_list)
+        tokens_other = sorted(info_key(info) for info in other.xc_list)
+        return tokens_self == tokens_other
 
     # endregion
 

pyscf/dh/xccode/xcinfo.py

@@ -41,11 +41,28 @@
 from .xctype import XCType
 from .xcjson import ADV_CORR_ALIAS, ADV_CORR_DICT
 from pyscf import dft
+from pyscf.dft.libxc import XC_CODES
 
 
 REGEX_XC = r"((,?)([+-]*)([0-9.]+\*)?([\w@]+)(\([\w+\-\*.,;=]+\))?)"
 
 
+def _canonical_xc_name(name: str) -> str:
+    r"""Resolve an XC name through PySCF's XC_CODES alias table into a canonical form.
+
+    For example, "B3LYP" and "B3LYPG" both resolve to the same libxc functional
+    id (402), unless B3LYP_WITH_VWN5 is set, in which case "B3LYP" resolves to
+    the VWN5 variant. Names absent from XC_CODES (HF, MP2, registered custom
+    functionals, ...) are returned unchanged.
+    """
+    key = name.upper()
+    seen = set()
+    while key in XC_CODES and key not in seen:
+        seen.add(key)
+        key = str(XC_CODES[key]).upper()
+    return key
+
+
 @dataclass
 class XCInfo:
     """