Unify matcher path coordinates to genomic positions

Wrap legacy AncestorMatcher to convert site-index edges to genomic
positions, mapping left=positions[0] to 0 for consistency.  Update
Matcher._match_one to use genomic positions directly.  Both matchers
now pass all 16 fixture tests identically.

Author: jeromekelleher

tests/test_matcher_fixtures.py

@@ -216,25 +216,25 @@ def setup(self):
     def test_copy_node2(self):
         """Query [0,1,0] exactly matches node 2."""
         path, mutations = _match(self.ts, self.positions, [0, 1, 0], self.am)
-        assert path == [(10.0, 100.0, 2)]
+        assert path == [(0.0, 100.0, 2)]
         assert mutations == []
 
     def test_copy_node3(self):
         """Query [1,0,0] exactly matches node 3."""
         path, mutations = _match(self.ts, self.positions, [1, 0, 0], self.am)
-        assert path == [(10.0, 100.0, 3)]
+        assert path == [(0.0, 100.0, 3)]
         assert mutations == []
 
     def test_mixed(self):
         """Query [1,1,0] recombines between nodes 2 and 3."""
         path, mutations = _match(self.ts, self.positions, [1, 1, 0], self.am)
-        assert path == [(20.0, 100.0, 2), (10.0, 20.0, 3)]
+        assert path == [(20.0, 100.0, 2), (0.0, 20.0, 3)]
         assert mutations == []
 
     def test_ancestral(self):
         """Query [0,0,0] (all ancestral) copies from virtual root."""
         path, mutations = _match(self.ts, self.positions, [0, 0, 0], self.am)
-        assert path == [(10.0, 100.0, 1)]
+        assert path == [(0.0, 100.0, 1)]
         assert mutations == []
 
 
@@ -248,19 +248,19 @@ def setup(self):
     def test_copy_leaf_node3(self):
         """Query [1,0,1,0] exactly matches node 3."""
         path, mutations = _match(self.ts, self.positions, [1, 0, 1, 0], self.am)
-        assert path == [(10.0, 100.0, 3)]
+        assert path == [(0.0, 100.0, 3)]
         assert mutations == []
 
     def test_copy_leaf_node4(self):
         """Query [1,0,0,1] exactly matches node 4."""
         path, mutations = _match(self.ts, self.positions, [1, 0, 0, 1], self.am)
-        assert path == [(10.0, 100.0, 4)]
+        assert path == [(0.0, 100.0, 4)]
         assert mutations == []
 
     def test_copy_internal(self):
         """Query [1,0,0,0] matches internal node 2."""
         path, mutations = _match(self.ts, self.positions, [1, 0, 0, 0], self.am)
-        assert path == [(10.0, 100.0, 2)]
+        assert path == [(0.0, 100.0, 2)]
         assert mutations == []
 
     def test_mixed_leaves(self):
@@ -269,7 +269,7 @@ def test_mixed_leaves(self):
         assert path == [
             (40.0, 100.0, 4),
             (30.0, 40.0, 3),
-            (10.0, 30.0, 1),
+            (0.0, 30.0, 1),
         ]
         assert mutations == []
 
@@ -284,19 +284,19 @@ def setup(self):
     def test_copy_A(self):
         """Query [1,0,0,0] copies entirely from A (node 2)."""
         path, mutations = _match(self.ts, self.positions, [1, 0, 0, 0], self.am)
-        assert path == [(10.0, 100.0, 2)]
+        assert path == [(0.0, 100.0, 2)]
         assert mutations == []
 
     def test_copy_B_site2(self):
         """Query [0,0,1,0] copies from B (node 3)."""
         path, mutations = _match(self.ts, self.positions, [0, 0, 1, 0], self.am)
-        assert path == [(10.0, 100.0, 3)]
+        assert path == [(0.0, 100.0, 3)]
         assert mutations == []
 
     def test_recombination(self):
         """Query [1,0,1,0] matches B's haplotype, requiring recombination."""
         path, mutations = _match(self.ts, self.positions, [1, 0, 1, 0], self.am)
