chython 3.0.1__tar.gz → 3.0.2__tar.gz

{chython-3.0.1/chython.egg-info → chython-3.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chython
-Version: 3.0.1
+Version: 3.0.2
 Summary: Library for processing molecules and reactions in python way
 Author-email: Ramil Nugmanov <nougmanoff@protonmail.com>
 License-Expression: LGPL-3.0-or-later

{chython-3.0.1 → chython-3.0.2}/chython/core/_ml.pxi

@@ -683,23 +683,41 @@ def mol_transition_view(MoleculeContainer molecule not None, TensorEncoding enco
 DEF ML_NO_INDEX = 0xffffffff
 
 
-# `uidx` is `map_number -> union index`, valid only for touched slots.  `rseen` / `pseen` mark which
-# side already claimed a map number.  `keep` is indexed by running ordinal over all atoms of both
-# sides (left first, then right); the atom passes write 1 for an atom that took a union slot and 0 for
-# one that was unmapped or rejected; the bond passes read it for both endpoints.  `head` / `link` are a
-# per-atom singly linked list over bond slots, keyed on the lower union index of the pair.  `side`
-# codes: 1 = reactant-only, 2 = product-only, 3 = both.  The uidx table is max map number + 1, at most
-# 10000 slots -- initialized slot by slot, not memset, because a three-atom record must not pay for all.
+# `uidx` is `map_number -> union index`, valid only for touched slots, and it is what PAIRS the two
+# sides -- an unmapped atom therefore takes a union row without an entry in it.  `rseen` / `pseen` mark
+# which side already claimed a map number.  `urow` is indexed by running ordinal over all atoms of both
+# sides (left first, then right) and holds the union row the atom took, or `ML_NO_INDEX` for a rejected
+# collision; the bond passes read it for both endpoints, which is why they need no map number of their
+# own.  `head` / `link` are a per-atom singly linked list over bond slots, keyed on the lower union index
+# of the pair.  `side` codes: 1 = reactant-only, 2 = product-only, 3 = both.  The uidx table is max map
+# number + 1, at most 10000 slots -- initialized slot by slot, not memset, because a three-atom record
+# must not pay for all.
 cdef struct ml_merge_t:
     uint32_t *uidx
     uint8_t *rseen
     uint8_t *pseen
     uint8_t *side              # 1 = reactant-only, 2 = product-only, 3 = both
-    uint8_t *keep              # 1 = atom took a union slot, 0 = unmapped or collided
+    uint32_t *urow             # union row per atom ordinal; ML_NO_INDEX = a rejected collision
     uint32_t *head
     uint32_t *link
 
 
+cdef inline void _ml_union_row(ml_union_t *g, ml_merge_t *merge, uint32_t row, atom_t *at,
+                               uint32_t mn, uint8_t side) noexcept nogil:
+    """One union row from one atom, on the side that atom came from.
+
+    `h_after` is written equal to `h_before`, which a paired product atom then overwrites.  An atom on
+    one side only keeps it -- the convention `ReactionModelingView.states` states -- and an unmapped
+    atom is one of those, the record having said nothing that would pair it.
+    """
+    merge.side[row] = side
+    merge.head[row] = ML_NO_INDEX
+    g.element[row] = at.element
+    g.h_before[row] = at.hydrogens & 0x0f
+    g.h_after[row] = at.hydrogens & 0x0f
+    g.map_number[row] = <uint16_t> mn
+
+
 cdef void _ml_union_degrees(ml_union_t *union_graph, ml_merge_t *merge) noexcept nogil:
     """Per-side heavy degree over the union, by the rule `ReactionModelingView.states` states.
 
@@ -744,9 +762,16 @@ def reaction_transition_view(reactants, products, TensorEncoding encoding=None):
     AGENTS ARE EXCLUDED BY NOT BEING PASSED.  The caller hands over the two sides it wants unioned, so
     there is no side-kind test inside the kernel to keep in step with the container's notion of one.
 
-    A BADLY MAPPED RECORD IS REPORTED.  An unmapped atom is counted and left out; a map number claimed
-    twice on one side is listed in `collisions` and the first claim keeps the slot.  Refusals live at
-    the answer boundary and this is not one.
+    AN UNMAPPED ATOM IS PLACED ON THE SIDE IT CAME FROM, as reactant-only or product-only, and counted
+    in `unmapped`.  Left out, it takes the degree of every neighbour that stayed down with it: an aryl
+    bromide whose bromine carries no number reads two heavy neighbours before the coupling and three
+    after, so every aryl halide of one ring gives the same transition state.  The price is that an atom
+    the record leaves bare on BOTH sides is two rows rather than one, nothing in the record pairing
+    them, and `unmapped` is what a consumer that cannot accept that reads.
+
+    A BADLY MAPPED RECORD IS REPORTED.  A map number claimed twice on one side is listed in `collisions`
+    and the first claim keeps the row; the second contributes nothing, since a union cannot hold two
+    atoms at one key.  Refusals live at the answer boundary and this is not one.
     """
     require_numpy()
     if encoding is None:
@@ -787,7 +812,7 @@ def reaction_transition_view(reactants, products, TensorEncoding encoding=None):
                         + align8(<size_t> slots)                             # rseen
                         + align8(<size_t> slots)                             # pseen
                         + align8(<size_t> cap_atoms)                         # side
-                        + align8(<size_t> cap_atoms)                         # keep
+                        + align8(<size_t> cap_atoms * sizeof(uint32_t))      # urow
                         + align8(<size_t> cap_atoms * sizeof(uint32_t))      # head
                         + align8(<size_t> cap_bonds * sizeof(uint32_t))      # link
                         + <size_t> 4 * cap_atoms                             # element + h_before + n_before + h_after
@@ -806,7 +831,7 @@ def reaction_transition_view(reactants, products, TensorEncoding encoding=None):
     merge.rseen = <uint8_t *> cursor; cursor += align8(<size_t> slots)
     merge.pseen = <uint8_t *> cursor; cursor += align8(<size_t> slots)
     merge.side = <uint8_t *> cursor; cursor += align8(<size_t> cap_atoms)
-    merge.keep = <uint8_t *> cursor; cursor += align8(<size_t> cap_atoms)
+    merge.urow = <uint32_t *> cursor; cursor += align8(<size_t> cap_atoms * sizeof(uint32_t))
     merge.head = <uint32_t *> cursor; cursor += align8(<size_t> cap_atoms * sizeof(uint32_t))
     merge.link = <uint32_t *> cursor; cursor += align8(<size_t> cap_bonds * sizeof(uint32_t))
     union_graph.element = <uint8_t *> cursor; cursor += cap_atoms
@@ -826,7 +851,7 @@ def reaction_transition_view(reactants, products, TensorEncoding encoding=None):
     cdef uint32_t n_union = 0, n_bonds = 0
     cdef uint32_t unmapped_r = 0, unmapped_p = 0
     cdef list collisions_r = [], collisions_p = []
-    cdef uint32_t k, mn, mm, n, m, e, base, right_base
+    cdef uint32_t k, mn, n, m, e, base, right_base
     cdef uint32_t edge_to
     cdef uint8_t order
     try:
@@ -853,26 +878,20 @@ def reaction_transition_view(reactants, products, TensorEncoding encoding=None):
             for i in range(n_mol):
                 at = atoms + i
                 mn = at.map_number
-                if not mn:
+                if mn:
+                    if merge.rseen[mn]:
+                        collisions_r.append(mn)
+                        merge.urow[base + i] = ML_NO_INDEX
+                        continue
+                    merge.rseen[mn] = 1
+                    merge.uidx[mn] = n_union
+                else:
                     unmapped_r += 1
-                    merge.keep[base + i] = 0
-                    continue
-                if merge.rseen[mn]:
-                    collisions_r.append(mn)
-                    merge.keep[base + i] = 0
-                    continue
-                merge.rseen[mn] = 1
-                merge.uidx[mn] = n_union
-                merge.side[n_union] = 1
-                merge.head[n_union] = ML_NO_INDEX
-                merge.keep[base + i] = 1
-                union_graph.element[n_union] = at.element
-                union_graph.h_before[n_union] = at.hydrogens & 0x0f
-                union_graph.h_after[n_union] = at.hydrogens & 0x0f
-                union_graph.map_number[n_union] = <uint16_t> mn
+                _ml_union_row(&union_graph, &merge, n_union, at, mn, 1)
+                merge.urow[base + i] = n_union
                 n_union += 1
             base += n_mol
-        right_base = base  # starting ordinal for product atoms in the keep array
+        right_base = base  # starting ordinal for product atoms in the urow array
 
         # product atoms: a known map number reads its after state onto the existing row, a new one
         # appends -- which is what keeps a component contiguous in the union order
@@ -883,54 +902,42 @@ def reaction_transition_view(reactants, products, TensorEncoding encoding=None):
             for i in range(n_mol):
                 at = atoms + i
                 mn = at.map_number
-                if not mn:
-                    unmapped_p += 1
-                    merge.keep[base + i] = 0
-                    continue
-                if merge.pseen[mn]:
-                    collisions_p.append(mn)
-                    merge.keep[base + i] = 0
-                    continue
-                merge.pseen[mn] = 1
-                if merge.rseen[mn]:
-                    n = merge.uidx[mn]
-                    merge.side[n] = 3
-                    union_graph.h_after[n] = at.hydrogens & 0x0f
-                    merge.keep[base + i] = 1
-                else:
+                if mn:
+                    if merge.pseen[mn]:
+                        collisions_p.append(mn)
+                        merge.urow[base + i] = ML_NO_INDEX
+                        continue
+                    merge.pseen[mn] = 1
+                    if merge.rseen[mn]:
+                        n = merge.uidx[mn]
+                        merge.side[n] = 3
+                        union_graph.h_after[n] = at.hydrogens & 0x0f
+                        merge.urow[base + i] = n
+                        continue
                     merge.uidx[mn] = n_union
-                    merge.side[n_union] = 2
-                    merge.head[n_union] = ML_NO_INDEX
-                    merge.keep[base + i] = 1
-                    union_graph.element[n_union] = at.element
-                    union_graph.h_before[n_union] = at.hydrogens & 0x0f
-                    union_graph.h_after[n_union] = at.hydrogens & 0x0f
-                    union_graph.map_number[n_union] = <uint16_t> mn
-                    n_union += 1
+                else:
+                    unmapped_p += 1
+                _ml_union_row(&union_graph, &merge, n_union, at, mn, 2)
+                merge.urow[base + i] = n_union
+                n_union += 1
             base += n_mol
 
-        # reactant bonds, both endpoints mapped and kept: appended in reactant order, `n < m`.
-        # The `n >= m` guard also stops a bond between two atoms sharing one map number from
-        # becoming a self-loop -- that is load-bearing, not incidental.
+        # reactant bonds, both endpoints holding a union row: appended in reactant order, `n < m`, so
+        # the `n >= m` guard is what visits each bond once.
         base = 0
         for mol in left:
             structure = mol._structure
-            atoms = structure.atoms()
             ptr = csr_ptr(structure)
             edges = csr_edges(structure)
             n_mol = structure.header.atom_count
             for i in range(n_mol):
-                if not merge.keep[base + i]:
+                n = merge.urow[base + i]
+                if n == ML_NO_INDEX:
                     continue
-                mn = atoms[i].map_number
-                n = merge.uidx[mn]
                 for k in range(ptr[i], ptr[i + 1]):
                     edge_to = edges[k].to
-                    if not merge.keep[base + edge_to]:
-                        continue
-                    mm = atoms[edge_to].map_number
-                    m = merge.uidx[mm]
-                    if n >= m:
+                    m = merge.urow[base + edge_to]
+                    if m == ML_NO_INDEX or n >= m:
                         continue
                     union_graph.bond_i[n_bonds] = n
                     union_graph.bond_j[n_bonds] = m
@@ -945,22 +952,17 @@ def reaction_transition_view(reactants, products, TensorEncoding encoding=None):
         base = right_base
         for mol in right:
             structure = mol._structure
-            atoms = structure.atoms()
             ptr = csr_ptr(structure)
             edges = csr_edges(structure)
             n_mol = structure.header.atom_count
             for i in range(n_mol):
-                if not merge.keep[base + i]:
+                n = merge.urow[base + i]
+                if n == ML_NO_INDEX:
                     continue
-                mn = atoms[i].map_number
-                n = merge.uidx[mn]
                 for k in range(ptr[i], ptr[i + 1]):
                     edge_to = edges[k].to
-                    if not merge.keep[base + edge_to]:
-                        continue
-                    mm = atoms[edge_to].map_number
-                    m = merge.uidx[mm]
-                    if n >= m:
+                    m = merge.urow[base + edge_to]
+                    if m == ML_NO_INDEX or n >= m:
                         continue
                     order = edges[k].order
                     e = merge.head[n]

{chython-3.0.1 → chython-3.0.2}/chython/core/reaction.py

@@ -202,8 +202,8 @@ class ReactionModelingView:
     number is the only thing that identifies "the same atom" across the arrow -- keying by atom number
     works only where a reader makes the two coincide.
 
-    IT REPORTS WHAT IT COULD NOT PLACE instead of producing an undefined union.  Calling unmapped
-    atoms and colliding map numbers "undefined results" means, for a training set, silent corruption at
+    IT REPORTS WHAT THE RECORD DID NOT STATE instead of leaving it undefined.  Calling unmapped atoms
+    and colliding map numbers "undefined results" means, for a training set, silent corruption at
     whatever rate the corpus happens to contain.  Here they land in :attr:`unmapped` and
     :attr:`collisions`, both empty for a well-mapped reaction, so a pipeline can decide -- and a
     refusal, if one is wanted, happens at the pipeline's boundary rather than inside a container that
@@ -219,7 +219,11 @@ class ReactionModelingView:
 
     @property
     def states(self) -> dict[int, tuple]:
-        """`{map_number: (element, h_before, n_before, h_after, n_after)}`.
+        """`{map_number: (element, h_before, n_before, h_after, n_after)}`, in union order.
+
+        A NEGATIVE KEY IS AN ATOM THE RECORD DOES NOT NUMBER, allocated `-1` onwards in that order.  It
+        is placed like any other atom, as reactant-only or product-only; the negative key says the
+        pairing is this view's reading of an absence rather than something the record stated.
 
         `element` is the atomic number.  `h_*` are IMPLICIT hydrogen counts per side and `n_*` are
         heavy-atom neighbour counts per side -- the per-side hydrogen count being the thing the
@@ -253,9 +257,11 @@ class ReactionModelingView:
     def unmapped(self) -> dict[str, int]:
         """How many atoms carried no map number, per side: `{'reactants': n, 'products': n}`.
 
-        Not an error and not silently dropped.  An unmapped atom cannot be placed in a union keyed by
-        map number, so it is counted and left out, and a consumer that requires a fully mapped
-        reaction checks this rather than discovering the hole in its loss curve.
+        Not an error and not a refusal.  Each is placed on the side it came from and keyed negatively in
+        :attr:`states`, so no neighbour of one loses a degree; what the count is for is the atom the
+        record leaves bare on BOTH sides, which becomes two rows because nothing pairs them.  A consumer
+        that requires a fully mapped reaction checks this rather than discovering the hole in its loss
+        curve.
         """
         return self._unmapped
 
@@ -577,18 +583,28 @@ class ReactionContainer:
         that is also a drawing.  Stated rather than assumed, because it is the kind of choice a model
         silently trains around.
 
+        AN UNMAPPED ATOM IS KEYED NEGATIVELY, `-1` onwards in union order, and still counted in
+        `unmapped`.  It holds a union row like any other atom -- on the side it came from -- so the key
+        is only the identity handle a dict needs: 0 would put every such atom on one entry, and a
+        positive one would be indistinguishable from a number the record stated.
+
         A COLLIDING MAP NUMBER KEEPS ITS FIRST CLAIM.  The second atom to claim a number is counted in
         `collisions` and contributes no state and no bond; a union cannot hold two atoms at one key.
         """
         view = reaction_transition_view(self._reactants, self._products,
                                         TensorEncoding(unknown_h=H_UNKNOWN))
-        map_numbers = view.map_numbers.tolist()
+        keys, bare = [], 0
+        for mn in view.map_numbers.tolist():
+            if not mn:
+                bare -= 1
+                mn = bare
+            keys.append(mn)
         states = {mn: (int(view.elements[i]), int(view.h_before[i]), int(view.n_before[i]),
                        int(view.h_after[i]), int(view.n_after[i]))
-                  for i, mn in enumerate(map_numbers)}
+                  for i, mn in enumerate(keys)}
         union = {}
         for (i, j), before, after in zip(view.bonds.tolist(), view.bond_before, view.bond_after):
-            a, b = map_numbers[i], map_numbers[j]
+            a, b = keys[i], keys[j]
             union[(a, b) if a < b else (b, a)] = (int(before), int(after))
         return ReactionModelingView(states, union, view.unmapped, view.collisions)
 

{chython-3.0.1 → chython-3.0.2}/chython/core/test/modeling_view_corpus.py

@@ -60,7 +60,7 @@ SMILES = {
     # the mirror: 5..8 exist only on the product side
     'tert_butyl_esterification': '[CH3:1][C:2](=[O:3])[OH:9]'
                                  '>>[CH3:1][C:2](=[O:3])[O:4][C:5]([CH3:6])([CH3:7])[CH3:8].[OH2:9]',
-    # one unmapped atom on each side, counted and left out of the union
+    # two unmapped atoms on each side, counted and placed on the side they came from
     'esterification_partly_mapped': '[CH3:1][C:2](=[O:3])[OH:4].CO'
                                     '>>[CH3:1][C:2](=[O:3])[O:4]C.O',
     # two atoms sharing map number 1 on the reactant side: the union merges them and says so
@@ -74,7 +74,7 @@ SMILES = {
     # a salt on the product side: two molecules, one of them a single mapped ion
     'saponification': '[CH3:1][C:2](=[O:3])[O:4][CH3:5].[OH-:6].[Na+:7]'
                       '>>[CH3:1][C:2](=[O:3])[O-:4].[Na+:7].[CH3:5][OH:6]',
-    # no mapping at all: every atom is unmapped, the union is empty, and that is a record
+    # no mapping at all: every atom is on one side only, so nothing is conserved, and that is a record
     'unmapped_hydrogenation': 'C=C.[H][H]>>CC',
     # an empty product side, which is a record and not an error
     'empty_products': '[CH3:1][CH3:2]>>',

{chython-3.0.1 → chython-3.0.2}/chython/core/test/test_ml_reaction_transition.py

@@ -40,6 +40,13 @@ def _bonds_by_map(view):
             for (i, j), b, a in zip(view.bonds.tolist(), view.bond_before, view.bond_after)}
 
 
+def _columns(view):
+    """Every column but `map_numbers`: what the record states, apart from how it numbers it."""
+    return (view.elements.tolist(), view.h_before.tolist(), view.h_after.tolist(),
+            view.n_before.tolist(), view.n_after.tolist(), view.bonds.tolist(),
+            view.bond_before.tolist(), view.bond_after.tolist())
+
+
 def test_a_fully_mapped_substitution_reports_both_sides_of_every_atom():
     view = read_reaction_smiles('[CH3:1][Br:2].[OH-:3]>>[CH3:1][OH:3].[Br-:2]').transition_view()
     assert _by_map(view) == {
@@ -112,10 +119,36 @@ def test_an_agent_contributes_no_atom_and_no_bond():
     assert sorted(view.map_numbers.tolist()) == [1, 2, 3, 4, 5, 6]
 
 
-def test_an_unmapped_atom_is_counted_and_left_out_of_the_union():
+def test_an_unmapped_atom_is_counted_and_placed_on_the_side_it_came_from():
+    """A record that names one atom still has a whole transition state.
+
+    `[CH3:1]Br>>[CH3:1]O` states the carbon and nothing else.  The bromine is reactant-only and the
+    oxygen product-only, so the C-Br bond breaks, the C-O bond forms, and the carbon counts one heavy
+    neighbour on each side rather than none.  `map_numbers` carries 0 for a row the record does not
+    number: the column is the record's own numbering and this view invents no entry in it.
+    """
+    view = read_reaction_smiles('[CH3:1]Br>>[CH3:1]O').transition_view()
+    assert view.map_numbers.tolist() == [1, 0, 0]
+    assert view.elements.tolist() == [6, 35, 8]
+    assert view.n_before.tolist() == [1, 1, 0]
+    assert view.n_after.tolist() == [1, 0, 1]
+    assert view.bonds.tolist() == [[0, 1], [0, 2]]
+    assert view.bond_before.tolist() == [1, 0]
+    assert view.bond_after.tolist() == [0, 1]
+    assert view.unmapped == {'reactants': 1, 'products': 1}
+
+
+def test_an_unmapped_atom_on_both_sides_is_two_rows_and_not_one():
+    """The price of placing them, and the reason `unmapped` is still reported.
+
+    Methanol's carbon and oxygen are unmapped on both sides of this esterification.  Nothing in the
+    record says the left pair and the right pair are the same two atoms, so the union holds four rows:
+    the reactant methanol leaves and the product methyl arrives.  A consumer that cannot accept that
+    reads `unmapped` and refuses the record.
+    """
     view = read_reaction_smiles('[CH3:1][C:2](=[O:3])[OH:4].CO'
                                 '>>[CH3:1][C:2](=[O:3])[O:4]C.O').transition_view()
-    assert sorted(view.map_numbers.tolist()) == [1, 2, 3, 4]
+    assert view.map_numbers.tolist() == [1, 2, 3, 4, 0, 0, 0, 0]
     assert view.unmapped == {'reactants': 2, 'products': 2}
 
 
@@ -125,21 +158,109 @@ def test_a_colliding_map_number_is_reported_and_not_refused():
     assert view.map_numbers.tolist() == [1, 2, 3]
 
 
-def test_a_bond_whose_endpoint_is_unmapped_is_not_a_union_bond():
-    """Half a bond cannot be placed in the union, and inventing an endpoint would be worse."""
+def test_a_bond_to_an_unmapped_atom_is_a_union_bond():
+    """Both endpoints have a row, so the bond has one: the union is over atoms, not over numbers."""
     view = read_reaction_smiles('[CH3:1]CO>>[CH3:1]C=O').transition_view()
-    assert view.bonds.shape == (0, 2)
-    assert view.map_numbers.tolist() == [1]
+    assert view.map_numbers.tolist() == [1, 0, 0, 0, 0]
+    assert view.bonds.tolist() == [[0, 1], [1, 2], [0, 3], [3, 4]]
+    assert view.bond_before.tolist() == [1, 1, 0, 0]
+    assert view.bond_after.tolist() == [0, 0, 1, 2]
+
 
+def test_a_reaction_with_no_mapping_at_all_is_every_atom_on_one_side():
+    """No number anywhere is a record, and the union it gives is the two sides side by side.
 
-def test_a_reaction_with_no_mapping_at_all_gives_an_empty_union():
+    Nothing is conserved, because nothing in the record says anything is.  `unmapped` counts every
+    atom, which is the signal a pipeline refuses on.
+    """
     view = read_reaction_smiles('C=C.[H][H]>>CC').transition_view()
-    assert view.elements.shape == (0,)
-    assert view.bonds.shape == (0, 2)
-    assert view.distances.shape == (0, 0)
+    assert view.map_numbers.tolist() == [0] * 6
+    assert view.elements.tolist() == [6, 6, 1, 1, 6, 6]
+    assert view.bond_before.tolist() == [2, 1, 0]
+    assert view.bond_after.tolist() == [0, 0, 1]
     assert view.unmapped == {'reactants': 4, 'products': 2}
 
 
+def test_a_changing_atom_moves_its_hydrogens_and_its_bond_order():
+    """`C-OH >> C=O`, the change that needs no atom to leave or arrive.
+
+    Both atoms of the reaction centre lose a hydrogen and the bond between them goes single to double.
+    No degree moves and `unmapped` is zero: a change is a statement about one atom on two sides, so it
+    takes a map number to state at all.
+    """
+    view = read_reaction_smiles('[CH3:1][CH2:2][OH:3]>>[CH3:1][CH:2]=[O:3]').transition_view()
+    assert view.h_before.tolist() == [3, 2, 1]
+    assert view.h_after.tolist() == [3, 1, 0]
+    assert view.n_before.tolist() == [1, 2, 1]
+    assert view.n_after.tolist() == [1, 2, 1], 'nothing left and nothing arrived'
+    assert _bonds_by_map(view) == {(1, 2): (1, 1), (2, 3): (1, 2)}
+    assert view.unmapped == {'reactants': 0, 'products': 0}
+
+
+def test_a_leaving_atom_reads_the_same_numbered_or_not():
+    """Being on one side only and being unnumbered are two different facts about an atom.
+
+    The bromine is reactant-only either way; the number changes its key and nothing else.  `unmapped`
+    is the only column that separates the two records, which is what makes it the signal to refuse on.
+    """
+    numbered = read_reaction_smiles('[CH3:1][Br:2]>>[CH4:1]').transition_view()
+    bare = read_reaction_smiles('[CH3:1]Br>>[CH4:1]').transition_view()
+    assert _columns(numbered) == _columns(bare)
+    assert numbered.map_numbers.tolist() == [1, 2]
+    assert bare.map_numbers.tolist() == [1, 0]
+    assert numbered.unmapped == {'reactants': 0, 'products': 0}
+    assert bare.unmapped == {'reactants': 1, 'products': 0}
+    assert bare.n_before.tolist() == [1, 1], 'the carbon has the bromine before'
+    assert bare.n_after.tolist() == [0, 0], 'and the bromine left alone, so it counts nobody after'
+    assert bare.bond_before.tolist() == [1] and bare.bond_after.tolist() == [0]
+
+
+def test_an_arriving_atom_reads_the_same_numbered_or_not():
+    """The mirror: a product-only atom, numbered or not, is one row whose bonds read `(0, order)`."""
+    numbered = read_reaction_smiles('[CH4:1]>>[CH3:1][Br:2]').transition_view()
+    bare = read_reaction_smiles('[CH4:1]>>[CH3:1]Br').transition_view()
+    assert _columns(numbered) == _columns(bare)
+    assert bare.map_numbers.tolist() == [1, 0]
+    assert bare.unmapped == {'reactants': 0, 'products': 1}
+    assert bare.h_before.tolist() == [4, 0] and bare.h_after.tolist() == [3, 0]
+    assert bare.n_before.tolist() == [0, 0] and bare.n_after.tolist() == [1, 1]
+    assert bare.bond_before.tolist() == [0] and bare.bond_after.tolist() == [1]
+
+
+def test_one_record_that_leaves_arrives_and_changes_at_once():
+    """Every branch in one union: two changing atoms, a leaving one, an arriving one, four moved bonds.
+
+    Maps 2 and 3 are the `C-OH >> C=O` pair.  Map 4 (bromine) is reactant-only.  Map 6 (water oxygen)
+    is product-only.  Map 5 is on both sides and loses its only neighbour, so it gains a hydrogen and
+    drops to a degree of 0 -- a paired atom reads the departure of an unpaired one.
+    """
+    view = read_reaction_smiles('[CH3:1][CH2:2][OH:3].[Br:4][CH3:5]'
+                                '>>[CH3:1][CH:2]=[O:3].[CH4:5].[OH2:6]').transition_view()
+    assert view.map_numbers.tolist() == [1, 2, 3, 4, 5, 6]
+    assert view.elements.tolist() == [6, 6, 8, 35, 6, 8]
+    assert view.h_before.tolist() == [3, 2, 1, 0, 3, 2]
+    assert view.h_after.tolist() == [3, 1, 0, 0, 4, 2]
+    assert view.n_before.tolist() == [1, 2, 1, 1, 1, 0]
+    assert view.n_after.tolist() == [1, 2, 1, 0, 0, 0]
+    assert _bonds_by_map(view) == {(1, 2): (1, 1), (2, 3): (1, 2), (4, 5): (1, 0)}
+    assert view.unmapped == {'reactants': 0, 'products': 0}
+
+
+def test_the_same_record_reads_the_same_where_it_numbers_nothing():
+    """The record above with its bromine and its water unnumbered: one union, two keyings.
+
+    The leaving atom and the arriving one lose their numbers, and every column but `map_numbers` and
+    `unmapped` is unchanged -- including the degree of map 5, which the bromine's row is what preserves.
+    """
+    numbered = read_reaction_smiles('[CH3:1][CH2:2][OH:3].[Br:4][CH3:5]'
+                                    '>>[CH3:1][CH:2]=[O:3].[CH4:5].[OH2:6]').transition_view()
+    bare = read_reaction_smiles('[CH3:1][CH2:2][OH:3].Br[CH3:5]'
+                                '>>[CH3:1][CH:2]=[O:3].[CH4:5].O').transition_view()
+    assert _columns(numbered) == _columns(bare)
+    assert bare.map_numbers.tolist() == [1, 2, 3, 0, 5, 0]
+    assert bare.unmapped == {'reactants': 1, 'products': 1}
+
+
 def test_an_empty_product_side_is_a_record():
     """Both atoms are reactant-only; they leave together, so each counts the other after."""
     view = read_reaction_smiles('[CH3:1][CH3:2]>>').transition_view()