-        assert path == [(30.0, 100.0, 3), (10.0, 30.0, 2)]
+        assert path == [(30.0, 100.0, 3), (0.0, 30.0, 2)]
         assert mutations == []
 
     def test_partial_missing(self):
@@ -316,24 +316,24 @@ def setup(self):
     def test_copy_C(self):
         """Query [1,1,1,0] exactly matches deepest node C (4)."""
         path, mutations = _match(self.ts, self.positions, [1, 1, 1, 0], self.am)
-        assert path == [(10.0, 100.0, 4)]
+        assert path == [(0.0, 100.0, 4)]
         assert mutations == []
 
     def test_copy_B(self):
         """Query [1,1,0,0] matches node B (3)."""
         path, mutations = _match(self.ts, self.positions, [1, 1, 0, 0], self.am)
-        assert path == [(10.0, 100.0, 3)]
+        assert path == [(0.0, 100.0, 3)]
         assert mutations == []
 
     def test_copy_A(self):
         """Query [1,0,0,0] matches node A (2)."""
         path, mutations = _match(self.ts, self.positions, [1, 0, 0, 0], self.am)
-        assert path == [(10.0, 100.0, 2)]
+        assert path == [(0.0, 100.0, 2)]
         assert mutations == []
 
     def test_novel_haplotype(self):
         """Query [0,0,0,1] doesn't match any node — copies virtual root
         with a mutation."""
         path, mutations = _match(self.ts, self.positions, [0, 0, 0, 1], self.am)
-        assert path == [(10.0, 100.0, 1)]
+        assert path == [(0.0, 100.0, 1)]
         assert mutations == [(40.0, 1)]

tsinfer/matching.py

@@ -288,7 +288,11 @@ def _match_one(self, job, reader) -> tuple:
         if self._use_matcher2:
             matcher = AncestorMatcher2(self._matcher_indexes, self._rho, self._mu)
         else:
-            matcher = _tsinfer.AncestorMatcher(self._tsb, self._rho, self._mu)
+            matcher = _LegacyMatcherWrapper(
+                _tsinfer.AncestorMatcher(self._tsb, self._rho, self._mu),
+                pos,
+                seq_len,
+            )
         t_init = time_.monotonic() - t0
 
         t0 = time_.monotonic()
@@ -307,12 +311,10 @@ def _match_one(self, job, reader) -> tuple:
         left, right, parent = matcher.find_path(h, start, end, match_out)
         t_match = time_.monotonic() - t1
 
-        # Convert site-index edges to absolute-position PathSegments
+        # Build PathSegments from genomic-position edges
         path = []
         for li, ri, pi in zip(left, right, parent):
-            l_pos = float(pos[li])
-            r_pos = float(pos[ri]) if ri < num_sites else float(seq_len)
-            path.append(PathSegment(left=l_pos, right=r_pos, parent=int(pi)))
+            path.append(PathSegment(left=float(li), right=float(ri), parent=int(pi)))
 
         # Detect mutations and convert to absolute positions
         in_range = np.zeros(num_sites, dtype=bool)
@@ -516,6 +518,32 @@ def add_vestigial_root(ts):
     return tables.tree_sequence()
 
 
+class _LegacyMatcherWrapper:
+    """Wraps _tsinfer.AncestorMatcher to return genomic positions."""
+
+    def __init__(self, matcher, positions, seq_len):
+        self._matcher = matcher
+        self._positions = positions
+        self._seq_len = seq_len
+
+    def find_path(self, h, start, end, match_out):
+        left, right, parent = self._matcher.find_path(h, start, end, match_out)
+        num_sites = len(self._positions)
+        left_pos = self._positions[left]
+        left_pos = np.where(left_pos == self._positions[0], 0, left_pos)
+        clipped = np.minimum(right, num_sites - 1)
+        right_pos = np.where(right < num_sites, self._positions[clipped], self._seq_len)
+        return left_pos, right_pos, parent
+
+    @property
+    def total_memory(self):
+        return self._matcher.total_memory
+
+    @property
+    def mean_traceback_size(self):
+        return self._matcher.mean_traceback_size
+
+
 class MatcherIndexes(_tsinfer.MatcherIndexes):
     """Wrapper around the C MatcherIndexes, built from a tree sequence."""