BHSA version mappings

In this notebook we map the nodes between the all the extant versions of the BHSA dataset.

The resulting mappings can be used for writing version independent programs that process the BHSA data. Those programs can only be version independent to a certain extent, because in general, node mappings between versions cannot be made perfect.

If one imagines what may change between versions, it seems intractable to make a device that overcomes differences in the encoding of the texts and its syntax. However, we are dealing with versions of a very stable text, that is linguistically annotated by means of a consistent method, so there is reason to be optimistic. This notebook shows that this optimism is well-founded.

In another notebook, versionPhrases we show how one can use the mappings to analyze phrase encodings across versions of the data.

Overview

We create the mappings in two distinct stages, each being based on a particular insight, and dealing with a set of difficult cases.

  • Slot nodes: we restrict ourselves to the slot nodes, the nodes that correspond to the individual words;
  • Nodes in general: we extend the slot mapping in a generic way to a mapping between all nodes. Those other nodes are the ones that correspond to higher level textual objects, such as phrases, clauses, sentences.

This is a big notebook, here are links to some locations in the computation.

Nodes, edges, mappings

In the text-fabric data model, nodes correspond to the objects in the text and its syntax, and edges correspond to relationships between those objects. Normally, these edges are intra-dataset, they are between nodes in the same dataset.

Now, each version of the BHSA in text-fabric is its own dataset. The mappings between nodes of one version and corresponding nodes in another version are inter-dataset edges.

Nodes in text-fabric are abstract, they are just numbers, starting with 1 for the first slot (word), increasing by one for each slot up to the last slot, and then just continuing beyond that for the non-slot nodes.

So an edge is just a mapping between numbers, and it is perfectly possible to have just any mapping between numbers in a dataset.

We store mappings as ordinary TF edge features, so you can use the mapping in both ways, by

nodesInVersion4 = Es('[email protected]').f(nodeInVersion3)
nodesInVersion3 = Es('oma[email protected]').t(nodeInVersion4)

respectively. When one version supersedes another, we store the mapping between the older and newer version as an edge in the new version, leaving the older version untouched.

We store the node mapping with a bit more information than the mere correspondence between nodes. We also add an integer to each correspondence which indicates how problematic that correspondence is.

If the correspondence is perfect, we do not add any value. If it is a simple discrepancy, confined to an equal amount of slots in both versions, we add value 0. If the discrepancy is more complicated, we add a higher number. The details of this will follow.

Slot nodes

The basic idea in creating a slot mapping is to walk through the slots of both versions in parallel, and upon encountering a difference, to take one of a few prescribed actions, that may lead to catching up slots in one of the two versions.

The standard behaviour is to stop at each difference encountered, unless the difference conforms to a "predefined" case. When there is no match, the user may add a case to the list of cases. It might be needed to add a different systematic kind of case, and for that programming is needed.

This notebook shows the patterns and the very small lists of cases that were needed to do the job for 4 version transitions, each corresponding to 1 year or more of encoding activity.

Differences

When we compare versions, our aim is not to record all differences in general, but to record the correspondence between the slots of the versions, and exactly where and how this correspondence is disturbed.

We use the lexeme concept as an anchor point for the correspondence. If we compare the two versions, slot by slot, and as long as we encounter the same lexemes, we have an undisturbed correspondence. In fact, we relax this a little bit, because the very concept of lexeme might change between versions. So we reduce the information in lexemes considerably, before we compare them, so that we do not get disturbed by petty changes.

While being undisturbed, we just create an edge between the slot in the one version that we are at, to the node in the other version that we are at, and we assign no value to such an edge.

But eventually, we encounter real disturbances. They manifest themselves in just a few situations:

  1. 1
  2. 2
  3. 3

In full generality, we can say: $i$ slots in the source $V$ version correspond to $j$ slots in the target version $W$, where $i$ and $j$ may be 0, but not at the same time:

  1. 4

If $i$ slots in version $V$, starting at $n$ get replaced by $j$ slots in the version $W$, starting at $m$, we create edges between all $n, ..., n+i-1$ on the one hand and all $m, ..., m+j-1$ on the other hand, and associate them all with the same number $j-i$.

But so far, it turns out that the only things we have to deal with, are specific instances of 1, 2, and 3 above.

We have a closer look at those cases.

Lexeme change

When a lexeme changes at a particular spot $n, m$, we have $i=j=1$, leading to exactly one edge $(n, m)$ with value $0$.

Slot splitting

When slot $n\in V$ splits into $m, ..., m+j \in W$, we create edges from $n$ to each of the $m, ..., m+j$, each carrying the number $j$. The larger $j$ is, the greater the dissimilarity between node $n\in V$ and each of the $m, ..., m+j \in W$.

Slot collapse

When slots $n, ..., n+i \in V$ collapse into $m\in W$, we create edges from each of the $n, ..., n+i$ to $m$, each carrying the number $j$. The larger $j$ is, the greater the dissimilarity between the nodes $n, ..., n+i\in V$ and $m \in W$.

Slot deletion

When slot $n$ is deleted from $V$, we have $i=1, j=0$, leading to zero edges from $n$. But so far, we have not encountered this case.

Slot addition

When slot $m$ is added to $W$, we have $i=0, j=1$, again leading to zero edges to $m$. But so far, we have not encountered this case.

Nodes in general

The basic idea we use for the general case is that that nodes are linked to slots. In text-fabric, the standard oslots edge feature lists for each non-slot node the slots it is linked to.

Combining the just created slot mappings between versions and the oslots feature, we can extend the slot mapping into a general node mapping.

In order to map a node $n$ in version $V$, we look at its slots $s$, use the already established slot mapping to map these to slots $t$ in version $W$, and collect the nodes $m$ in version $W$ that are linked to those $t$. They are good candidates for the mapping.

5

Refinements

When we try to match nodes across versions, based on slot containment, we also respect their otypes. So we will not try to match a clause to a phrase. We make implicit use of the fact that for most otypes, the members contain disjoint slots.

Multiple candidates

Of course, things are not always as neat as in the diagram. Textual objects may have split, or shifted, or collapsed. In general we find 0 or more candidates. Even if we find exactly one candidate, it does not have to be a perfect match. A typical situation is this:

6

We do not find a node $m\in W$ that occupies the mapped slots exactly. Instead, we find that the target area is split between two candidates who also reach outside the target area.

In such cases, we make edges to all such candidates, but we add a dissimilarity measure. If $m$ is the collection of slots, mapped from $n$, and $m_1$ is a candidate for $n$, meaning $m_1$ has overlap with $m$, then the dissimilarity of $m_1$ is defined as:

$$|m_1\cup m| - |m_1\cap m|$$

In words: the number of slots in the union of $m_1$ and $m$ minus the number of slots in their intersection.

In other words: $m_1$ gets a penalty for

  • each slot $s\in m_1$ that is not in the mapped slots $m$;
  • each mapped slot $t\in m$ that is not in $m_1$.

If a candidate occupies exactly the mapped slots, the dissimilarity is 0. If there is only one such candidate of the right type, the case is completely clear, and we do not add a dissimilarity value to the edge.

If there are more candidates, all of them will get an edge, and those edges will contain the dissimilarity value, even if that value is $0$.

Subphrases

The most difficult type to handle in our dataset is the subphrase, because they nest and overlap. But it turns out that the similarity measure almost always helps out: when looking for candidates for a mapped subphrase, usually one of them has a dissimilarity of 0. That's the real counterpart.

Reporting

We report the success in establishing the match between non-slot nodes. We do so per node type, and for each node type we list a few statistics, both in absolute numbers and in percentage of the total amount of nodes of that type in the source version.

We count the nodes that fall in each of the following cases. The list of cases is ordered by decreasing success of the mapping.

  1. unique, perfect: there is only one match for the mapping and it is a perfect one in terms of slots linked to it;
  2. multiple, one perfect: there are multiple matches, but at least one is perfect; this occurs typically if nodes of a type are linked to nested and overlapping sequences of slots, such as subphrases;
  3. unique, imperfect: there is only one match, but it is not perfect; this indicates that some boundary reorganization has happened between the two versions, and that some slots of the source node have been cut off in the target node; yet the fact that the source node and the target node correspond is clear;
  4. multiple, cleanly composed: in this case the source node corresponds to a bunch of matches, that together cleanly cover the mapped slots of the source node; in other words: the original node has been split in several parts;
  5. multiple, non-perfect: all remaining cases where there are matches; these situations can be the result of more intrusive changes; if it turns out to be a small set they do require closer inspection;
  6. not mapped: these are nodes for which no match could be found.

Computing

In [2]:
import os
import collections
from functools import reduce
from utils import caption
from tf.fabric import Fabric

We specify our versions and the subtle differences between them as far as they are relevant.

In [23]:
REPO = os.path.expanduser("~/github/etcbc/bhsa")
baseDir = "{}/tf".format(REPO)
tempDir = "{}/_temp".format(REPO)

versions = """
    3
    4
    4b
    2016
    2017
    c
""".strip().split()

# work only with selected versions
# remove this if you want to work with all versions
versions = """
    2017
    2021
""".strip().split()

versionInfo = {
    "": dict(
        OCC="g_word",
        LEX="lex",
    ),
    "3": dict(
        OCC="text_plain",
        LEX="lexeme",
    ),
}

Load all versions in one go!

In [24]:
TF = {}
api = {}
for v in versions:
    for (param, value) in versionInfo.get(v, versionInfo[""]).items():
        globals()[param] = value
    caption(4, "Version -> {} <- loading ...".format(v))
    TF[v] = Fabric(locations="{}/{}".format(baseDir, v), modules=[""])
    api[v] = TF[v].load("{} {}".format(OCC, LEX))  # noqa F821
caption(4, "All versions loaded")
..............................................................................................
.      5m 27s Version -> 2017 <- loading ...                                                 .
..............................................................................................
This is Text-Fabric 9.1.7
Api reference : https://annotation.github.io/text-fabric/tf/cheatsheet.html

115 features found and 0 ignored
  0.00s loading features ...
   |     0.00s Dataset without structure sections in otext:no structure functions in the T-API
    18s All features loaded/computed - for details use TF.isLoaded()
..............................................................................................
.      5m 45s Version -> 2021 <- loading ...                                                 .
..............................................................................................
This is Text-Fabric 9.1.7
Api reference : https://annotation.github.io/text-fabric/tf/cheatsheet.html

115 features found and 0 ignored
  0.00s loading features ...
   |     0.00s Dataset without structure sections in otext:no structure functions in the T-API
    22s All features loaded/computed - for details use TF.isLoaded()
..............................................................................................
.      6m 07s All versions loaded                                                            .
..............................................................................................

We want to switch easily between the APIs for the versions.

In [25]:
def activate(v):
    for (param, value) in versionInfo.get(v, versionInfo[""]).items():
        globals()[param] = value
    api[v].makeAvailableIn(globals())
    caption(4, "Active version is now -> {} <-".format(v))

Inspect the amount of slots in all versions.

In [26]:
nSlots = {}
for v in versions:
    activate(v)
    nSlots[v] = F.otype.maxSlot
    caption(0, "\t {} slots".format(nSlots[v]))
..............................................................................................
.      6m 09s Active version is now -> 2017 <-                                               .
..............................................................................................
|      6m 09s 	 426584 slots
..............................................................................................
.      6m 09s Active version is now -> 2021 <-                                               .
..............................................................................................
|      6m 09s 	 426590 slots

Method

When we compare two versions, we inspect the lexemes found at corresponding positions in the versions. We start at the beginning, and when the lexemes do not match, we have a closer look.

However, in order not to be disturbed by minor discrepancies in the lexemes, we mask the lexemes: we apply a few transformations to it, such as removing alephs and wavs, and finally even turning them into ordered sets of letters, thereby loosing the order and multiplicity of letter. We also strip the disambiguation marks.

We maintain a current mapping between the slots of the two versions, and we update it if we encounter disturbances. Initially, this map is the identity map.

What we encounter as remaining differences boils down to the following:

  • a lexeme is split into two lexemes with the same total material, typically involving H, MN, or B
  • the lexeme is part of a special case, listed in the cases table (which has been found by repeatedly chasing for the first remaining difference.
  • the both lexemes differ, but that's it, no map updates have to be done.

The first two types of cases can be solved by splitting a lexeme into k parts or combining k lexemes into one. After that the mapping has to be shifted to the right or to the left from a certain point onwards.

The loop then is as follows:

  • find the first slot with a lexeme in the first version that is different from the lexeme at the mapped slot in the second version
  • analyze what is the case:
    • if the disturbance is recognized on the basis of existing patterns and cases, update the map and consider this case solved
    • if the disturbance is not recognized, the case is unsolved, and we break out of the loop. More analysis is needed, and the outcome of that has to be coded as an extra pattern or case.
  • if the status is solved, go back to the first step

We end up with a mapping from the slots of the first version to those of the other version that links slots with approximately equal lexemes together.

Making slot mappings

Lexeme masking

We start by defining our masking function, and compile lists of all lexemes and masked lexemes for all versions.

In [27]:
masks = [
    (lambda lex: lex.rstrip("[/="), "strip disambiguation"),
    (lambda lex: lex[0:-2] if lex.endswith("JM") else lex, "remove JM"),
    (lambda lex: lex[0:-2] if lex.endswith("WT") else lex, "remove WT"),
    (lambda lex: lex.replace("J", ""), "remove J"),
    (lambda lex: lex.replace(">", ""), "remove Alef"),
    (lambda lex: lex.replace("W", ""), "remove W"),
    (lambda lex: lex.replace("Z", "N"), "identify Z and N"),
    (lambda lex: lex.rstrip("HT"), "strip HT"),
    (
        lambda lex: ("".join(sorted(set(set(lex))))) + "_" * lex.count("_"),
        "ignore order and multiplicity",
    ),
]


def mask(lex, trans=None):
    """Apply a single masking operation or apply them all.
    
    Parameters
    ----------
    lex: string
        The text of the lexem
    trans: integer, optional `None`
        If given, it is an index in the `masks` list, and the corresponding
        mask transformation will be applied to `lex`.
        If `None`, all transformations in the `masks` list will be applied in that order.
        
    Returns
    -------
    string
        The result of transforming `lex`
    """
    if trans is not None:
        return masks[trans][0](lex)
    for (fun, desc) in masks:
        lex = fun(lex)
    return lex

Carry out the lexeme masking for all versions.

In [28]:
lexemes = {}

caption(4, "Masking lexemes")
for v in versions:
    activate(v)
    lexemes[v] = collections.OrderedDict()
    for n in F.otype.s("word"):
        lex = Fs(LEX).v(n)  # noqa F821
        lexemes[v][n] = (lex, mask(lex, trans=0), mask(lex))
caption(0, "Done")
..............................................................................................
.      6m 14s Masking lexemes                                                                .
..............................................................................................
..............................................................................................
.      6m 14s Active version is now -> 2017 <-                                               .
..............................................................................................
..............................................................................................
.      6m 15s Active version is now -> 2021 <-                                               .
..............................................................................................
|      6m 16s Done

Now for each version v, lexemes[v] is a mapping from word nodes n to lexeme information of the word at node n. The lexeme information is a tuple with members

  • fullLex the full disambiguated lexeme
  • lex the lexeme without the disambiguation marks
  • maskedLex the fully transformed lexeme

Cases and mappings

In cases we store special cases that we stumbled upon. Every time we encountered a disturbance which did not follow a recognized pattern, we turned it into a case. The number is the slot number in the first version where the case will be applied. Cases will only be applied at these exact slot numbers and nowhere else.

In mappings we build a mapping between corresponding nodes across a pair of versions. At some of those correspondences there are disturbances, there we add a measure of the dissimilarity to the mapped pair.

Later, we extend those slot mappings to node mappings, which are maps between versions where all nodes get mapped, not just slot nodes. We deliver those node mappings as formal edges in TF. Then these edges will be added in the second version, so that each newer version knows how to link to the previous version. We build the node maps in edges.

We store the dissimilarities in a separate dictionary, dissimilarity.

All these dictionaries are keyed by a 2-tuple of versions.

In [29]:
cases = {}
mappings = {}
dissimilarity = {}
edges = {}

Algorithm

Here is the code that directly implements the method. Every pair of distinct versions can be mapped. We store the mappings in a dictionary, keyed by tuples like (4, 4b), for the mapping from version 4 to 4b, for instance.

The loop is in doDiffs below.

In [30]:
def inspect(v, w, start, end):
    """Helper function for inspecting the situation in a given range of slots.
    
    Parameters
    ----------
    v: string
        First version
    w: string
        Second version
    start: integer
        Slot number (in first version) where we start the inspection.
    end: integer
        Slot number (in first version) where we end the inspection.
        
    Returns
    -------
    None
        The situation will be printed as a table with a row for each slot
        and columns:
        slot number in version 1,
        lexeme of that slot in version 1,
        lexeme of the corresponding slot in version 2
    """
    mapKey = (v, w)
    mapping = mappings[mapKey]
    version1Info = versionInfo.get(v, versionInfo[""])
    version2Info = versionInfo.get(w, versionInfo[""])
    
    for slot in range(start, end):
        print(
            "{:>6}: {:<8} {:<8}".format(
                slot,
                api[v].Fs(version1Info["LEX"]).v(slot),
                api[w].Fs(version2Info["LEX"]).v(mapping[slot]),
            )
        )


def inspect2(v, w, slot, k):
    """Helper function for inspecting the edges in a given range of slots.
    
    Not used, currently.
    
    Parameters
    ----------
    v: string
        First version
    w: string
        Second version
    slot: integer
        Slot number (in first version) in the center of the inspection
    k: integer
        Amount of slots left and right from the center where we inspect.
        
    Returns
    -------
    None
        The situation will be printed as a table with a row for each slot
        and columns:
        slot number in version 1,
        the edge at that slot number, or X if there is no edge
    """
    mapKey = (v, w)
    edge = edges[mapKey]
    for i in range(slot - k, slot + k + 1):
        print(f"EDGE {i} =>", edge.get(i, "X"))


def firstDiff(v, w, start):
    """Find the first discrepancy after a given position.
    
    First we walk quickly through the slots of th first version,
    until we reach the starting position.
    
    Then we continue walking until the current slot is either
    
    *   a special case
    *   a discrepancy
    
    Parameters
    ----------
    v: string
        First version
    w: string
        Second version
    start: integer
        start position
    
    Returns
    -------
    int or None
        If there is no discrepancy, None is returned,
        otherwise the position of the first discrepancy.
    """
    mapKey = (v, w)
    mapping = mappings[mapKey]
    theseCases = cases[mapKey]

    fDiff = None
    for (slot, (lex1, bareLex1, maskedLex1)) in lexemes[v].items():
        if slot < start:
            continue
        maskedLex2 = lexemes[w][mapping[slot]][2]
        if slot in theseCases or maskedLex1 != maskedLex2:
            fDiff = slot
            break
    return fDiff


def printDiff(v, w, slot, k):
    """Prints the situation around a discrepancy.
    
    We also show phrase atom boundaries.
    WE show the bare lexemes in the display, not the masked lexemes.
    
    Parameters
    ----------
    v: string
        First version
    w: string
        Second version
    slot: integer
        position of the discrepancy
    k: integer
        amount of slots around the discrepancy to include in the display
        
    Returns
    -------
    A plain text display of the situation around the discrepancy.
    """
    
    mapKey = (v, w)
    mapping = mappings[mapKey]
    comps = {}
    prevChunkV = None
    prevChunkW = None
    
    # gather the comparison material in comps
    # which has as keys the versions and as value a list of display items
    
    for i in range(slot - k, slot + k + 1):
        # determine if we are at a phrase atom boundary in version 1
        chunkV = None if i not in mapping else api[v].L.u(i, otype="phrase_atom")
        boundaryV = prevChunkV is not None and prevChunkV != chunkV
        prevChunkV = chunkV
        # determine if we are at the actual discrepancy in version 1
        currentV = i == slot

        # determine if we are at a phrase atom boundary in version 2
        j = mapping.get(i, None)
        chunkW = None if j is None else api[w].L.u(j, otype="phrase_atom")
        boundaryW = prevChunkW is not None and prevChunkW != chunkW
        prevChunkW = chunkW
        # determine if we are at the actual discrepancy in version 2
        currentW = j == mapping[slot]

        lvTuple = lexemes[v].get(i, None)
        lwTuple = None if j is None else lexemes[w].get(j, None)
        lv = "□" if lvTuple is None else lvTuple[1] # bare lexeme
        lw = "□" if lwTuple is None else lwTuple[1] # bare lexeme

        comps.setdefault(v, []).append((lv, currentV, boundaryV))
        comps.setdefault(w, []).append((lw, currentW, boundaryW))
        
    # turn the display items into strings and store them in rep
    # which is also keyed by the versions
    
    rep = {}
    for version in comps:
        rep[version] = printVersion(version, comps[version])

    # compose the display out of the strings per version
    # and make a header of sectional information and slot positions
    
    print(
        """{} {}:{} ==> slot {} ==> {}
    {}
    {}
""".format(
            *api[v].T.sectionFromNode(slot),
            slot,
            mapping[slot],
            rep[v],
            rep[w],
        )
    )


def printVersion(v, comps):
    """Generate a string displaying a stretch of lexemes around a position.
    
    Parameters
    ----------
    comps: list of tuple
        For each slot there is a comp tuple consisting of
        
        *   the bare lexeme
        *   whether the slot is in the discrepancy position
        *   whether the slot is at a phrase atom boundary
        
    Returns
    -------
    string
        A sequence of lexemes with boundary characters in between.
    """
    
    rep = ""
    for (lex, isCurrent, boundary) in comps:
        rep += "┫┣" if boundary else "╋"
        rep += f"▶{lex}◀" if isCurrent else lex
    rep += "╋"
    return rep

doDiffs

This function contains the loop to walk through all differences.

We walk from discrepancy to discrepancy, and stop if there are no more discrepancies or when we have reached an artificial upper boundary of discrepancies.

We try to solve the discrepancies. If we hit a discrepancy that we cannot solve, we break out the loop too.

MAX_ITER

The articial limit is MAX_ITER. You determine it experimentally. Keep it low at first, when you are meeting the initial discrepancies. When you have dealt with them and discover that you can dealt with that amount of discrepancies, increase the limit.

Cases

We will encounter discrepancies, and we will learn how to solve them. There are some generic ways of solving them, and these we collect in a dictionary of cases.

The keys of the cases are either slot positions or lexemes.

When the algorithms walks through the corpus, it will consider slots whose number or whose lexeme is in the cases as solved.

The value of a case is a tuple consisting of

  • the name of an action
  • a parameter

Here are the actions

key action parameters description
slot ok None the discrepancy is ok, nothing to worry about; we set the dissimilarity to 0, which is worse than None
slot split n integer split the lexeme in version 1 into n lexemes in version 2; set the dissimilarity to n
slot collapse n integer collapse n lexemes in version 1 into one lexeme in version 2; dissimilarity -n
lex ok alt string the discrepancy is ok if version 2 has alt instead of lex; dissimilarity set to 0
lex split n integer split lex in version 1 into n extra slots in version 2; set the dissimilarity to n

If a discrepancy falls through all these special cases, we have a few generic rules that will also be applied:

  • if a lexeme in version 1 contains _, we split on it and treat it as separate lexemes. In fact, we perform the action split with parameter the number of parts separated by _.
  • if the lex in version 1 equals the lex in version 2 plus the next lex in version 2, and if the lex in version 2 is H, we split the lex in version 1 into that H and the rest.
  • if the set of letters in the masked lexeme in version 1 is the union of the sets of the corresponding masked lexeme in version 2 plus that of the next lexeme in version 2, and if the corresponding lexeme in version 2 is either B or MN, we split the lex in version 1 into that B or MN and the rest.

Note that these rules are very corpus dependent, and have been distilled from experience with the BHSA versions involved. If you aree in the process of applying this algorithm to other corpora, you can leave out these rules, and add your own depending on what you encounter.

In [31]:
MAX_ITER = 250


def doDiffs(v, w):
    mapKey = (v, w)
    
    thisDissimilarity = {}
    dissimilarity[mapKey] = thisDissimilarity
    
    thisMapping = dict(((n, n) for n in api[v].F.otype.s("word")))
    mappings[mapKey] = thisMapping
    
    theseCases = cases.get(mapKey, {})

    iteration = 0
    start = 1

    solved = True

    while True:
        # try to find the next difference from where you are now
        n = firstDiff(v, w, start)

        if n is None:
            print(f"No more differences.\nFound {iteration} points of disturbance")
            break

        if iteration > MAX_ITER:
            print("There might be more disturbances: increase MAX_ITER")
            break

        iteration += 1
        
        # there is a difference: we have to do work
        # we print it as a kind of logging
        
        printDiff(v, w, n, 5)

        # we try to solve the discrepancy
        # first we gather the information of about the lexemes at this position in both versions
    
        (lex1, bareLex1, maskedLex1) = lexemes[v][n]
        (lex2, bareLex2, maskedLex2) = lexemes[w][thisMapping[n]]
        
        # and at the next position
        
        (lex1next, bareLex1next, maskedLex1next) = lexemes[v][n + 1]
        (lex2next, bareLex2next, maskedLex2next) = lexemes[w][thisMapping[n + 1]]

        # the discrepancy is not solved unless we find it in a case or in a rule
        solved = None
        skip = 0
        
        # first check the explicit cases
        
        if n in theseCases:
            (action, param) = theseCases[n]
            if action == "collapse":
                plural = "" if param == 1 else "s"
                solved = f"{action} {param} fewer slot{plural}"
                thisDissimilarity[n] = -param
                skip = param
                for m in range(api[v].F.otype.maxSlot, n + param, -1):
                    thisMapping[m] = thisMapping[m - param]
                for m in range(n + 1, n + param + 1):
                    thisMapping[m] = thisMapping[n]
            elif action == "split":
                plural = "" if param == 1 else "s"
                solved = f"{action} into {param} extra slot{plural}"
                thisDissimilarity[n] = param
                for m in range(n + 1, api[v].F.otype.maxSlot + 1):
                    thisMapping[m] = thisMapping[m] + param
            elif action == "ok":
                solved = "incidental variation in lexeme"
                thisDissimilarity[n] = 0
        elif lex1 in theseCases:
            (action, param) = theseCases[lex1]
            if action == "ok":
                if lex2 == param:
                    solved = "systematic variation in lexeme"
                    thisDissimilarity[n] = 0
            elif action == "split":
                plural = "" if param == 1 else "s"
                solved = f"systematic {action} into {param} extra slot{plural}"
                thisDissimilarity[n] = param
                for m in range(n + 1, api[v].F.otype.maxSlot + 1):
                    thisMapping[m] = thisMapping[m] + param
                    
        # then try some more general rules
        
        elif "_" in lex1:
            action = "split"
            param = lex1.count("_")
            plural = "" if param == 1 else "s"
            solved = f"{action} on _ into {param} extra slot{plural}"
            thisDissimilarity[n] = param
            for m in range(n + 1, api[v].F.otype.maxSlot + 1):
                thisMapping[m] = thisMapping[m] + param
        elif lex1 == lex2 + lex2next:
            if lex2 == "H":
                solved = "split article off"
                thisDissimilarity[n] = 1
                for m in range(n + 1, api[v].F.otype.maxSlot + 1):
                    thisMapping[m] = thisMapping[m] + 1
        elif set(maskedLex1) == set(maskedLex2) | set(maskedLex2next):
            if lex2 == "B" or lex2 == "MN":
                solved = "split preposition off"
                thisDissimilarity[n] = 1
                for m in range(n + 1, api[v].F.otype.maxSlot + 1):
                    thisMapping[m] = thisMapping[m] + 1
        print(f"Action: {solved if solved else 'BLOCKED'}\n")

        # stop the loop if the discrepancy is not solved
        # The discrepancy has already been printed to the output,
        # so you can see immediately what is happening there
        
        if not solved:
            break

        # if the discrepancy was solved, 
        # advance to the first position after the discrepancy
        # and try to find a new discrepancy in the next iteration
        start = n + 1 + skip

    if not solved:
        print(f"Blocking difference in {iteration} iterations")

The mappings itself are needed elsewhere in Text-Fabric, let us write them to file. We write them into the dataset corresponding to the target version. So the map 3-4 ends up in version 4.

In [32]:
def edgesFromMaps():
    edges.clear()
    for ((v, w), mp) in sorted(mappings.items()):
        caption(4, "Make edge from slot mapping {} => {}".format(v, w))

        edge = {}
        dm = dissimilarity[(v, w)]

        for n in range(1, api[v].F.otype.maxSlot + 1):
            m = mp[n]
            k = dm.get(n, None)
            if k is None:
                if n in edge:
                    if m not in edge[n]:
                        edge[n][m] = None
                else:
                    edge.setdefault(n, {})[m] = None
            else:
                if k > 0:
                    for j in range(m, m + k + 1):
                        edge.setdefault(n, {})[j] = k
                elif k < 0:
                    for i in range(n, n - k + 1):
                        edge.setdefault(i, {})[m] = k
                else:
                    edge.setdefault(n, {})[m] = 0
        edges[(v, w)] = edge

Running

Here we run the mapping between 3 and 4.

3 => 4

Here are the special cases for this conversion.

In [12]:
cases.update(
    {
        ("3", "4"): {
            "CXH[": ("ok", "XWH["),
            "MQYT/": ("split", 1),
            28730: ("ok", None),
            121812: ("ok", None),
            174515: ("ok", None),
            201089: ("ok", None),
            218383: ("split", 2),
            221436: ("ok", None),
            247730: ("ok", None),
            272883: ("collapse", 1),
            353611: ("ok", None),
        },
    }
)
In [13]:
doDiffs("3", "4")
Genesis 18:2 ==> slot 7840 ==> 7840
    ╋MN╋PTX╋H╋>HL┫┣W┫┣▶CXH◀┫┣>RY┫┣W┫┣>MR┫┣>DNJ┫┣>M╋
    ╋MN╋PTX╋H╋>HL┫┣W┫┣▶XWH◀┫┣>RY┫┣W┫┣>MR┫┣>DNJ┫┣>M╋

Action: systematic variation in lexeme

Genesis 19:1 ==> slot 8447 ==> 8447
    ╋W┫┣QWM┫┣L╋QR>┫┣W┫┣▶CXH◀┫┣>P┫┣>RY┫┣W┫┣>MR┫┣HNH╋
    ╋W┫┣QWM┫┣L╋QR>┫┣W┫┣▶XWH◀┫┣>P┫┣>RY┫┣W┫┣>MR┫┣HNH╋

Action: systematic variation in lexeme

Genesis 21:14 ==> slot 9856 ==> 9856
    ╋HLK┫┣W┫┣T<H┫┣B╋MDBR╋▶B>R_CB<◀┫┣W┫┣KLH┫┣H╋MJM┫┣MN╋
    ╋HLK┫┣W┫┣T<H┫┣B╋MDBR╋▶B>R◀╋CB<┫┣W┫┣KLH┫┣H╋MJM╋

Action: split on _ into 1 extra slot

Genesis 21:31 ==> slot 10174 ==> 10175
    ╋L╋H╋MQWM╋H╋HW>┫┣▶B>R_CB<◀┫┣KJ┫┣CM┫┣CB<┫┣CNJM┫┣W╋
    ╋L╋H╋MQWM╋H╋HW>┫┣▶B>R◀╋CB<┫┣KJ┫┣CM┫┣CB<┫┣CNJM╋

Action: split on _ into 1 extra slot

Genesis 21:32 ==> slot 10183 ==> 10185
    ╋CNJM┫┣W┫┣KRT┫┣BRJT┫┣B╋▶B>R_CB<◀┫┣W┫┣QWM┫┣>BJMLK╋W╋PJKL╋
    ╋CNJM┫┣W┫┣KRT┫┣BRJT┫┣B╋▶B>R◀╋CB<┫┣W┫┣QWM┫┣>BJMLK╋W╋

Action: split on _ into 1 extra slot

Genesis 21:33 ==> slot 10200 ==> 10203
    ╋PLCTJ┫┣W┫┣NV<┫┣>CL┫┣B╋▶B>R_CB<◀┫┣W┫┣QR>┫┣CM┫┣B╋CM╋
    ╋PLCTJ┫┣W┫┣NV<┫┣>CL┫┣B╋▶B>R◀╋CB<┫┣W┫┣QR>┫┣CM┫┣B╋

Action: split on _ into 1 extra slot

Genesis 22:5 ==> slot 10341 ==> 10345
    ╋N<R┫┣HLK┫┣<D╋KH┫┣W┫┣▶CXH◀┫┣W┫┣CWB┫┣>L┫┣W┫┣LQX╋
    ╋N<R┫┣HLK┫┣<D╋KH┫┣W┫┣▶XWH◀┫┣W┫┣CWB┫┣>L┫┣W┫┣LQX╋

Action: systematic variation in lexeme

Genesis 22:19 ==> slot 10641 ==> 10645
    ╋QWM┫┣W┫┣HLK┫┣JXDW┫┣>L╋▶B>R_CB<◀┫┣W┫┣JCB┫┣>BRHM┫┣B╋B>R_CB<╋
    ╋QWM┫┣W┫┣HLK┫┣JXDW┫┣>L╋▶B>R◀╋CB<┫┣W┫┣JCB┫┣>BRHM┫┣B╋

Action: split on _ into 1 extra slot

Genesis 22:19 ==> slot 10646 ==> 10651
    ╋B>R_CB<┫┣W┫┣JCB┫┣>BRHM┫┣B╋▶B>R_CB<◀┫┣W┫┣HJH┫┣>XR╋H╋DBR╋
    ╋B>R┫┣W┫┣JCB┫┣>BRHM┫┣B╋▶B>R◀╋CB<┫┣W┫┣HJH┫┣>XR╋H╋

Action: split on _ into 1 extra slot

Genesis 23:7 ==> slot 10830 ==> 10836
    ╋MWT┫┣W┫┣QWM┫┣>BRHM┫┣W┫┣▶CXH◀┫┣L╋<M╋H╋>RY┫┣L╋
    ╋MWT┫┣W┫┣QWM┫┣>BRHM┫┣W┫┣▶XWH◀┫┣L╋<M╋H╋>RY┫┣L╋

Action: systematic variation in lexeme

Genesis 23:12 ==> slot 10933 ==> 10939
    ╋NTN┫┣L┫┣QBR┫┣MWT┫┣W┫┣▶CXH◀┫┣>BRHM┫┣L╋PNH╋<M╋H╋
    ╋NTN┫┣L┫┣QBR┫┣MWT┫┣W┫┣▶XWH◀┫┣>BRHM┫┣L╋PNH╋<M╋H╋

Action: systematic variation in lexeme

Genesis 24:26 ==> slot 11604 ==> 11610
    ╋W┫┣QDD┫┣H╋>JC┫┣W┫┣▶CXH◀┫┣L╋JHWH┫┣W┫┣>MR┫┣BRK╋
    ╋W┫┣QDD┫┣H╋>JC┫┣W┫┣▶XWH◀┫┣L╋JHWH┫┣W┫┣>MR┫┣BRK╋

Action: systematic variation in lexeme

Genesis 24:48 ==> slot 12051 ==> 12057
    ╋<L╋JD┫┣W┫┣QDD┫┣W┫┣▶CXH◀┫┣L╋JHWH┫┣W┫┣BRK┫┣>T╋
    ╋<L╋JD┫┣W┫┣QDD┫┣W┫┣▶XWH◀┫┣L╋JHWH┫┣W┫┣BRK┫┣>T╋

Action: systematic variation in lexeme

Genesis 24:52 ==> slot 12144 ==> 12150
    ╋<BD╋>BRHM┫┣>T╋DBR┫┣W┫┣▶CXH◀┫┣>RY┫┣L╋JHWH┫┣W┫┣JY>╋
    ╋<BD╋>BRHM┫┣>T╋DBR┫┣W┫┣▶XWH◀┫┣>RY┫┣L╋JHWH┫┣W┫┣JY>╋

Action: systematic variation in lexeme

Genesis 25:20 ==> slot 12724 ==> 12730
    ╋BT╋BTW>L┫┣H╋>RMJ┫┣MN╋▶PDN_>RM◀┫┣>XWT╋LBN┫┣H╋>RMJ┫┣L╋
    ╋BT╋BTW>L┫┣H╋>RMJ┫┣MN╋▶PDN◀╋>RM┫┣>XWT╋LBN┫┣H╋>RMJ╋

Action: split on _ into 1 extra slot

Genesis 26:23 ==> slot 13405 ==> 13412
    ╋>RY┫┣W┫┣<LH┫┣MN╋CM┫┣▶B>R_CB<◀┫┣W┫┣R>H┫┣>L┫┣JHWH┫┣B╋
    ╋>RY┫┣W┫┣<LH┫┣MN╋CM┫┣▶B>R◀╋CB<┫┣W┫┣R>H┫┣>L┫┣JHWH╋

Action: split on _ into 1 extra slot

Genesis 26:33 ==> slot 13588 ==> 13596
    ╋<L╋KN┫┣CM╋H╋<JR┫┣▶B>R_CB<◀┫┣<D╋H╋JWM╋H╋ZH╋
    ╋<L╋KN┫┣CM╋H╋<JR┫┣▶B>R◀╋CB<┫┣<D╋H╋JWM╋H╋

Action: split on _ into 1 extra slot

Genesis 27:29 ==> slot 14101 ==> 14110
    ╋W╋TJRWC┫┣<BD┫┣<M┫┣W┫┣▶CXH◀┫┣L┫┣L>M┫┣HWH┫┣GBJR┫┣L╋
    ╋W╋TJRWC┫┣<BD┫┣<M┫┣W┫┣▶XWH◀┫┣L┫┣L>M┫┣HWH┫┣GBJR┫┣L╋

Action: systematic variation in lexeme

Genesis 27:29 ==> slot 14109 ==> 14118
    ╋HWH┫┣GBJR┫┣L╋>X┫┣W┫┣▶CXH◀┫┣L┫┣BN╋>M┫┣>RR┫┣>RR╋
    ╋HWH┫┣GBJR┫┣L╋>X┫┣W┫┣▶XWH◀┫┣L┫┣BN╋>M┫┣>RR┫┣>RR╋

Action: systematic variation in lexeme

Genesis 28:2 ==> slot 14510 ==> 14519
    ╋MN╋BT╋KN<N┫┣QWM┫┣HLK┫┣▶PDN_>RM◀┫┣BJT╋BTW>L┫┣>B╋>M┫┣W╋
    ╋MN╋BT╋KN<N┫┣QWM┫┣HLK┫┣▶PDN◀╋>RM┫┣BJT╋BTW>L┫┣>B╋>M╋

Action: split on _ into 1 extra slot

Genesis 28:5 ==> slot 14568 ==> 14578
    ╋JYXQ┫┣>T╋J<QB┫┣W┫┣HLK┫┣▶PDN_>RM◀┫┣>L╋LBN┫┣BN╋BTW>L┫┣H╋
    ╋JYXQ┫┣>T╋J<QB┫┣W┫┣HLK┫┣▶PDN◀╋>RM┫┣>L╋LBN┫┣BN╋BTW>L╋

Action: split on _ into 1 extra slot

Genesis 28:6 ==> slot 14592 ==> 14603
    ╋>T╋J<QB┫┣W┫┣CLX┫┣>T┫┣▶PDN_>RM◀┫┣L╋LQX┫┣L┫┣MN╋CM╋
    ╋>T╋J<QB┫┣W┫┣CLX┫┣>T┫┣▶PDN◀╋>RM┫┣L╋LQX┫┣L┫┣MN╋

Action: split on _ into 1 extra slot

Genesis 28:7 ==> slot 14623 ==> 14635
    ╋W╋>L╋>M┫┣W┫┣HLK┫┣▶PDN_>RM◀┫┣W┫┣R>H┫┣<FW┫┣KJ┫┣R<╋
    ╋W╋>L╋>M┫┣W┫┣HLK┫┣▶PDN◀╋>RM┫┣W┫┣R>H┫┣<FW┫┣KJ╋

Action: split on _ into 1 extra slot

Genesis 28:10 ==> slot 14659 ==> 14672
    ╋>CH┫┣W┫┣JY>┫┣J<QB┫┣MN╋▶B>R_CB<◀┫┣W┫┣HLK┫┣XRN┫┣W┫┣PG<╋
    ╋>CH┫┣W┫┣JY>┫┣J<QB┫┣MN╋▶B>R◀╋CB<┫┣W┫┣HLK┫┣XRN┫┣W╋

Action: split on _ into 1 extra slot

Genesis 31:18 ==> slot 16687 ==> 16701
    ╋MQNH╋QNJN┫┣>CR┫┣RKC┫┣B╋▶PDN_>RM◀┫┣L╋BW>┫┣>L╋JYXQ┫┣>B╋
    ╋MQNH╋QNJN┫┣>CR┫┣RKC┫┣B╋▶PDN◀╋>RM┫┣L╋BW>┫┣>L╋JYXQ╋

Action: split on _ into 1 extra slot

Genesis 33:3 ==> slot 18117 ==> 18132
    ╋HW>┫┣<BR┫┣L╋PNH┫┣W┫┣▶CXH◀┫┣>RY┫┣CB<╋P<M┫┣<D╋NGC╋
    ╋HW>┫┣<BR┫┣L╋PNH┫┣W┫┣▶XWH◀┫┣>RY┫┣CB<╋P<M┫┣<D╋NGC╋

Action: systematic variation in lexeme

Genesis 33:6 ==> slot 18175 ==> 18190
    ╋CPXH┫┣HNH╋W╋JLD┫┣W┫┣▶CXH◀┫┣W┫┣NGC┫┣GM┫┣L>H╋W╋
    ╋CPXH┫┣HNH╋W╋JLD┫┣W┫┣▶XWH◀┫┣W┫┣NGC┫┣GM╋L>H╋W╋

Action: systematic variation in lexeme

Genesis 33:7 ==> slot 18183 ==> 18198
    ╋GM┫┣L>H╋W╋JLD┫┣W┫┣▶CXH◀┫┣W┫┣>XR┫┣NGC┫┣JWSP╋W╋
    ╋GM╋L>H╋W╋JLD┫┣W┫┣▶XWH◀┫┣W┫┣>XR┫┣NGC┫┣JWSP╋W╋

Action: systematic variation in lexeme

Genesis 33:7 ==> slot 18191 ==> 18206
    ╋NGC┫┣JWSP╋W╋RXL┫┣W┫┣▶CXH◀┫┣W┫┣>MR┫┣MJ┫┣L┫┣KL╋
    ╋NGC┫┣JWSP╋W╋RXL┫┣W┫┣▶XWH◀┫┣W┫┣>MR┫┣MJ┫┣L┫┣KL╋

Action: systematic variation in lexeme

Genesis 33:18 ==> slot 18397 ==> 18412
    ╋>RY╋KN<N┫┣B╋BW>┫┣MN╋▶PDN_>RM◀┫┣W┫┣XNH┫┣>T╋PNH╋H╋
    ╋>RY╋KN<N┫┣B╋BW>┫┣MN╋▶PDN◀╋>RM┫┣W┫┣XNH┫┣>T╋PNH╋

Action: split on _ into 1 extra slot

Genesis 35:9 ==> slot 19216 ==> 19232
    ╋J<QB┫┣<WD┫┣B╋BW>┫┣MN╋▶PDN_>RM◀┫┣W┫┣BRK┫┣>T┫┣W┫┣>MR╋
    ╋J<QB┫┣<WD┫┣B╋BW>┫┣MN╋▶PDN◀╋>RM┫┣W┫┣BRK┫┣>T┫┣W╋

Action: split on _ into 1 extra slot

Genesis 35:26 ==> slot 19485 ==> 19502
    ╋J<QB┫┣>CR┫┣JLD┫┣L┫┣B╋▶PDN_>RM◀┫┣W┫┣BW>┫┣J<QB┫┣>L╋JYXQ╋
    ╋J<QB┫┣>CR┫┣JLD┫┣L┫┣B╋▶PDN◀╋>RM┫┣W┫┣BW>┫┣J<QB┫┣>L╋

Action: split on _ into 1 extra slot

Genesis 37:7 ==> slot 20271 ==> 20289
    ╋W┫┣HNH┫┣SBB┫┣>LMH┫┣W┫┣▶CXH◀┫┣L╋>LMH┫┣W┫┣>MR┫┣L╋
    ╋W┫┣HNH┫┣SBB┫┣>LMH┫┣W┫┣▶XWH◀┫┣L╋>LMH┫┣W┫┣>MR┫┣L╋

Action: systematic variation in lexeme

Genesis 37:9 ==> slot 20323 ==> 20341
    ╋JRX╋W╋>XD╋<FR╋KWKB┫┣▶CXH◀┫┣L┫┣W┫┣SPR┫┣>L╋>B╋
    ╋JRX╋W╋>XD╋<FR╋KWKB┫┣▶XWH◀┫┣L┫┣W┫┣SPR┫┣>L╋>B╋

Action: systematic variation in lexeme

Genesis 37:10 ==> slot 20355 ==> 20373
    ╋W╋>M╋W╋>X┫┣L╋▶CXH◀┫┣L┫┣>RY┫┣W┫┣QN>┫┣B╋
    ╋W╋>M╋W╋>X┫┣L╋▶XWH◀┫┣L┫┣>RY┫┣W┫┣QN>┫┣B╋

Action: systematic variation in lexeme

Genesis 42:6 ==> slot 23509 ==> 23527
    ╋W┫┣BW>┫┣>X╋JWSP┫┣W┫┣▶CXH◀┫┣L┫┣>P┫┣>RY┫┣W┫┣R>H╋
    ╋W┫┣BW>┫┣>X╋JWSP┫┣W┫┣▶XWH◀┫┣L┫┣>P┫┣>RY┫┣W┫┣R>H╋

Action: systematic variation in lexeme

Genesis 43:26 ==> slot 24650 ==> 24668
    ╋B╋JD┫┣H╋BJT┫┣W┫┣▶CXH◀┫┣L┫┣>RY┫┣W┫┣C>L┫┣L╋
    ╋B╋JD┫┣H╋BJT┫┣W┫┣▶XWH◀┫┣L┫┣>RY┫┣W┫┣C>L┫┣L╋

Action: systematic variation in lexeme

Genesis 43:28 ==> slot 24682 ==> 24700
    ╋<WD┫┣XJ┫┣W┫┣QDD┫┣W┫┣▶CXH◀┫┣W┫┣NF>┫┣<JN┫┣W┫┣R>H╋
    ╋<WD┫┣XJ┫┣W┫┣QDD┫┣W┫┣▶XWH◀┫┣W┫┣NF>┫┣<JN┫┣W┫┣R>H╋

Action: systematic variation in lexeme

Genesis 46:1 ==> slot 25981 ==> 25999
    ╋KL┫┣>CR┫┣L┫┣W┫┣BW>┫┣▶B>R_CB<◀┫┣W┫┣ZBX┫┣ZBX┫┣L╋>LHJM╋
    ╋KL┫┣>CR┫┣L┫┣W┫┣BW>┫┣▶B>R◀╋CB<┫┣W┫┣ZBX┫┣ZBX┫┣L╋

Action: split on _ into 1 extra slot

Genesis 46:5 ==> slot 26042 ==> 26061
    ╋<JN┫┣W┫┣QWM┫┣J<QB┫┣MN╋▶B>R_CB<◀┫┣W┫┣NF>┫┣BN╋JFR>L┫┣>T╋
    ╋<JN┫┣W┫┣QWM┫┣J<QB┫┣MN╋▶B>R◀╋CB<┫┣W┫┣NF>┫┣BN╋JFR>L╋

Action: split on _ into 1 extra slot

Genesis 46:15 ==> slot 26201 ==> 26221
    ╋>CR┫┣JLD┫┣L╋J<QB┫┣B╋▶PDN_>RM◀┫┣W┫┣>T╋DJNH┫┣BT┫┣KL╋
    ╋>CR┫┣JLD┫┣L╋J<QB┫┣B╋▶PDN◀╋>RM┫┣W┫┣>T╋DJNH┫┣BT╋

Action: split on _ into 1 extra slot

Genesis 47:31 ==> slot 27267 ==> 27288
    ╋L┫┣W┫┣CB<┫┣L┫┣W┫┣▶CXH◀┫┣JFR>L┫┣<L╋R>C╋H╋MVH╋
    ╋L┫┣W┫┣CB<┫┣L┫┣W┫┣▶XWH◀┫┣JFR>L┫┣<L╋R>C╋H╋MVH╋

Action: systematic variation in lexeme

Genesis 48:12 ==> slot 27501 ==> 27522
    ╋>T┫┣MN╋<M╋BRK┫┣W┫┣▶CXH◀┫┣L╋>P┫┣>RY┫┣W┫┣LQX╋
    ╋>T┫┣MN╋<M╋BRK┫┣W┫┣▶XWH◀┫┣L╋>P┫┣>RY┫┣W┫┣LQX╋

Action: systematic variation in lexeme

Genesis 49:8 ==> slot 27858 ==> 27879
    ╋>X┫┣JD┫┣B╋<RP╋>JB┫┣▶CXH◀┫┣L┫┣BN╋>B┫┣GWR╋>RJH╋
    ╋>X┫┣JD┫┣B╋<RP╋>JB┫┣▶XWH◀┫┣L┫┣BN╋>B┫┣GWR╋>RJH╋

Action: systematic variation in lexeme

Genesis 50:26 ==> slot 28730 ==> 28751
    ╋CNH┫┣W┫┣XNV┫┣>T┫┣W┫┣▶FJM◀┫┣B╋H╋>RWN┫┣B╋MYRJM╋
    ╋CNH┫┣W┫┣XNV┫┣>T┫┣W┫┣▶JFM◀┫┣B╋H╋>RWN┫┣B╋MYRJM╋

Action: incidental variation in lexeme

Exodus 4:31 ==> slot 30778 ==> 30799
    ╋>T╋<NJ┫┣W┫┣QDD┫┣W┫┣▶CXH◀┫┣W┫┣>XR┫┣BW>┫┣MCH╋W╋
    ╋>T╋<NJ┫┣W┫┣QDD┫┣W┫┣▶XWH◀┫┣W┫┣>XR┫┣BW>┫┣MCH╋W╋

Action: systematic variation in lexeme

Exodus 11:8 ==> slot 34587 ==> 34608
    ╋KL╋<BD╋>LH┫┣>L┫┣W┫┣▶CXH◀┫┣L┫┣L╋>MR┫┣JY>┫┣>TH╋
    ╋KL╋<BD╋>LH┫┣>L┫┣W┫┣▶XWH◀┫┣L┫┣L╋>MR┫┣JY>┫┣>TH╋

Action: systematic variation in lexeme

Exodus 12:27 ==> slot 35293 ==> 35314
    ╋W┫┣QDD┫┣H╋<M┫┣W┫┣▶CXH◀┫┣W┫┣HLK┫┣W┫┣<FH┫┣BN╋
    ╋W┫┣QDD┫┣H╋<M┫┣W┫┣▶XWH◀┫┣W┫┣HLK┫┣W┫┣<FH┫┣BN╋

Action: systematic variation in lexeme

Exodus 18:7 ==> slot 38561 ==> 38582
    ╋MCH┫┣L╋QR>┫┣XTN┫┣W┫┣▶CXH◀┫┣W┫┣NCQ┫┣L┫┣W┫┣C>L╋
    ╋MCH┫┣L╋QR>┫┣XTN┫┣W┫┣▶XWH◀┫┣W┫┣NCQ┫┣L┫┣W┫┣C>L╋

Action: systematic variation in lexeme

Exodus 20:5 ==> slot 39627 ==> 39648
    ╋TXT╋L╋H╋>RY┫┣L>┫┣▶CXH◀┫┣L┫┣W┫┣L>┫┣<BD┫┣KJ╋
    ╋TXT╋L╋H╋>RY┫┣L>┫┣▶XWH◀┫┣L┫┣W┫┣L>┫┣<BD┫┣KJ╋

Action: systematic variation in lexeme

Exodus 23:24 ==> slot 41400 ==> 41421
    ╋H╋JBWSJ┫┣W┫┣KXD┫┣L>┫┣▶CXH◀┫┣L╋>LHJM┫┣W┫┣L>┫┣<BD╋
    ╋H╋JBWSJ┫┣W┫┣KXD┫┣L>┫┣▶XWH◀┫┣L╋>LHJM┫┣W┫┣L>┫┣<BD╋

Action: systematic variation in lexeme

Exodus 24:1 ==> slot 41592 ==> 41613
    ╋CB<┫┣MN╋ZQN╋JFR>L┫┣W┫┣▶CXH◀┫┣MN╋RXWQ┫┣W┫┣NGC┫┣MCH╋
    ╋CB<┫┣MN╋ZQN╋JFR>L┫┣W┫┣▶XWH◀┫┣MN╋RXWQ┫┣W┫┣NGC┫┣MCH╋

Action: systematic variation in lexeme

Exodus 32:8 ==> slot 46644 ==> 46665
    ╋<FH┫┣L┫┣<GL┫┣MSKH┫┣W┫┣▶CXH◀┫┣L┫┣W┫┣ZBX┫┣L┫┣W╋
    ╋<FH┫┣L┫┣<GL┫┣MSKH┫┣W┫┣▶XWH◀┫┣L┫┣W┫┣ZBX┫┣L┫┣W╋

Action: systematic variation in lexeme

Exodus 33:10 ==> slot 47480 ==> 47501
    ╋QWM┫┣KL╋H╋<M┫┣W┫┣▶CXH◀┫┣>JC┫┣PTX╋>HL┫┣W┫┣DBR╋
    ╋QWM┫┣KL╋H╋<M┫┣W┫┣▶XWH◀┫┣>JC┫┣PTX╋>HL┫┣W┫┣DBR╋

Action: systematic variation in lexeme

Exodus 34:8 ==> slot 47918 ==> 47939
    ╋MCH┫┣W┫┣QDD┫┣>RY┫┣W┫┣▶CXH◀┫┣W┫┣>MR┫┣>M┫┣N>┫┣MY>╋
    ╋MCH┫┣W┫┣QDD┫┣>RY┫┣W┫┣▶XWH◀┫┣W┫┣>MR┫┣>M┫┣N>┫┣MY>╋

Action: systematic variation in lexeme

Exodus 34:14 ==> slot 48052 ==> 48073
    ╋>T╋>CRH┫┣KRT┫┣KJ┫┣L>┫┣▶CXH◀┫┣L╋>L╋>XR┫┣KJ┫┣JHWH╋
    ╋>T╋>CRH┫┣KRT┫┣KJ┫┣L>┫┣▶XWH◀┫┣L╋>L╋>XR┫┣KJ┫┣JHWH╋

Action: systematic variation in lexeme

Leviticus 26:1 ==> slot 68138 ==> 68159
    ╋L>┫┣NTN┫┣B╋>RY┫┣L╋▶CXH◀┫┣<L┫┣KJ┫┣>NJ┫┣JHWH┫┣>LHJM╋
    ╋L>┫┣NTN┫┣B╋>RY┫┣L╋▶XWH◀┫┣<L┫┣KJ┫┣>NJ┫┣JHWH┫┣>LHJM╋

Action: systematic variation in lexeme

Numbers 22:31 ==> slot 84445 ==> 84466
    ╋B╋JD┫┣W┫┣QDD┫┣W┫┣▶CXH◀┫┣L╋>P┫┣W┫┣>MR┫┣>L╋
    ╋B╋JD┫┣W┫┣QDD┫┣W┫┣▶XWH◀┫┣L╋>P┫┣W┫┣>MR┫┣>L╋

Action: systematic variation in lexeme

Numbers 25:2 ==> slot 85620 ==> 85641
    ╋W┫┣>KL┫┣H╋<M┫┣W┫┣▶CXH◀┫┣L╋>LHJM┫┣W┫┣YMD┫┣JFR>L╋
    ╋W┫┣>KL┫┣H╋<M┫┣W┫┣▶XWH◀┫┣L╋>LHJM┫┣W┫┣YMD┫┣JFR>L╋

Action: systematic variation in lexeme

Deuteronomy 4:19 ==> slot 95563 ==> 95584
    ╋H╋CMJM┫┣W┫┣NDX┫┣W┫┣▶CXH◀┫┣L┫┣W┫┣<BD┫┣>CR┫┣XLQ╋
    ╋H╋CMJM┫┣W┫┣NDX┫┣W┫┣▶XWH◀┫┣L┫┣W┫┣<BD┫┣>CR┫┣XLQ╋

Action: systematic variation in lexeme

Deuteronomy 5:9 ==> slot 96432 ==> 96453
    ╋TXT╋L╋H╋>RY┫┣L>┫┣▶CXH◀┫┣L┫┣W┫┣L>┫┣<BD┫┣KJ╋
    ╋TXT╋L╋H╋>RY┫┣L>┫┣▶XWH◀┫┣L┫┣W┫┣L>┫┣<BD┫┣KJ╋

Action: systematic variation in lexeme

Deuteronomy 8:19 ==> slot 98341 ==> 98362
    ╋>LHJM╋>XR┫┣W┫┣<BD┫┣W┫┣▶CXH◀┫┣L┫┣<WD┫┣B┫┣H╋JWM╋
    ╋>LHJM╋>XR┫┣W┫┣<BD┫┣W┫┣▶XWH◀┫┣L┫┣<WD┫┣B┫┣H╋JWM╋

Action: systematic variation in lexeme

Deuteronomy 11:16 ==> slot 99903 ==> 99924
    ╋W┫┣<BD┫┣>LHJM╋>XR┫┣W┫┣▶CXH◀┫┣L┫┣W┫┣XRH┫┣>P╋JHWH╋
    ╋W┫┣<BD┫┣>LHJM╋>XR┫┣W┫┣▶XWH◀┫┣L┫┣W┫┣XRH┫┣>P╋JHWH╋

Action: systematic variation in lexeme

Deuteronomy 17:3 ==> slot 102960 ==> 102981
    ╋W┫┣<BD┫┣>LHJM╋>XR┫┣W┫┣▶CXH◀┫┣L┫┣W┫┣L╋H╋CMC╋
    ╋W┫┣<BD┫┣>LHJM╋>XR┫┣W┫┣▶XWH◀┫┣L┫┣W┫┣L╋H╋CMC╋

Action: systematic variation in lexeme

Deuteronomy 26:10 ==> slot 107354 ==> 107375
    ╋L╋PNH╋JHWH┫┣>LHJM┫┣W┫┣▶CXH◀┫┣L╋PNH╋JHWH┫┣>LHJM┫┣W╋
    ╋L╋PNH╋JHWH┫┣>LHJM┫┣W┫┣▶XWH◀┫┣L╋PNH╋JHWH┫┣>LHJM┫┣W╋

Action: systematic variation in lexeme

Deuteronomy 29:25 ==> slot 110064 ==> 110085
    ╋W┫┣<BD┫┣>LHJM╋>XR┫┣W┫┣▶CXH◀┫┣L┫┣>LHJM┫┣>CR┫┣L>┫┣JD<╋
    ╋W┫┣<BD┫┣>LHJM╋>XR┫┣W┫┣▶XWH◀┫┣L┫┣>LHJM┫┣>CR┫┣L>┫┣JD<╋

Action: systematic variation in lexeme

Deuteronomy 30:17 ==> slot 110528 ==> 110549
    ╋L>┫┣CM<┫┣W┫┣NDX┫┣W┫┣▶CXH◀┫┣L╋>LHJM╋>XR┫┣W┫┣<BD╋
    ╋L>┫┣CM<┫┣W┫┣NDX┫┣W┫┣▶XWH◀┫┣L╋>LHJM╋>XR┫┣W┫┣<BD╋

Action: systematic variation in lexeme

Joshua 5:14 ==> slot 115288 ==> 115309
    ╋JHWCW<┫┣>L╋PNH┫┣>RY┫┣W┫┣▶CXH◀┫┣W┫┣>MR┫┣L┫┣MH┫┣>DWN╋
    ╋JHWCW<┫┣>L╋PNH┫┣>RY┫┣W┫┣▶XWH◀┫┣W┫┣>MR┫┣L┫┣MH┫┣>DWN╋

Action: systematic variation in lexeme

Joshua 15:22 ==> slot 121812 ==> 121833
    ╋W╋JGWR┫┣W┫┣QJNH╋W╋▶DJBWN◀╋W╋<D<DH┫┣W┫┣QDC╋W╋
    ╋W╋JGWR┫┣W┫┣QJNH╋W╋▶DJMWNH◀╋W╋<D<DH┫┣W┫┣QDC╋W╋

Action: incidental variation in lexeme

Joshua 15:28 ==> slot 121847 ==> 121868
    ╋W╋BJT_PLV┫┣W┫┣XYR_CW<L╋W╋▶B>R_CB<◀╋W╋BZJWTJH┫┣B<LH╋W╋<JJM╋
    ╋W╋BJT_PLV┫┣W┫┣XYR_CW<L╋W╋▶B>R◀╋CB<╋W╋BZJWTJH┫┣B<LH╋W╋

Action: split on _ into 1 extra slot

Joshua 19:2 ==> slot 123405 ==> 123427
    ╋W┫┣HJH┫┣L┫┣B╋NXLH┫┣▶B>R_CB<◀╋W╋CB<╋W╋MWLDH┫┣W╋
    ╋W┫┣HJH┫┣L┫┣B╋NXLH┫┣▶B>R◀╋CB<╋W╋CB<╋W╋MWLDH╋

Action: split on _ into 1 extra slot

Joshua 19:13 ==> slot 123552 ==> 123575
    ╋MN╋CM┫┣<BR┫┣QDM┫┣MZRX┫┣▶GT_XPR◀┫┣<T_QYJN┫┣W┫┣JY>┫┣RMWN┫┣H╋
    ╋MN╋CM┫┣<BR┫┣QDM┫┣MZRX┫┣▶GT◀╋XPR┫┣<T╋QYJN┫┣W┫┣JY>╋

Action: split on _ into 1 extra slot

Joshua 19:13 ==> slot 123553 ==> 123577
    ╋CM┫┣<BR┫┣QDM┫┣MZRX┫┣GT_XPR┫┣▶<T_QYJN◀┫┣W┫┣JY>┫┣RMWN┫┣H┫┣T>R╋
    ╋CM┫┣<BR┫┣QDM┫┣MZRX┫┣GT┫┣▶<T◀╋QYJN┫┣W┫┣JY>┫┣RMWN┫┣H╋

Action: split on _ into 1 extra slot

Joshua 23:7 ==> slot 126335 ==> 126360
    ╋W┫┣L>┫┣<BD┫┣W┫┣L>┫┣▶CXH◀┫┣L┫┣KJ╋>M┫┣B╋JHWH╋
    ╋W┫┣L>┫┣<BD┫┣W┫┣L>┫┣▶XWH◀┫┣L┫┣KJ╋>M┫┣B╋JHWH╋

Action: systematic variation in lexeme

Joshua 23:16 ==> slot 126577 ==> 126602
    ╋W┫┣<BD┫┣>LHJM╋>XR┫┣W┫┣▶CXH◀┫┣L┫┣W┫┣XRH┫┣>P╋JHWH╋
    ╋W┫┣<BD┫┣>LHJM╋>XR┫┣W┫┣▶XWH◀┫┣L┫┣W┫┣XRH┫┣>P╋JHWH╋

Action: systematic variation in lexeme

Judges 2:12 ==> slot 128424 ==> 128449
    ╋H╋<M┫┣>CR┫┣SBJB┫┣W┫┣▶CXH◀┫┣L┫┣W┫┣K<S┫┣>T╋JHWH╋
    ╋H╋<M┫┣>CR┫┣SBJB┫┣W┫┣▶XWH◀┫┣L┫┣W┫┣K<S┫┣>T╋JHWH╋

Action: systematic variation in lexeme

Judges 2:17 ==> slot 128518 ==> 128543
    ╋ZNH┫┣>XR╋>LHJM╋>XR┫┣W┫┣▶CXH◀┫┣L┫┣SWR┫┣MHR┫┣MN╋H╋
    ╋ZNH┫┣>XR╋>LHJM╋>XR┫┣W┫┣▶XWH◀┫┣L┫┣SWR┫┣MHR┫┣MN╋H╋

Action: systematic variation in lexeme

Judges 2:19 ==> slot 128586 ==> 128611
    ╋>XR┫┣L╋<BD┫┣W┫┣L╋▶CXH◀┫┣L┫┣L>┫┣NPL┫┣MN╋M<LL╋
    ╋>XR┫┣L╋<BD┫┣W┫┣L╋▶XWH◀┫┣L┫┣L>┫┣NPL┫┣MN╋M<LL╋

Action: systematic variation in lexeme

Judges 7:15 ==> slot 131789 ==> 131814
    ╋XLWM╋W╋>T╋CBR┫┣W┫┣▶CXH◀┫┣W┫┣CWB┫┣>L╋MXNH╋JFR>L╋
    ╋XLWM╋W╋>T╋CBR┫┣W┫┣▶XWH◀┫┣W┫┣CWB┫┣>L╋MXNH╋JFR>L╋

Action: systematic variation in lexeme

Judges 20:1 ==> slot 139866 ==> 139891
    ╋L╋MN╋DN╋W╋<D╋▶B>R_CB<◀╋W╋>RY╋H╋GL<D┫┣>L╋
    ╋L╋MN╋DN╋W╋<D╋▶B>R◀╋CB<╋W╋>RY╋H╋GL<D╋

Action: split on _ into 1 extra slot

1_Samuel 1:3 ==> slot 141555 ==> 141581
    ╋<JR┫┣MN╋JWM┫┣JWM┫┣L╋▶CXH◀┫┣W┫┣L╋ZBX┫┣L╋JHWH╋
    ╋<JR┫┣MN╋JWM┫┣JWM┫┣L╋▶XWH◀┫┣W┫┣L╋ZBX┫┣L╋JHWH╋

Action: systematic variation in lexeme

1_Samuel 1:19 ==> slot 141867 ==> 141893
    ╋CKM┫┣B╋H╋BQR┫┣W┫┣▶CXH◀┫┣L╋PNH╋JHWH┫┣W┫┣CWB╋
    ╋CKM┫┣B╋H╋BQR┫┣W┫┣▶XWH◀┫┣L╋PNH╋JHWH┫┣W┫┣CWB╋

Action: systematic variation in lexeme

1_Samuel 1:28 ==> slot 142070 ==> 142096
    ╋HW>┫┣C>L┫┣L╋JHWH┫┣W┫┣▶CXH◀┫┣CM┫┣L╋JHWH┫┣W┫┣PLL╋
    ╋HW>┫┣C>L┫┣L╋JHWH┫┣W┫┣▶XWH◀┫┣CM┫┣L╋JHWH┫┣W┫┣PLL╋

Action: systematic variation in lexeme

1_Samuel 2:36 ==> slot 142808 ==> 142834
    ╋JTR┫┣B╋BJT┫┣BW>┫┣L╋▶CXH◀┫┣L┫┣L╋>GWRH╋KSP╋W╋
    ╋JTR┫┣B╋BJT┫┣BW>┫┣L╋▶XWH◀┫┣L┫┣L╋>GWRH╋KSP╋W╋

Action: systematic variation in lexeme

1_Samuel 3:20 ==> slot 143208 ==> 143234
    ╋JFR>L┫┣MN╋DN╋W╋<D╋▶B>R_CB<◀┫┣KJ┫┣>MN┫┣CMW>L┫┣L╋NBJ>╋
    ╋JFR>L┫┣MN╋DN╋W╋<D╋▶B>R◀╋CB<┫┣KJ┫┣>MN┫┣CMW>L┫┣L╋

Action: split on _ into 1 extra slot

1_Samuel 8:2 ==> slot 145073 ==> 145100
    ╋CM╋MCNH┫┣>BJH┫┣CPV┫┣B╋▶B>R_CB<◀┫┣W┫┣L>┫┣HLK┫┣BN┫┣B╋
    ╋CM╋MCNH┫┣>BJH┫┣CPV┫┣B╋▶B>R◀╋CB<┫┣W┫┣L>┫┣HLK┫┣BN╋

Action: split on _ into 1 extra slot

1_Samuel 9:21 ==> slot 145980 ==> 146008
    ╋C>WL┫┣W┫┣>MR┫┣H┫┣L>┫┣▶BN_JMJNJ◀┫┣>NKJ┫┣MN╋QVN╋CBV╋JFR>L╋
    ╋C>WL┫┣W┫┣>MR┫┣H┫┣L>┫┣▶BN◀╋JMJNJ┫┣>NKJ┫┣MN╋QVN╋CBV╋

Action: split on _ into 1 extra slot

1_Samuel 15:25 ==> slot 150040 ==> 150069
    ╋XV>T┫┣W┫┣CWB┫┣<M┫┣W┫┣▶CXH◀┫┣L╋JHWH┫┣W┫┣>MR┫┣CMW>L╋
    ╋XV>T┫┣W┫┣CWB┫┣<M┫┣W┫┣▶XWH◀┫┣L╋JHWH┫┣W┫┣>MR┫┣CMW>L╋

Action: systematic variation in lexeme

1_Samuel 15:30 ==> slot 150127 ==> 150156
    ╋JFR>L┫┣W┫┣CWB┫┣<M┫┣W┫┣▶CXH◀┫┣L╋JHWH┫┣>LHJM┫┣W┫┣CWB╋
    ╋JFR>L┫┣W┫┣CWB┫┣<M┫┣W┫┣▶XWH◀┫┣L╋JHWH┫┣>LHJM┫┣W┫┣CWB╋

Action: systematic variation in lexeme

1_Samuel 15:31 ==> slot 150137 ==> 150166
    ╋CWB┫┣CMW>L┫┣>XR╋C>WL┫┣W┫┣▶CXH◀┫┣C>WL┫┣L╋JHWH┫┣W┫┣>MR╋
    ╋CWB┫┣CMW>L┫┣>XR╋C>WL┫┣W┫┣▶XWH◀┫┣C>WL┫┣L╋JHWH┫┣W┫┣>MR╋

Action: systematic variation in lexeme

1_Samuel 20:41 ==> slot 154264 ==> 154293
    ╋NPL┫┣L╋>P┫┣>RY┫┣W┫┣▶CXH◀┫┣CLC╋P<M┫┣W┫┣NCQ┫┣>JC╋
    ╋NPL┫┣L╋>P┫┣>RY┫┣W┫┣▶XWH◀┫┣CLC╋P<M┫┣W┫┣NCQ┫┣>JC╋

Action: systematic variation in lexeme

1_Samuel 24:9 ==> slot 156141 ==> 156170
    ╋QDD┫┣DWD┫┣>P┫┣>RY┫┣W┫┣▶CXH◀┫┣W┫┣>MR┫┣DWD┫┣L╋C>WL╋
    ╋QDD┫┣DWD┫┣>P┫┣>RY┫┣W┫┣▶XWH◀┫┣W┫┣>MR┫┣DWD┫┣L╋C>WL╋

Action: systematic variation in lexeme

1_Samuel 25:23 ==> slot 156977 ==> 157006
    ╋>P╋DWD┫┣<L╋PNH┫┣W┫┣▶CXH◀┫┣>RY┫┣W┫┣NPL┫┣<L╋RGL╋
    ╋>P╋DWD┫┣<L╋PNH┫┣W┫┣▶XWH◀┫┣>RY┫┣W┫┣NPL┫┣<L╋RGL╋

Action: systematic variation in lexeme

1_Samuel 25:41 ==> slot 157436 ==> 157465
    ╋L╋>CH┫┣W┫┣QWM┫┣W┫┣▶CXH◀┫┣>P┫┣>RY┫┣W┫┣>MR┫┣HNH╋
    ╋L╋>CH┫┣W┫┣QWM┫┣W┫┣▶XWH◀┫┣>P┫┣>RY┫┣W┫┣>MR┫┣HNH╋

Action: systematic variation in lexeme

1_Samuel 28:14 ==> slot 158789 ==> 158818
    ╋W┫┣QDD┫┣>P┫┣>RY┫┣W┫┣▶CXH◀┫┣W┫┣>MR┫┣CMW>L┫┣>L╋C>WL╋
    ╋W┫┣QDD┫┣>P┫┣>RY┫┣W┫┣▶XWH◀┫┣W┫┣>MR┫┣CMW>L┫┣>L╋C>WL╋

Action: systematic variation in lexeme

2_Samuel 1:2 ==> slot 160475 ==> 160504
    ╋DWD┫┣W┫┣NPL┫┣>RY┫┣W┫┣▶CXH◀┫┣W┫┣>MR┫┣L┫┣DWD┫┣>J╋
    ╋DWD┫┣W┫┣NPL┫┣>RY┫┣W┫┣▶XWH◀┫┣W┫┣>MR┫┣L┫┣DWD┫┣>J╋

Action: systematic variation in lexeme

2_Samuel 3:10 ==> slot 161848 ==> 161877
    ╋JHWDH┫┣MN╋DN╋W╋<D╋▶B>R_CB<◀┫┣W┫┣L>┫┣JKL┫┣<WD┫┣L╋
    ╋JHWDH┫┣MN╋DN╋W╋<D╋▶B>R◀╋CB<┫┣W┫┣L>┫┣JKL┫┣<WD╋

Action: split on _ into 1 extra slot

2_Samuel 9:6 ==> slot 165033 ==> 165063
    ╋W┫┣NPL┫┣<L╋PNH┫┣W┫┣▶CXH◀┫┣W┫┣>MR┫┣DWD┫┣MPJBCT┫┣W╋
    ╋W┫┣NPL┫┣<L╋PNH┫┣W┫┣▶XWH◀┫┣W┫┣>MR┫┣DWD┫┣MPJBCT┫┣W╋

Action: systematic variation in lexeme

2_Samuel 9:8 ==> slot 165073 ==> 165103
    ╋LXM┫┣<L╋CLXN┫┣TMJD┫┣W┫┣▶CXH◀┫┣W┫┣>MR┫┣MH┫┣<BD┫┣KJ╋
    ╋LXM┫┣<L╋CLXN┫┣TMJD┫┣W┫┣▶XWH◀┫┣W┫┣>MR┫┣MH┫┣<BD┫┣KJ╋

Action: systematic variation in lexeme

2_Samuel 12:20 ==> slot 166812 ==> 166842
    ╋W┫┣BW>┫┣BJT╋JHWH┫┣W┫┣▶CXH◀┫┣W┫┣BW>┫┣>L╋BJT┫┣W╋
    ╋W┫┣BW>┫┣BJT╋JHWH┫┣W┫┣▶XWH◀┫┣W┫┣BW>┫┣>L╋BJT┫┣W╋

Action: systematic variation in lexeme

2_Samuel 14:4 ==> slot 168053 ==> 168083
    ╋NPL┫┣<L╋>P┫┣>RY┫┣W┫┣▶CXH◀┫┣W┫┣>MR┫┣JC<┫┣H╋MLK╋
    ╋NPL┫┣<L╋>P┫┣>RY┫┣W┫┣▶XWH◀┫┣W┫┣>MR┫┣JC<┫┣H╋MLK╋

Action: systematic variation in lexeme

2_Samuel 14:22 ==> slot 168532 ==> 168562
    ╋JW>B┫┣>L╋PNH┫┣>RY┫┣W┫┣▶CXH◀┫┣W┫┣BRK┫┣>T╋H╋MLK╋
    ╋JW>B┫┣>L╋PNH┫┣>RY┫┣W┫┣▶XWH◀┫┣W┫┣BRK┫┣>T╋H╋MLK╋

Action: systematic variation in lexeme

2_Samuel 14:33 ==> slot 168816 ==> 168846
    ╋BW>┫┣>L╋H╋MLK┫┣W┫┣▶CXH◀┫┣L┫┣<L╋>P┫┣>RY┫┣L╋
    ╋BW>┫┣>L╋H╋MLK┫┣W┫┣▶XWH◀┫┣L┫┣<L╋>P┫┣>RY┫┣L╋

Action: systematic variation in lexeme

2_Samuel 15:5 ==> slot 168939 ==> 168969
    ╋HJH┫┣B╋QRB┫┣>JC┫┣L╋▶CXH◀┫┣L┫┣W┫┣CLX┫┣>T╋JD╋
    ╋HJH┫┣B╋QRB┫┣>JC┫┣L╋▶XWH◀┫┣L┫┣W┫┣CLX┫┣>T╋JD╋

Action: systematic variation in lexeme

2_Samuel 15:32 ==> slot 169576 ==> 169606
    ╋BW>┫┣<D╋H╋R>C┫┣>CR┫┣▶CXH◀┫┣CM┫┣L╋>LHJM┫┣W┫┣HNH╋
    ╋BW>┫┣<D╋H╋R>C┫┣>CR┫┣▶XWH◀┫┣CM┫┣L╋>LHJM┫┣W┫┣HNH╋

Action: systematic variation in lexeme

2_Samuel 16:4 ==> slot 169812 ==> 169842
    ╋L╋MPJBCT┫┣W┫┣>MR┫┣YJB>┫┣▶CXH◀┫┣MY>┫┣XN┫┣B╋<JN┫┣>DWN╋
    ╋L╋MPJBCT┫┣W┫┣>MR┫┣YJB>┫┣▶XWH◀┫┣MY>┫┣XN┫┣B╋<JN┫┣>DWN╋

Action: systematic variation in lexeme

2_Samuel 17:11 ==> slot 170486 ==> 170516
    ╋JFR>L┫┣MN╋DN╋W╋<D╋▶B>R_CB<◀┫┣K╋H╋XWL┫┣>CR┫┣<L╋
    ╋JFR>L┫┣MN╋DN╋W╋<D╋▶B>R◀╋CB<┫┣K╋H╋XWL┫┣>CR╋

Action: split on _ into 1 extra slot

2_Samuel 18:21 ==> slot 171572 ==> 171603
    ╋H╋MLK┫┣>CR┫┣R>H┫┣W┫┣▶CXH◀┫┣KCJ┫┣L╋JW>B┫┣W┫┣RWY╋
    ╋H╋MLK┫┣>CR┫┣R>H┫┣W┫┣▶XWH◀┫┣KCJ┫┣L╋JW>B┫┣W┫┣RWY╋

Action: systematic variation in lexeme

2_Samuel 18:28 ==> slot 171749 ==> 171780
    ╋>L╋H╋MLK┫┣CLWM┫┣W┫┣▶CXH◀┫┣L╋H╋MLK┫┣L╋>P╋
    ╋>L╋H╋MLK┫┣CLWM┫┣W┫┣▶XWH◀┫┣L╋H╋MLK┫┣L╋>P╋

Action: systematic variation in lexeme

2_Samuel 22:27 ==> slot 174515 ==> 174546
    ╋GBWR╋TMJM┫┣TMM┫┣<M╋BRR┫┣▶BRR◀┫┣W┫┣<M╋<QC┫┣TPL┫┣W╋
    ╋GBWR╋TMJM┫┣TMM┫┣<M╋BRR┫┣▶TBR◀┫┣W┫┣<M╋<QC┫┣TPL┫┣W╋

Action: incidental variation in lexeme

2_Samuel 24:2 ==> slot 175416 ==> 175447
    ╋JFR>L┫┣MN╋DN╋W╋<D╋▶B>R_CB<◀┫┣W┫┣PQD┫┣>T╋H╋<M╋
    ╋JFR>L┫┣MN╋DN╋W╋<D╋▶B>R◀╋CB<┫┣W┫┣PQD┫┣>T╋H╋

Action: split on _ into 1 extra slot

2_Samuel 24:6 ==> slot 175525 ==> 175557
    ╋>L╋>RY╋TXTJM_XDCJ┫┣W┫┣BW>┫┣▶DN_J<N◀┫┣W┫┣SBJB┫┣>L╋YJDWN┫┣W╋
    ╋>L╋>RY╋TXTJM_XDCJ┫┣W┫┣BW>┫┣▶DN◀╋J<N┫┣W┫┣SBJB┫┣>L╋YJDWN╋

Action: split on _ into 1 extra slot

2_Samuel 24:7 ==> slot 175547 ==> 175580
    ╋W┫┣JY>┫┣>L╋NGB╋JHWDH┫┣▶B>R_CB<◀┫┣W┫┣CWV┫┣B╋KL╋H╋
    ╋W┫┣JY>┫┣>L╋NGB╋JHWDH┫┣▶B>R◀╋CB<┫┣W┫┣CWV┫┣B╋KL╋

Action: split on _ into 1 extra slot

2_Samuel 24:15 ==> slot 175749 ==> 175783
    ╋<M┫┣MN╋DN╋W╋<D╋▶B>R_CB<◀┫┣CB<╋>LP╋>JC┫┣W┫┣CLX╋
    ╋<M┫┣MN╋DN╋W╋<D╋▶B>R◀╋CB<┫┣CB<╋>LP╋>JC┫┣W╋

Action: split on _ into 1 extra slot

2_Samuel 24:20 ==> slot 175878 ==> 175913
    ╋<L┫┣W┫┣JY>┫┣>RWNH┫┣W┫┣▶CXH◀┫┣L╋H╋MLK┫┣>P┫┣>RY╋
    ╋<L┫┣W┫┣JY>┫┣>RWNH┫┣W┫┣▶XWH◀┫┣L╋H╋MLK┫┣>P┫┣>RY╋

Action: systematic variation in lexeme

1_Kings 1:16 ==> slot 176360 ==> 176395
    ╋MLK┫┣W┫┣QDD┫┣BT_CB<┫┣W┫┣▶CXH◀┫┣L╋H╋MLK┫┣W┫┣>MR╋
    ╋MLK┫┣W┫┣QDD┫┣BT_CB<┫┣W┫┣▶XWH◀┫┣L╋H╋MLK┫┣W┫┣>MR╋

Action: systematic variation in lexeme

1_Kings 1:23 ==> slot 176502 ==> 176537
    ╋L╋PNH╋H╋MLK┫┣W┫┣▶CXH◀┫┣L╋H╋MLK┫┣<L╋>P╋
    ╋L╋PNH╋H╋MLK┫┣W┫┣▶XWH◀┫┣L╋H╋MLK┫┣<L╋>P╋

Action: systematic variation in lexeme

1_Kings 1:31 ==> slot 176685 ==> 176720
    ╋QDD┫┣BT_CB<┫┣>P┫┣>RY┫┣W┫┣▶CXH◀┫┣L╋H╋MLK┫┣W┫┣>MR╋
    ╋QDD┫┣BT_CB<┫┣>P┫┣>RY┫┣W┫┣▶XWH◀┫┣L╋H╋MLK┫┣W┫┣>MR╋

Action: systematic variation in lexeme

1_Kings 1:47 ==> slot 177085 ==> 177120
    ╋>T╋KS>┫┣MN╋KS>┫┣W┫┣▶CXH◀┫┣H╋MLK┫┣<L╋H╋MCKB╋
    ╋>T╋KS>┫┣MN╋KS>┫┣W┫┣▶XWH◀┫┣H╋MLK┫┣<L╋H╋MCKB╋

Action: systematic variation in lexeme

1_Kings 1:53 ==> slot 177213 ==> 177248
    ╋H╋MZBX┫┣W┫┣BW>┫┣W┫┣▶CXH◀┫┣L╋H╋MLK┫┣CLMH┫┣W╋
    ╋H╋MZBX┫┣W┫┣BW>┫┣W┫┣▶XWH◀┫┣L╋H╋MLK┫┣CLMH┫┣W╋

Action: systematic variation in lexeme

1_Kings 2:19 ==> slot 177635 ==> 177670
    ╋H╋MLK┫┣L╋QR>┫┣W┫┣▶CXH◀┫┣L┫┣W┫┣JCB┫┣<L╋KS>╋
    ╋H╋MLK┫┣L╋QR>┫┣W┫┣▶XWH◀┫┣L┫┣W┫┣JCB┫┣<L╋KS>╋

Action: systematic variation in lexeme

1_Kings 5:5 ==> slot 179399 ==> 179434
    ╋T>NH┫┣MN╋DN╋W╋<D╋▶B>R_CB<◀┫┣KL╋JWM╋CLMH┫┣W┫┣HJH╋
    ╋T>NH┫┣MN╋DN╋W╋<D╋▶B>R◀╋CB<┫┣KL╋JWM╋CLMH┫┣W╋

Action: split on _ into 1 extra slot

1_Kings 9:6 ==> slot 183762 ==> 183798
    ╋W┫┣<BD┫┣>LHJM╋>XR┫┣W┫┣▶CXH◀┫┣L┫┣W┫┣KRT┫┣>T╋JFR>L╋
    ╋W┫┣<BD┫┣>LHJM╋>XR┫┣W┫┣▶XWH◀┫┣L┫┣W┫┣KRT┫┣>T╋JFR>L╋

Action: systematic variation in lexeme

1_Kings 9:9 ==> slot 183852 ==> 183888
    ╋XZQ┫┣B╋>LHJM╋>XR┫┣W┫┣▶CXH◀┫┣L┫┣W┫┣<BD┫┣<L╋KN╋
    ╋XZQ┫┣B╋>LHJM╋>XR┫┣W┫┣▶XWH◀┫┣L┫┣W┫┣<BD┫┣<L╋KN╋

Action: systematic variation in lexeme

1_Kings 11:33 ==> slot 185644 ==> 185680
    ╋JFR>L┫┣J<N╋>CR┫┣<ZB┫┣W┫┣▶CXH◀┫┣L╋<CTRT┫┣>LHJM╋YJDNJ┫┣L╋
    ╋JFR>L┫┣J<N╋>CR┫┣<ZB┫┣W┫┣▶XWH◀┫┣L╋<CTRT┫┣>LHJM╋YJDNJ┫┣L╋

Action: systematic variation in lexeme

1_Kings 16:31 ==> slot 189693 ==> 189729
    ╋<BD┫┣>T╋H╋B<L┫┣W┫┣▶CXH◀┫┣L┫┣W┫┣QWM┫┣MZBX┫┣L╋
    ╋<BD┫┣>T╋H╋B<L┫┣W┫┣▶XWH◀┫┣L┫┣W┫┣QWM┫┣MZBX┫┣L╋

Action: systematic variation in lexeme

1_Kings 19:3 ==> slot 191400 ==> 191436
    ╋HLK┫┣>L╋NPC┫┣W┫┣BW>┫┣▶B>R_CB<◀┫┣>CR┫┣L╋JHWDH┫┣W┫┣NWX╋
    ╋HLK┫┣>L╋NPC┫┣W┫┣BW>┫┣▶B>R◀╋CB<┫┣>CR┫┣L╋JHWDH┫┣W╋

Action: split on _ into 1 extra slot

1_Kings 22:54 ==> slot 194696 ==> 194733
    ╋<BD┫┣>T╋H╋B<L┫┣W┫┣▶CXH◀┫┣L┫┣W┫┣K<S┫┣>T╋JHWH╋
    ╋<BD┫┣>T╋H╋B<L┫┣W┫┣▶XWH◀┫┣L┫┣W┫┣K<S┫┣>T╋JHWH╋

Action: systematic variation in lexeme

2_Kings 2:15 ==> slot 195567 ==> 195604
    ╋W┫┣BW>┫┣L╋QR>┫┣W┫┣▶CXH◀┫┣L┫┣>RY┫┣W┫┣>MR┫┣>L╋
    ╋W┫┣BW>┫┣L╋QR>┫┣W┫┣▶XWH◀┫┣L┫┣>RY┫┣W┫┣>MR┫┣>L╋

Action: systematic variation in lexeme

2_Kings 4:37 ==> slot 197205 ==> 197242
    ╋W┫┣NPL┫┣<L╋RGL┫┣W┫┣▶CXH◀┫┣>RY┫┣W┫┣NF>┫┣>T╋BN╋
    ╋W┫┣NPL┫┣<L╋RGL┫┣W┫┣▶XWH◀┫┣>RY┫┣W┫┣NF>┫┣>T╋BN╋

Action: systematic variation in lexeme

2_Kings 5:18 ==> slot 197853 ==> 197890
    ╋BW>┫┣>DWN┫┣BJT╋RMWN┫┣L╋▶CXH◀┫┣CM┫┣W┫┣HW>┫┣C<N┫┣<L╋
    ╋BW>┫┣>DWN┫┣BJT╋RMWN┫┣L╋▶XWH◀┫┣CM┫┣W┫┣HW>┫┣C<N┫┣<L╋

Action: systematic variation in lexeme

2_Kings 5:18 ==> slot 197861 ==> 197898
    ╋HW>┫┣C<N┫┣<L╋JD┫┣W┫┣▶CXH◀┫┣BJT╋RMWN┫┣B╋CXH┫┣BJT╋
    ╋HW>┫┣C<N┫┣<L╋JD┫┣W┫┣▶XWH◀┫┣BJT╋RMWN┫┣B╋XWH┫┣BJT╋

Action: systematic variation in lexeme

2_Kings 5:18 ==> slot 197865 ==> 197902
    ╋W┫┣CXH┫┣BJT╋RMWN┫┣B╋▶CXH◀┫┣BJT╋RMWN┫┣SLX┫┣JHWH┫┣L╋
    ╋W┫┣XWH┫┣BJT╋RMWN┫┣B╋▶XWH◀┫┣BJT╋RMWN┫┣SLX┫┣JHWH┫┣L╋

Action: systematic variation in lexeme

2_Kings 10:2 ==> slot 201089 ==> 201126
    ╋>X>B┫┣L╋>MR┫┣W┫┣<TH┫┣▶B◀╋BW>┫┣H╋SPR╋H╋ZH╋
    ╋>X>B┫┣L╋>MR┫┣W┫┣<TH┫┣▶K◀╋BW>┫┣H╋SPR╋H╋ZH╋

Action: incidental variation in lexeme

2_Kings 12:2 ==> slot 202531 ==> 202568
    ╋W┫┣CM╋>M┫┣YBJH┫┣MN╋▶B>R_CB<◀┫┣W┫┣<FH┫┣JHW>C┫┣H┫┣JCR╋
    ╋W┫┣CM╋>M┫┣YBJH┫┣MN╋▶B>R◀╋CB<┫┣W┫┣<FH┫┣JHW>C┫┣H╋

Action: split on _ into 1 extra slot

2_Kings 17:16 ==> slot 205873 ==> 205911
    ╋<GL┫┣W┫┣<FH┫┣>CRH┫┣W┫┣▶CXH◀┫┣L╋KL╋YB>╋H╋CMJM╋
    ╋<GL┫┣W┫┣<FH┫┣>CRH┫┣W┫┣▶XWH◀┫┣L╋KL╋YB>╋H╋CMJM╋

Action: systematic variation in lexeme

2_Kings 17:35 ==> slot 206336 ==> 206374
    ╋JR>┫┣>LHJM╋>XR┫┣W┫┣L>┫┣▶CXH◀┫┣L┫┣W┫┣L>┫┣<BD┫┣W╋
    ╋JR>┫┣>LHJM╋>XR┫┣W┫┣L>┫┣▶XWH◀┫┣L┫┣W┫┣L>┫┣<BD┫┣W╋

Action: systematic variation in lexeme

2_Kings 17:36 ==> slot 206366 ==> 206404
    ╋NVH┫┣>T┫┣JR>┫┣W┫┣L┫┣▶CXH◀┫┣W┫┣L┫┣ZBX┫┣W┫┣>T╋
    ╋NVH┫┣>T┫┣JR>┫┣W┫┣L┫┣▶XWH◀┫┣W┫┣L┫┣ZBX┫┣W┫┣>T╋

Action: systematic variation in lexeme

2_Kings 18:22 ==> slot 206992 ==> 207030
    ╋PNH╋H╋MZBX╋H╋ZH┫┣▶CXH◀┫┣B╋JRWCLM┫┣W┫┣<TH┫┣<RB╋
    ╋PNH╋H╋MZBX╋H╋ZH┫┣▶XWH◀┫┣B╋JRWCLM┫┣W┫┣<TH┫┣<RB╋

Action: systematic variation in lexeme

2_Kings 19:37 ==> slot 208105 ==> 208143
    ╋B╋NJNWH┫┣W┫┣HJH┫┣HW>┫┣▶CXH◀┫┣BJT╋NSRK┫┣>LHJM┫┣W┫┣>DRMLK╋
    ╋B╋NJNWH┫┣W┫┣HJH┫┣HW>┫┣▶XWH◀┫┣BJT╋NSRK┫┣>LHJM┫┣W┫┣>DRMLK╋

Action: systematic variation in lexeme

2_Kings 21:3 ==> slot 208684 ==> 208722
    ╋<FH┫┣>X>B┫┣MLK╋JFR>L┫┣W┫┣▶CXH◀┫┣L╋KL╋YB>╋H╋CMJM╋
    ╋<FH┫┣>X>B┫┣MLK╋JFR>L┫┣W┫┣▶XWH◀┫┣L╋KL╋YB>╋H╋CMJM╋

Action: systematic variation in lexeme

2_Kings 21:21 ==> slot 209093 ==> 209131
    ╋GLWLJM┫┣>CR┫┣<BD┫┣>B┫┣W┫┣▶CXH◀┫┣L┫┣W┫┣<ZB┫┣>T╋JHWH╋
    ╋GLWLJM┫┣>CR┫┣<BD┫┣>B┫┣W┫┣▶XWH◀┫┣L┫┣W┫┣<ZB┫┣>T╋JHWH╋

Action: systematic variation in lexeme

2_Kings 23:8 ==> slot 210002 ==> 210040
    ╋H╋KHN┫┣MN╋GB<┫┣<D╋▶B>R_CB<◀┫┣W┫┣NTY┫┣>T╋BMH╋H╋
    ╋H╋KHN┫┣MN╋GB<┫┣<D╋▶B>R◀╋CB<┫┣W┫┣NTY┫┣>T╋BMH╋

Action: split on _ into 1 extra slot

Isaiah 2:8 ==> slot 212626 ==> 212665
    ╋>RY┫┣>LJL┫┣L╋M<FH╋JD┫┣▶CXH◀┫┣L╋>CR┫┣<FH┫┣>YB<┫┣W╋
    ╋>RY┫┣>LJL┫┣L╋M<FH╋JD┫┣▶XWH◀┫┣L╋>CR┫┣<FH┫┣>YB<┫┣W╋

Action: systematic variation in lexeme

Isaiah 2:20 ==> slot 212810 ==> 212849
    ╋ZHB┫┣>CR┫┣<FH┫┣L┫┣L╋▶CXH◀┫┣L╋XPR┫┣PRWT╋W╋L╋
    ╋ZHB┫┣>CR┫┣<FH┫┣L┫┣L╋▶XWH◀┫┣L╋XPR┫┣PRWT╋W╋L╋

Action: systematic variation in lexeme

Isaiah 19:18 ==> slot 218383 ==> 218422
    ╋W┫┣CB<┫┣L╋JHWH╋YB>┫┣▶<JR_HHRS◀┫┣>MR┫┣L╋>XD┫┣B╋H╋
    ╋W┫┣CB<┫┣L╋JHWH╋YB>┫┣▶<JR◀╋H╋HRS┫┣>MR┫┣L╋>XD╋

Action: split into 2 extra slots

Isaiah 27:13 ==> slot 220739 ==> 220780
    ╋NDX┫┣B╋>RY╋MYRJM┫┣W┫┣▶CXH◀┫┣L╋JHWH┫┣B╋HR╋H╋
    ╋NDX┫┣B╋>RY╋MYRJM┫┣W┫┣▶XWH◀┫┣L╋JHWH┫┣B╋HR╋H╋

Action: systematic variation in lexeme

Isaiah 29:9 ==> slot 221436 ==> 221477
    ╋H┫┣YB>┫┣<L╋HR╋YJWN┫┣▶TMH◀┫┣W┫┣TMH┫┣C<<┫┣W┫┣C<<╋
    ╋H┫┣YB>┫┣<L╋HR╋YJWN┫┣▶MHH◀┫┣W┫┣TMH┫┣C<<┫┣W┫┣C<<╋

Action: incidental variation in lexeme

Isaiah 36:7 ==> slot 223853 ==> 223894
    ╋PNH╋H╋MZBX╋H╋ZH┫┣▶CXH◀┫┣W┫┣<TH┫┣<RB┫┣N>┫┣>T╋
    ╋PNH╋H╋MZBX╋H╋ZH┫┣▶XWH◀┫┣W┫┣<TH┫┣<RB┫┣N>┫┣>T╋

Action: systematic variation in lexeme

Isaiah 37:38 ==> slot 224931 ==> 224972
    ╋B╋NJNWH┫┣W┫┣HJH┫┣HW>┫┣▶CXH◀┫┣BJT╋NSRK┫┣>LHJM┫┣W┫┣>DRMLK╋
    ╋B╋NJNWH┫┣W┫┣HJH┫┣HW>┫┣▶XWH◀┫┣BJT╋NSRK┫┣>LHJM┫┣W┫┣>DRMLK╋

Action: systematic variation in lexeme

Isaiah 44:15 ==> slot 227568 ==> 227609
    ╋LXM┫┣>P┫┣P<L┫┣>L┫┣W┫┣▶CXH◀┫┣<FH┫┣PSL┫┣W┫┣SGD┫┣L╋
    ╋LXM┫┣>P┫┣P<L┫┣>L┫┣W┫┣▶XWH◀┫┣<FH┫┣PSL┫┣W┫┣SGD┫┣L╋

Action: systematic variation in lexeme

Isaiah 44:17 ==> slot 227604 ==> 227645
    ╋L╋PSL┫┣SGD┫┣L┫┣W┫┣▶CXH◀┫┣W┫┣PLL┫┣>L┫┣W┫┣>MR╋
    ╋L╋PSL┫┣SGD┫┣L┫┣W┫┣▶XWH◀┫┣W┫┣PLL┫┣>L┫┣W┫┣>MR╋

Action: systematic variation in lexeme

Isaiah 45:14 ==> slot 228066 ==> 228107
    ╋H╋ZQJM┫┣<BR┫┣W┫┣>L┫┣▶CXH◀┫┣>L┫┣PLL┫┣>K┫┣B┫┣>L╋
    ╋H╋ZQJM┫┣<BR┫┣W┫┣>L┫┣▶XWH◀┫┣>L┫┣PLL┫┣>K┫┣B┫┣>L╋

Action: systematic variation in lexeme

Isaiah 46:6 ==> slot 228361 ==> 228402
    ╋W┫┣<FH┫┣>L┫┣SGD┫┣>P┫┣▶CXH◀┫┣NF>┫┣<L╋KTP┫┣SBL┫┣W╋
    ╋W┫┣<FH┫┣>L┫┣SGD┫┣>P┫┣▶XWH◀┫┣NF>┫┣<L╋KTP┫┣SBL┫┣W╋

Action: systematic variation in lexeme

Isaiah 49:7 ==> slot 229225 ==> 229266
    ╋R>H┫┣W┫┣QWM┫┣FR┫┣W┫┣▶CXH◀┫┣LM<N╋JHWH┫┣>CR┫┣>MN┫┣QDWC╋
    ╋R>H┫┣W┫┣QWM┫┣FR┫┣W┫┣▶XWH◀┫┣LM<N╋JHWH┫┣>CR┫┣>MN┫┣QDWC╋

Action: systematic variation in lexeme

Isaiah 49:23 ==> slot 229494 ==> 229535
    ╋W┫┣FRH┫┣MJNQT┫┣>P┫┣>RY┫┣▶CXH◀┫┣L┫┣W┫┣<PR╋RGL┫┣LXK╋
    ╋W┫┣FRH┫┣MJNQT┫┣>P┫┣>RY┫┣▶XWH◀┫┣L┫┣W┫┣<PR╋RGL┫┣LXK╋

Action: systematic variation in lexeme

Isaiah 60:14 ==> slot 232790 ==> 232831
    ╋>L┫┣CXX┫┣BN╋<NH┫┣W┫┣▶CXH◀┫┣<L╋KP╋RGL┫┣KL╋N>Y╋
    ╋>L┫┣CXX┫┣BN╋<NH┫┣W┫┣▶XWH◀┫┣<L╋KP╋RGL┫┣KL╋N>Y╋

Action: systematic variation in lexeme

Isaiah 66:23 ==> slot 234914 ==> 234955
    ╋CBT┫┣BW>┫┣KL╋BFR┫┣L╋▶CXH◀┫┣L╋PNH┫┣>MR┫┣JHWH┫┣W╋
    ╋CBT┫┣BW>┫┣KL╋BFR┫┣L╋▶XWH◀┫┣L╋PNH┫┣>MR┫┣JHWH┫┣W╋

Action: systematic variation in lexeme

Jeremiah 1:16 ==> slot 235230 ==> 235271
    ╋QVR┫┣L╋>LHJM╋>XR┫┣W┫┣▶CXH◀┫┣L╋M<FH╋JD┫┣W┫┣>TH╋
    ╋QVR┫┣L╋>LHJM╋>XR┫┣W┫┣▶XWH◀┫┣L╋M<FH╋JD┫┣W┫┣>TH╋

Action: systematic variation in lexeme

Jeremiah 7:2 ==> slot 238176 ==> 238217
    ╋H╋C<R╋H╋>LH┫┣L╋▶CXH◀┫┣L╋JHWH┫┣KH┫┣>MR┫┣JHWH╋
    ╋H╋C<R╋H╋>LH┫┣L╋▶XWH◀┫┣L╋JHWH┫┣KH┫┣>MR┫┣JHWH╋

Action: systematic variation in lexeme

Jeremiah 8:2 ==> slot 238952 ==> 238993
    ╋W┫┣>CR┫┣DRC┫┣W┫┣>CR┫┣▶CXH◀┫┣L┫┣L>┫┣>SP┫┣W┫┣L>╋
    ╋W┫┣>CR┫┣DRC┫┣W┫┣>CR┫┣▶XWH◀┫┣L┫┣L>┫┣>SP┫┣W┫┣L>╋

Action: systematic variation in lexeme

Jeremiah 13:10 ==> slot 241282 ==> 241323
    ╋>XR┫┣L╋<BD┫┣W┫┣L╋▶CXH◀┫┣L┫┣W┫┣HJH┫┣K╋H╋
    ╋>XR┫┣L╋<BD┫┣W┫┣L╋▶XWH◀┫┣L┫┣W┫┣HJH┫┣K╋H╋

Action: systematic variation in lexeme

Jeremiah 16:11 ==> slot 242826 ==> 242867
    ╋>LHJM╋>XR┫┣W┫┣<BD┫┣W┫┣▶CXH◀┫┣L┫┣W┫┣>T┫┣<ZB┫┣W╋
    ╋>LHJM╋>XR┫┣W┫┣<BD┫┣W┫┣▶XWH◀┫┣L┫┣W┫┣>T┫┣<ZB┫┣W╋

Action: systematic variation in lexeme

Jeremiah 22:9 ==> slot 245440 ==> 245481
    ╋>T╋BRJT╋JHWH┫┣>LHJM┫┣W┫┣▶CXH◀┫┣L╋>LHJM╋>XR┫┣W┫┣<BD╋
    ╋>T╋BRJT╋JHWH┫┣>LHJM┫┣W┫┣▶XWH◀┫┣L╋>LHJM╋>XR┫┣W┫┣<BD╋

Action: systematic variation in lexeme

Jeremiah 25:6 ==> slot 247079 ==> 247120
    ╋>XR┫┣L╋<BD┫┣W┫┣L╋▶CXH◀┫┣L┫┣W┫┣L>┫┣K<S┫┣>T╋
    ╋>XR┫┣L╋<BD┫┣W┫┣L╋▶XWH◀┫┣L┫┣W┫┣L>┫┣K<S┫┣>T╋

Action: systematic variation in lexeme

Jeremiah 25:34 ==> slot 247730 ==> 247771
    ╋ML>┫┣JWM┫┣L╋VBX┫┣W┫┣▶TPWYH◀┫┣W┫┣NPL┫┣K╋KLJ╋XMDH╋
    ╋ML>┫┣JWM┫┣L╋VBX┫┣W┫┣▶PWY◀┫┣W┫┣NPL┫┣K╋KLJ╋XMDH╋

Action: incidental variation in lexeme

Jeremiah 26:2 ==> slot 247827 ==> 247868
    ╋<JR╋JHWDH┫┣H┫┣BW>┫┣L╋▶CXH◀┫┣BJT╋JHWH┫┣>T╋KL╋H╋
    ╋<JR╋JHWDH┫┣H┫┣BW>┫┣L╋▶XWH◀┫┣BJT╋JHWH┫┣>T╋KL╋H╋

Action: systematic variation in lexeme

Ezekiel 8:16 ==> slot 267952 ==> 267993
    ╋W┫┣PNH┫┣QDM┫┣W┫┣HMH┫┣▶CXH◀┫┣QDM┫┣L╋H╋CMC┫┣W╋
    ╋W┫┣PNH┫┣QDM┫┣W┫┣HMH┫┣▶XWH◀┫┣QDM┫┣L╋H╋CMC┫┣W╋

Action: systematic variation in lexeme

Ezekiel 18:14 ==> slot 272883 ==> 272924
    ╋W┫┣R>H┫┣W┫┣L>┫┣<FH┫┣▶K◀╋HN┫┣<L╋H╋HR┫┣L>╋
    ╋W┫┣R>H┫┣W┫┣L>┫┣<FH┫┣▶K◀┫┣<L╋H╋HR┫┣L>┫┣>KL╋

Action: collapse 1 fewer slot

Ezekiel 46:2 ==> slot 289063 ==> 289103
    ╋<LH╋W╋>T╋CLM┫┣W┫┣▶CXH◀┫┣<L╋MPTN╋H╋C<R┫┣W╋
    ╋<LH╋W╋>T╋CLM┫┣W┫┣▶XWH◀┫┣<L╋MPTN╋H╋C<R┫┣W╋

Action: systematic variation in lexeme

Ezekiel 46:3 ==> slot 289079 ==> 289119
    ╋SGR┫┣<D╋H╋<RB┫┣W┫┣▶CXH◀┫┣<M╋H╋>RY┫┣PTX╋H╋
    ╋SGR┫┣<D╋H╋<RB┫┣W┫┣▶XWH◀┫┣<M╋H╋>RY┫┣PTX╋H╋

Action: systematic variation in lexeme

Ezekiel 46:9 ==> slot 289210 ==> 289250
    ╋BW>┫┣DRK╋C<R╋YPWN┫┣L╋▶CXH◀┫┣JY>┫┣DRK╋C<R╋NGB┫┣W╋
    ╋BW>┫┣DRK╋C<R╋YPWN┫┣L╋▶XWH◀┫┣JY>┫┣DRK╋C<R╋NGB┫┣W╋

Action: systematic variation in lexeme

Amos 5:5 ==> slot 296522 ==> 296562
    ╋H╋GLGL┫┣L>┫┣BW>┫┣W┫┣▶B>R_CB<◀┫┣L>┫┣<BR┫┣KJ┫┣H╋GLGL╋
    ╋H╋GLGL┫┣L>┫┣BW>┫┣W┫┣▶B>R◀╋CB<┫┣L>┫┣<BR┫┣KJ┫┣H╋

Action: split on _ into 1 extra slot

Amos 8:14 ==> slot 297728 ==> 297769
    ╋>LHJM┫┣DN┫┣W┫┣XJ┫┣DRK╋▶B>R_CB<◀┫┣W┫┣NPL┫┣W┫┣L>┫┣QWM╋
    ╋>LHJM┫┣DN┫┣W┫┣XJ┫┣DRK╋▶B>R◀╋CB<┫┣W┫┣NPL┫┣W┫┣L>╋

Action: split on _ into 1 extra slot

Micah 5:12 ==> slot 300758 ==> 300800
    ╋MYBH┫┣MN╋QRB┫┣W┫┣L>┫┣▶CXH◀┫┣<WD┫┣L╋M<FH╋JD┫┣W╋
    ╋MYBH┫┣MN╋QRB┫┣W┫┣L>┫┣▶XWH◀┫┣<WD┫┣L╋M<FH╋JD┫┣W╋

Action: systematic variation in lexeme

Zephaniah 1:5 ==> slot 303109 ==> 303151
    ╋H╋KHN┫┣W┫┣>T┫┣H┫┣▶CXH◀┫┣<L╋H╋GG┫┣L╋YB>╋
    ╋H╋KHN┫┣W┫┣>T╋H┫┣▶XWH◀┫┣<L╋H╋GG┫┣L╋YB>╋

Action: systematic variation in lexeme

Zephaniah 1:5 ==> slot 303120 ==> 303162
    ╋H╋CMJM┫┣W┫┣>T┫┣H┫┣▶CXH◀┫┣H┫┣CB<┫┣L╋JHWH┫┣W╋
    ╋H╋CMJM┫┣W┫┣>T╋H┫┣▶XWH◀┫┣H┫┣CB<┫┣L╋JHWH┫┣W╋

Action: systematic variation in lexeme

Zephaniah 2:11 ==> slot 303598 ==> 303640
    ╋KL╋>LHJM╋H╋>RY┫┣W┫┣▶CXH◀┫┣L┫┣>JC┫┣MN╋MQWM┫┣KL╋
    ╋KL╋>LHJM╋H╋>RY┫┣W┫┣▶XWH◀┫┣L┫┣>JC┫┣MN╋MQWM┫┣KL╋

Action: systematic variation in lexeme

Zechariah 14:16 ==> slot 309251 ==> 309293
    ╋DJ╋CNH┫┣B╋CNH┫┣L╋▶CXH◀┫┣L╋MLK┫┣JHWH╋YB>┫┣W╋
    ╋DJ╋CNH┫┣B╋CNH┫┣L╋▶XWH◀┫┣L╋MLK┫┣JHWH╋YB>┫┣W╋

Action: systematic variation in lexeme

Zechariah 14:17 ==> slot 309276 ==> 309318
    ╋H╋>RY┫┣>L╋JRWCLM┫┣L╋▶CXH◀┫┣L╋MLK┫┣JHWH╋YB>┫┣W╋
    ╋H╋>RY┫┣>L╋JRWCLM┫┣L╋▶XWH◀┫┣L╋MLK┫┣JHWH╋YB>┫┣W╋

Action: systematic variation in lexeme

Psalms 5:8 ==> slot 311040 ==> 311082
    ╋B╋RB╋XSD┫┣BW>┫┣BJT┫┣▶CXH◀┫┣>L╋HJKL╋QDC┫┣B╋JR>H╋
    ╋B╋RB╋XSD┫┣BW>┫┣BJT┫┣▶XWH◀┫┣>L╋HJKL╋QDC┫┣B╋JR>H╋

Action: systematic variation in lexeme

Psalms 7:1 ==> slot 311219 ==> 311261
    ╋L╋JHWH┫┣<L╋DBR╋KWC┫┣▶BN_JMJNJ◀┫┣JHWH┫┣>LHJM┫┣B┫┣XSH┫┣JC<╋
    ╋L╋JHWH┫┣<L╋DBR╋KWC┫┣▶BN◀╋JMJNJ┫┣JHWH┫┣>LHJM┫┣B┫┣XSH╋

Action: split on _ into 1 extra slot

Psalms 22:28 ==> slot 313781 ==> 313824
    ╋JHWH┫┣KL╋>PS╋>RY┫┣W┫┣▶CXH◀┫┣L╋PNH┫┣KL╋MCPXH╋GWJ╋
    ╋JHWH┫┣KL╋>PS╋>RY┫┣W┫┣▶XWH◀┫┣L╋PNH┫┣KL╋MCPXH╋GWJ╋

Action: systematic variation in lexeme

Psalms 22:30 ==> slot 313799 ==> 313842
    ╋B╋H╋GWJ┫┣>KL┫┣W┫┣▶CXH◀┫┣KL╋DCN╋>RY┫┣L╋PNH╋
    ╋B╋H╋GWJ┫┣>KL┫┣W┫┣▶XWH◀┫┣KL╋DCN╋>RY┫┣L╋PNH╋

Action: systematic variation in lexeme

Psalms 29:2 ==> slot 314650 ==> 314693
    ╋JHB┫┣L╋JHWH┫┣KBWD╋CM┫┣▶CXH◀┫┣L╋JHWH┫┣B╋HDRH╋QDC╋
    ╋JHB┫┣L╋JHWH┫┣KBWD╋CM┫┣▶XWH◀┫┣L╋JHWH┫┣B╋HDRH╋QDC╋

Action: systematic variation in lexeme

Psalms 45:12 ==> slot 317948 ==> 317991
    ╋JPJ┫┣KJ┫┣HW>┫┣>DWN┫┣W┫┣▶CXH◀┫┣L┫┣W┫┣BT╋YR┫┣B╋
    ╋JPJ┫┣KJ┫┣HW>┫┣>DWN┫┣W┫┣▶XWH◀┫┣L┫┣W┫┣BT╋YR┫┣B╋

Action: systematic variation in lexeme

Psalms 66:4 ==> slot 320924 ==> 320967
    ╋L┫┣>JB┫┣KL╋H╋>RY┫┣▶CXH◀┫┣L┫┣W┫┣ZMR┫┣L┫┣ZMR╋
    ╋L┫┣>JB┫┣KL╋H╋>RY┫┣▶XWH◀┫┣L┫┣W┫┣ZMR┫┣L┫┣ZMR╋

Action: systematic variation in lexeme

Psalms 72:11 ==> slot 322344 ==> 322387
    ╋W╋SB>┫┣>CKR┫┣QRB┫┣W┫┣▶CXH◀┫┣L┫┣KL╋MLK┫┣KL╋GWJ╋
    ╋W╋SB>┫┣>CKR┫┣QRB┫┣W┫┣▶XWH◀┫┣L┫┣KL╋MLK┫┣KL╋GWJ╋

Action: systematic variation in lexeme

Psalms 81:10 ==> slot 324624 ==> 324667
    ╋B┫┣>L╋ZR┫┣W┫┣L>┫┣▶CXH◀┫┣L╋>L╋NKR┫┣>NKJ┫┣JHWH╋
    ╋B┫┣>L╋ZR┫┣W┫┣L>┫┣▶XWH◀┫┣L╋>L╋NKR┫┣>NKJ┫┣JHWH╋

Action: systematic variation in lexeme

Psalms 86:9 ==> slot 325294 ==> 325337
    ╋GWJ┫┣>CR┫┣<FH┫┣BW>┫┣W┫┣▶CXH◀┫┣L╋PNH┫┣>DNJ┫┣W┫┣KBD╋
    ╋GWJ┫┣>CR┫┣<FH┫┣BW>┫┣W┫┣▶XWH◀┫┣L╋PNH┫┣>DNJ┫┣W┫┣KBD╋

Action: systematic variation in lexeme

Psalms 95:6 ==> slot 326949 ==> 326992
    ╋W┫┣JBCT┫┣JD┫┣JYR┫┣BW>┫┣▶CXH◀┫┣W┫┣KR<┫┣BRK┫┣L╋PNH╋
    ╋W┫┣JBCT┫┣JD┫┣JYR┫┣BW>┫┣▶XWH◀┫┣W┫┣KR<┫┣BRK┫┣L╋PNH╋

Action: systematic variation in lexeme

Psalms 96:9 ==> slot 327100 ==> 327143
    ╋MNXH┫┣W┫┣BW>┫┣L╋XYR┫┣▶CXH◀┫┣L╋JHWH┫┣B╋HDRH╋QDC╋
    ╋MNXH┫┣W┫┣BW>┫┣L╋XYR┫┣▶XWH◀┫┣L╋JHWH┫┣B╋HDRH╋QDC╋

Action: systematic variation in lexeme

Psalms 97:7 ==> slot 327237 ==> 327280
    ╋H┫┣HLL┫┣B╋H╋>LJL┫┣▶CXH◀┫┣L┫┣KL╋>LHJM┫┣CM<┫┣W╋
    ╋H┫┣HLL┫┣B╋H╋>LJL┫┣▶XWH◀┫┣L┫┣KL╋>LHJM┫┣CM<┫┣W╋

Action: systematic variation in lexeme

Psalms 99:5 ==> slot 327443 ==> 327486
    ╋<FH┫┣RWM┫┣JHWH┫┣>LHJM┫┣W┫┣▶CXH◀┫┣L╋HDM╋RGL┫┣QDWC┫┣HW>╋
    ╋<FH┫┣RWM┫┣JHWH┫┣>LHJM┫┣W┫┣▶XWH◀┫┣L╋HDM╋RGL┫┣QDWC┫┣HW>╋

Action: systematic variation in lexeme

Psalms 99:9 ==> slot 327492 ==> 327535
    ╋<LJLH┫┣RWM┫┣JHWH┫┣>LHJM┫┣W┫┣▶CXH◀┫┣L╋HR╋QDC┫┣KJ┫┣QDWC╋
    ╋<LJLH┫┣RWM┫┣JHWH┫┣>LHJM┫┣W┫┣▶XWH◀┫┣L╋HR╋QDC┫┣KJ┫┣QDWC╋

Action: systematic variation in lexeme

Psalms 106:19 ==> slot 329085 ==> 329128
    ╋<FH┫┣<GL┫┣B╋XRB┫┣W┫┣▶CXH◀┫┣L╋MSKH┫┣W┫┣MWR┫┣>T╋
    ╋<FH┫┣<GL┫┣B╋XRB┫┣W┫┣▶XWH◀┫┣L╋MSKH┫┣W┫┣MWR┫┣>T╋

Action: systematic variation in lexeme

Psalms 132:7 ==> slot 333437 ==> 333480
    ╋FDH╋J<R┫┣BW>┫┣L╋MCKN┫┣▶CXH◀┫┣L╋HDM╋RGL┫┣QWM┫┣JHWH╋
    ╋FDH╋J<R┫┣BW>┫┣L╋MCKN┫┣▶XWH◀┫┣L╋HDM╋RGL┫┣QWM┫┣JHWH╋

Action: systematic variation in lexeme

Psalms 138:2 ==> slot 334200 ==> 334243
    ╋KL╋LB┫┣NGD╋>LHJM┫┣ZMR┫┣▶CXH◀┫┣>L╋HJKL╋QDC┫┣W┫┣JDH╋
    ╋KL╋LB┫┣NGD╋>LHJM┫┣ZMR┫┣▶XWH◀┫┣>L╋HJKL╋QDC┫┣W┫┣JDH╋

Action: systematic variation in lexeme

Job 1:20 ==> slot 336428 ==> 336471
    ╋R>C┫┣W┫┣NPL┫┣>RY┫┣W┫┣▶CXH◀┫┣W┫┣>MR┫┣<RWM┫┣JY>┫┣MN╋
    ╋R>C┫┣W┫┣NPL┫┣>RY┫┣W┫┣▶XWH◀┫┣W┫┣>MR┫┣<RWM┫┣JY>┫┣MN╋

Action: systematic variation in lexeme

Proverbs 24:31 ==> slot 353611 ==> 353654
    ╋LB┫┣W┫┣HNH┫┣<LH┫┣KL┫┣▶QMWF◀┫┣KSH┫┣PNH┫┣XRWL┫┣W┫┣GDR╋
    ╋LB┫┣W┫┣HNH┫┣<LH┫┣KL┫┣▶QMFWN◀┫┣KSH┫┣PNH┫┣XRWL┫┣W┫┣GDR╋

Action: incidental variation in lexeme

Ruth 2:10 ==> slot 356377 ==> 356420
    ╋W┫┣NPL┫┣<L╋PNH┫┣W┫┣▶CXH◀┫┣>RY┫┣W┫┣>MR┫┣>L┫┣MDW<╋
    ╋W┫┣NPL┫┣<L╋PNH┫┣W┫┣▶XWH◀┫┣>RY┫┣W┫┣>MR┫┣>L┫┣MDW<╋

Action: systematic variation in lexeme

Esther 3:2 ==> slot 366631 ==> 366674
    ╋C<R╋H╋MLK┫┣KR<┫┣W┫┣▶CXH◀┫┣L╋HMN┫┣KJ┫┣KN┫┣YWH╋
    ╋C<R╋H╋MLK┫┣KR<┫┣W┫┣▶XWH◀┫┣L╋HMN┫┣KJ┫┣KN┫┣YWH╋

Action: systematic variation in lexeme

Esther 3:2 ==> slot 366646 ==> 366689
    ╋MRDKJ┫┣L>┫┣KR<┫┣W┫┣L>┫┣▶CXH◀┫┣W┫┣>MR┫┣<BD╋H╋MLK╋
    ╋MRDKJ┫┣L>┫┣KR<┫┣W┫┣L>┫┣▶XWH◀┫┣W┫┣>MR┫┣<BD╋H╋MLK╋

Action: systematic variation in lexeme

Esther 3:5 ==> slot 366702 ==> 366745
    ╋KJ┫┣>JN┫┣MRDKJ┫┣KR<╋W╋▶CXH◀┫┣L┫┣W┫┣ML>┫┣HMN┫┣XMH╋
    ╋KJ┫┣>JN┫┣MRDKJ┫┣KR<╋W╋▶XWH◀┫┣L┫┣W┫┣ML>┫┣HMN┫┣XMH╋

Action: systematic variation in lexeme

Daniel 1:2 ==> slot 370037 ==> 370080
    ╋>T╋JHWJQJM┫┣MLK╋JHWDH┫┣W┫┣▶MQYT◀╋KLJ╋BJT╋H╋>LHJM┫┣W╋
    ╋>T╋JHWJQJM┫┣MLK╋JHWDH┫┣W┫┣▶MN◀╋QYT╋KLJ╋BJT╋H╋>LHJM╋

Action: systematic split into 1 extra slot

Daniel 1:5 ==> slot 370138 ==> 370182
    ╋L╋GDL┫┣CNH╋CLC┫┣W┫┣▶MQYT◀┫┣<MD┫┣L╋PNH╋H╋MLK╋
    ╋L╋GDL┫┣CNH╋CLC┫┣W┫┣▶MN◀╋QYT┫┣<MD┫┣L╋PNH╋H╋

Action: systematic split into 1 extra slot

Daniel 1:15 ==> slot 370329 ==> 370374
    ╋W┫┣NSH┫┣JWM╋<FRH┫┣W┫┣▶MQYT◀╋JWM╋<FRH┫┣R>H┫┣MR>H┫┣VWB╋
    ╋W┫┣NSH┫┣JWM╋<FRH┫┣W┫┣▶MN◀╋QYT╋JWM╋<FRH┫┣R>H┫┣MR>H╋

Action: systematic split into 1 extra slot

Daniel 1:18 ==> slot 370390 ==> 370436
    ╋XZWN╋W╋XLWM┫┣W┫┣L╋▶MQYT◀╋H╋JWM┫┣>CR┫┣>MR┫┣H╋
    ╋XZWN╋W╋XLWM┫┣W┫┣L╋▶MN◀╋QYT╋H╋JWM┫┣>CR┫┣>MR╋

Action: systematic split into 1 extra slot

Nehemiah 7:69 ==> slot 386987 ==> 387034
    ╋CB<╋M>H╋W╋<FRJM┫┣W┫┣▶MQYT◀╋R>C╋H╋>B┫┣NTN┫┣L╋
    ╋CB<╋M>H╋W╋<FRJM┫┣W┫┣▶MN◀╋QYT╋R>C╋H╋>B┫┣NTN╋

Action: systematic split into 1 extra slot

Nehemiah 8:6 ==> slot 387279 ==> 387327
    ╋M<L╋JD┫┣W┫┣QDD┫┣W┫┣▶CXH◀┫┣L╋JHWH┫┣>P┫┣>RY┫┣W╋
    ╋M<L╋JD┫┣W┫┣QDD┫┣W┫┣▶XWH◀┫┣L╋JHWH┫┣>P┫┣>RY┫┣W╋

Action: systematic variation in lexeme

Nehemiah 9:3 ==> slot 387715 ==> 387763
    ╋JWM┫┣W┫┣RBJ<J┫┣JDH┫┣W┫┣▶CXH◀┫┣L╋JHWH┫┣>LHJM┫┣W┫┣QWM╋
    ╋JWM┫┣W┫┣RBJ<J┫┣JDH┫┣W┫┣▶XWH◀┫┣L╋JHWH┫┣>LHJM┫┣W┫┣QWM╋

Action: systematic variation in lexeme

Nehemiah 9:6 ==> slot 387815 ==> 387863
    ╋W┫┣YB>╋H╋CMJM┫┣L┫┣▶CXH◀┫┣>TH┫┣HW>┫┣JHWH┫┣H╋>LHJM╋
    ╋W┫┣YB>╋H╋CMJM┫┣L┫┣▶XWH◀┫┣>TH┫┣HW>┫┣JHWH┫┣H╋>LHJM╋

Action: systematic variation in lexeme

Nehemiah 11:27 ==> slot 389626 ==> 389674
    ╋W┫┣B╋XYR_CW<L╋W╋B╋▶B>R_CB<◀╋W╋BT┫┣W┫┣B╋YQLG╋
    ╋W┫┣B╋XYR_CW<L╋W╋B╋▶B>R◀╋CB<╋W╋BT┫┣W┫┣B╋

Action: split on _ into 1 extra slot

Nehemiah 11:30 ==> slot 389660 ==> 389709
    ╋W╋BT┫┣W┫┣XNH┫┣MN╋▶B>R_CB<◀┫┣<D╋GJ>╋HNM┫┣W┫┣BN╋
    ╋W╋BT┫┣W┫┣XNH┫┣MN╋▶B>R◀╋CB<┫┣<D╋GJ>╋HNM┫┣W╋

Action: split on _ into 1 extra slot

1_Chronicles 4:28 ==> slot 393152 ==> 393202
    ╋BN╋JHWDH┫┣W┫┣JCB┫┣B╋▶B>R_CB<◀┫┣W┫┣MWLDH╋W╋XYR_CW<L┫┣W╋
    ╋BN╋JHWDH┫┣W┫┣JCB┫┣B╋▶B>R◀╋CB<╋W╋MWLDH╋W╋XYR_CW<L╋

Action: split on _ into 1 extra slot

1_Chronicles 16:29 ==> slot 399894 ==> 399945
    ╋MNXH┫┣W┫┣BW>┫┣L╋PNH┫┣▶CXH◀┫┣L╋JHWH┫┣B╋HDRH╋QDC╋
    ╋MNXH┫┣W┫┣BW>┫┣L╋PNH┫┣▶XWH◀┫┣L╋JHWH┫┣B╋HDRH╋QDC╋

Action: systematic variation in lexeme

1_Chronicles 21:2 ==> slot 401751 ==> 401802
    ╋HLK┫┣SPR┫┣>T╋JFR>L┫┣MN╋▶B>R_CB<◀┫┣W┫┣<D╋DN┫┣W┫┣BW>╋
    ╋HLK┫┣SPR┫┣>T╋JFR>L┫┣MN╋▶B>R◀╋CB<┫┣W┫┣<D╋DN┫┣W╋

Action: split on _ into 1 extra slot

1_Chronicles 21:21 ==> slot 402212 ==> 402264
    ╋JY>┫┣MN╋H╋GRN┫┣W┫┣▶CXH◀┫┣L╋DWD┫┣>P┫┣>RY┫┣W╋
    ╋JY>┫┣MN╋H╋GRN┫┣W┫┣▶XWH◀┫┣L╋DWD┫┣>P┫┣>RY┫┣W╋

Action: systematic variation in lexeme

1_Chronicles 27:12 ==> slot 405025 ==> 405077
    ╋>BJ<ZR┫┣H╋<NTTJ┫┣L╋H╋▶BN_JMJNJ◀┫┣W┫┣<L╋MXLQT┫┣<FRJM╋W╋
    ╋>BJ<ZR┫┣H╋<NTTJ┫┣L╋H╋▶BN◀╋JMJNJ┫┣W┫┣<L╋MXLQT┫┣<FRJM╋

Action: split on _ into 1 extra slot

1_Chronicles 29:20 ==> slot 406515 ==> 406568
    ╋>LHJM╋>B┫┣W┫┣QDD┫┣W┫┣▶CXH◀┫┣L╋JHWH┫┣W┫┣L╋H╋
    ╋>LHJM╋>B┫┣W┫┣QDD┫┣W┫┣▶XWH◀┫┣L╋JHWH┫┣W┫┣L╋H╋

Action: systematic variation in lexeme

2_Chronicles 7:3 ==> slot 409997 ==> 410050
    ╋>RY┫┣<L╋H╋RYPH┫┣W┫┣▶CXH◀┫┣W┫┣JDH┫┣L╋JHWH┫┣KJ╋
    ╋>RY┫┣<L╋H╋RYPH┫┣W┫┣▶XWH◀┫┣W┫┣JDH┫┣L╋JHWH┫┣KJ╋

Action: systematic variation in lexeme

2_Chronicles 7:19 ==> slot 410427 ==> 410480
    ╋W┫┣<BD┫┣>LHJM╋>XR┫┣W┫┣▶CXH◀┫┣L┫┣W┫┣NTC┫┣MN╋<L╋
    ╋W┫┣<BD┫┣>LHJM╋>XR┫┣W┫┣▶XWH◀┫┣L┫┣W┫┣NTC┫┣MN╋<L╋

Action: systematic variation in lexeme

2_Chronicles 7:22 ==> slot 410513 ==> 410566
    ╋XZQ┫┣B╋>LHJM╋>XR┫┣W┫┣▶CXH◀┫┣L┫┣W┫┣<BD┫┣<L╋KN╋
    ╋XZQ┫┣B╋>LHJM╋>XR┫┣W┫┣▶XWH◀┫┣L┫┣W┫┣<BD┫┣<L╋KN╋

Action: systematic variation in lexeme

2_Chronicles 19:4 ==> slot 415696 ==> 415749
    ╋JY>┫┣B╋H╋<M┫┣MN╋▶B>R_CB<◀┫┣<D╋HR╋>PRJM┫┣W┫┣CWB╋
    ╋JY>┫┣B╋H╋<M┫┣MN╋▶B>R◀╋CB<┫┣<D╋HR╋>PRJM┫┣W╋

Action: split on _ into 1 extra slot

2_Chronicles 20:18 ==> slot 416304 ==> 416358
    ╋NPL┫┣L╋PNH╋JHWH┫┣L╋▶CXH◀┫┣L╋JHWH┫┣W┫┣QWM┫┣H╋
    ╋NPL┫┣L╋PNH╋JHWH┫┣L╋▶XWH◀┫┣L╋JHWH┫┣W┫┣QWM┫┣H╋

Action: systematic variation in lexeme

2_Chronicles 24:1 ==> slot 418154 ==> 418208
    ╋W┫┣CM╋>M┫┣YBJH┫┣MN╋▶B>R_CB<◀┫┣W┫┣<FH┫┣JW>C┫┣H┫┣JCR╋
    ╋W┫┣CM╋>M┫┣YBJH┫┣MN╋▶B>R◀╋CB<┫┣W┫┣<FH┫┣JW>C┫┣H╋

Action: split on _ into 1 extra slot

2_Chronicles 24:17 ==> slot 418544 ==> 418599
    ╋JHWJD<┫┣BW>┫┣FR╋JHWDH┫┣W┫┣▶CXH◀┫┣L╋H╋MLK┫┣>Z┫┣CM<╋
    ╋JHWJD<┫┣BW>┫┣FR╋JHWDH┫┣W┫┣▶XWH◀┫┣L╋H╋MLK┫┣>Z┫┣CM<╋

Action: systematic variation in lexeme

2_Chronicles 25:14 ==> slot 419155 ==> 419210
    ╋L╋>LHJM┫┣W┫┣L╋PNH┫┣▶CXH◀┫┣W┫┣L┫┣QVR┫┣W┫┣XRH╋
    ╋L╋>LHJM┫┣W┫┣L╋PNH┫┣▶XWH◀┫┣W┫┣L┫┣QVR┫┣W┫┣XRH╋

Action: systematic variation in lexeme

2_Chronicles 29:28 ==> slot 421534 ==> 421589
    ╋JFR>L┫┣W┫┣KL╋H╋QHL┫┣▶CXH◀┫┣W┫┣H╋CJR┫┣CJR┫┣W╋
    ╋JFR>L┫┣W┫┣KL╋H╋QHL┫┣▶XWH◀┫┣W┫┣H╋CJR┫┣CJR┫┣W╋

Action: systematic variation in lexeme

2_Chronicles 29:29 ==> slot 421564 ==> 421619
    ╋KL┫┣H┫┣MY>┫┣>T┫┣W┫┣▶CXH◀┫┣W┫┣>MR┫┣JXZQJHW┫┣H╋MLK╋
    ╋KL┫┣H┫┣MY>┫┣>T┫┣W┫┣▶XWH◀┫┣W┫┣>MR┫┣JXZQJHW┫┣H╋MLK╋

Action: systematic variation in lexeme

2_Chronicles 29:30 ==> slot 421595 ==> 421650
    ╋L╋FMXH┫┣W┫┣QDD┫┣W┫┣▶CXH◀┫┣W┫┣<NH┫┣JXZQJHW┫┣W┫┣>MR╋
    ╋L╋FMXH┫┣W┫┣QDD┫┣W┫┣▶XWH◀┫┣W┫┣<NH┫┣JXZQJHW┫┣W┫┣>MR╋

Action: systematic variation in lexeme

2_Chronicles 30:5 ==> slot 421839 ==> 421894
    ╋QWL┫┣B╋KL╋JFR>L┫┣MN╋▶B>R_CB<◀┫┣W┫┣<D╋DN┫┣L╋BW>╋
    ╋QWL┫┣B╋KL╋JFR>L┫┣MN╋▶B>R◀╋CB<┫┣W┫┣<D╋DN┫┣L╋

Action: split on _ into 1 extra slot

2_Chronicles 32:12 ==> slot 423282 ==> 423338
    ╋>MR┫┣L╋PNH╋MZBX╋>XD┫┣▶CXH◀┫┣W┫┣<L┫┣QVR┫┣H┫┣L>╋
    ╋>MR┫┣L╋PNH╋MZBX╋>XD┫┣▶XWH◀┫┣W┫┣<L┫┣QVR┫┣H┫┣L>╋

Action: systematic variation in lexeme

2_Chronicles 33:3 ==> slot 423850 ==> 423906
    ╋B<L┫┣W┫┣<FH┫┣>CRH┫┣W┫┣▶CXH◀┫┣L╋KL╋YB>╋H╋CMJM╋
    ╋B<L┫┣W┫┣<FH┫┣>CRH┫┣W┫┣▶XWH◀┫┣L╋KL╋YB>╋H╋CMJM╋

Action: systematic variation in lexeme

No more differences.
Found 234 points of disturbance

Running

Here we run the mapping between 4 and 4b. The points of disturbance will be written into the output cell.

4 => 4b

Here are the special cases for this conversion.

In [14]:
cases.update(
    {
        ("4", "4b"): {
            214730: ("collapse", 3),
            260028: ("split", 1),
            289948: ("ok", None),
            307578: ("split", 1),
            323067: ("ok", None),
            389774: ("ok", None),
            407543: ("split", 1),
            408429: ("split", 1),
        },
    }
)
In [15]:
doDiffs("4", "4b")
Genesis 24:65 ==> slot 12369 ==> 12369
    ╋H╋<BD┫┣MJ┫┣H╋>JC╋▶HLZH◀┫┣H┫┣HLK┫┣B╋H╋FDH╋
    ╋H╋<BD┫┣MJ┫┣H╋>JC╋▶H◀╋LZH┫┣H┫┣HLK┫┣B╋H╋

Action: split article off

Genesis 37:19 ==> slot 20514 ==> 20515
    ╋>X┫┣HNH┫┣B<L╋H╋XLWM╋▶HLZH◀┫┣BW>┫┣W┫┣<TH┫┣HLK┫┣W╋
    ╋>X┫┣HNH┫┣B<L╋H╋XLWM╋▶H◀╋LZH┫┣BW>┫┣W┫┣<TH┫┣HLK╋

Action: split article off

Judges 6:20 ==> slot 130846 ==> 130848
    ╋W┫┣NWX┫┣>L╋H╋SL<╋▶HLZ◀┫┣W┫┣>T╋H╋MRQ┫┣CPK╋
    ╋W┫┣NWX┫┣>L╋H╋SL<╋▶H◀╋LZ┫┣W┫┣>T╋H╋MRQ╋

Action: split article off

1_Samuel 14:1 ==> slot 148319 ==> 148322
    ╋MYB╋PLCTJ┫┣>CR┫┣MN╋<BR╋▶HLZ◀┫┣W┫┣L╋>B┫┣L>┫┣NGD╋
    ╋MYB╋PLCTJ┫┣>CR┫┣MN╋<BR╋▶H◀╋LZ┫┣W┫┣L╋>B┫┣L>╋

Action: split article off

1_Samuel 17:26 ==> slot 151331 ==> 151335
    ╋>CR┫┣NKH┫┣>T╋H╋PLCTJ╋▶HLZ◀┫┣W┫┣SWR┫┣XRPH┫┣MN╋<L╋
    ╋>CR┫┣NKH┫┣>T╋H╋PLCTJ╋▶H◀╋LZ┫┣W┫┣SWR┫┣XRPH┫┣MN╋

Action: split article off

1_Samuel 20:19 ==> slot 153816 ==> 153821
    ╋W┫┣JCB┫┣>YL╋H╋>BN┫┣▶H>ZL◀┫┣W┫┣>NJ┫┣CLC╋H╋XY╋
    ╋W┫┣JCB┫┣>YL╋H╋>BN╋▶H◀╋>ZL┫┣W┫┣>NJ┫┣CLC╋H╋

Action: split article off

2_Kings 4:25 ==> slot 196975 ==> 196981
    ╋GJXZJ┫┣N<R┫┣HNH┫┣H╋CWNMJ╋▶HLZ◀┫┣<TH┫┣RWY┫┣N>┫┣L╋QR>╋
    ╋GJXZJ┫┣N<R┫┣HNH┫┣H╋CWNMJ╋▶H◀╋LZ┫┣<TH┫┣RWY┫┣N>┫┣L╋

Action: split article off

2_Kings 23:17 ==> slot 210326 ==> 210333
    ╋W┫┣>MR┫┣MH┫┣H╋YJWN╋▶HLZ◀┫┣>CR┫┣>NJ┫┣R>H┫┣W┫┣>MR╋
    ╋W┫┣>MR┫┣MH┫┣H╋YJWN╋▶H◀╋LZ┫┣>CR┫┣>NJ┫┣R>H┫┣W╋

Action: split article off

Isaiah 8:1 ==> slot 214730 ==> 214738
    ╋<L┫┣B╋XRV╋>NWC┫┣L╋▶MHR◀┫┣CLL┫┣XWC┫┣BZ┫┣W┫┣<WD╋
    ╋<L┫┣B╋XRV╋>NWC┫┣L╋▶MHR_CLL_XC_BZ◀┫┣W┫┣<WD┫┣L┫┣<D╋>MN╋

Action: collapse 3 fewer slots

Jeremiah 46:20 ==> slot 260028 ==> 260033
    ╋NYH┫┣MN╋>JN╋JCB┫┣<GLH╋▶JPHPJ◀┫┣MYRJM┫┣QRY┫┣MN╋YPWN┫┣BW>╋
    ╋NYH┫┣MN╋>JN╋JCB┫┣<GLH╋▶JPH◀╋PJH┫┣MYRJM┫┣QRY┫┣MN╋YPWN╋

Action: split into 1 extra slot

Ezekiel 16:7 ==> slot 271124 ==> 271130
    ╋RBH┫┣W┫┣GDL┫┣W┫┣BW>┫┣▶B<D◀╋<DJ┫┣CD┫┣KWN┫┣W┫┣F<R╋
    ╋RBH┫┣W┫┣GDL┫┣W┫┣BW>┫┣▶B◀╋<DJ╋<DJ┫┣CD┫┣KWN┫┣W╋

Action: split preposition off

Ezekiel 36:35 ==> slot 283104 ==> 283111
    ╋<BR┫┣W┫┣>MR┫┣H╋>RY╋▶HLZW◀┫┣H┫┣CMM┫┣HJH┫┣K╋GN╋
    ╋<BR┫┣W┫┣>MR┫┣H╋>RY╋▶H◀╋LZW┫┣H┫┣CMM┫┣HJH┫┣K╋

Action: split article off

Ezekiel 47:13 ==> slot 289948 ==> 289956
    ╋TRWPH┫┣KH┫┣>MR┫┣>DNJ╋JHWH┫┣▶ZH◀┫┣GBWL┫┣>CR┫┣NXL┫┣>T╋H╋
    ╋TRWPH┫┣KH┫┣>MR┫┣>DNJ╋JHWH┫┣▶G>◀╋GBWL┫┣>CR┫┣NXL┫┣>T╋H╋

Action: incidental variation in lexeme

Zechariah 2:8 ==> slot 305480 ==> 305488
    ╋RWY┫┣DBR┫┣>L╋H╋N<R╋▶HLZ◀┫┣L╋>MR┫┣PRZWT┫┣JCB┫┣JRWCLM╋
    ╋RWY┫┣DBR┫┣>L╋H╋N<R╋▶H◀╋LZ┫┣L╋>MR┫┣PRZWT┫┣JCB╋

Action: split article off

Zechariah 9:8 ==> slot 307578 ==> 307587
    ╋JBWSJ┫┣W┫┣XNH┫┣L╋BJT┫┣▶MYBH◀┫┣MN╋<BR╋W╋MN╋CWB╋
    ╋JBWSJ┫┣W┫┣XNH┫┣L╋BJT┫┣▶MN◀╋YB>┫┣MN╋<BR╋W╋MN╋

Action: split into 1 extra slot

Psalms 75:7 ==> slot 323067 ==> 323077
    ╋M<RB┫┣W┫┣L>┫┣MN╋MDBR┫┣▶RWM◀┫┣KJ┫┣>LHJM┫┣CPV┫┣ZH┫┣CPL╋
    ╋M<RB┫┣W┫┣L>┫┣MN╋MDBR╋▶HR◀┫┣KJ┫┣>LHJM┫┣CPV┫┣ZH┫┣CPL╋

Action: incidental variation in lexeme

Daniel 8:16 ==> slot 375529 ==> 375539
    ╋W┫┣>MR┫┣GBRJ>L┫┣BJN┫┣L╋▶HLZ◀┫┣>T╋H╋MR>H┫┣W┫┣BW>╋
    ╋W┫┣>MR┫┣GBRJ>L┫┣BJN┫┣L╋▶H◀╋LZ┫┣>T╋H╋MR>H┫┣W╋

Action: split article off

Nehemiah 12:4 ==> slot 389774 ==> 389785
    ╋XVWC┫┣CKNJH╋RXWM╋MRMWT┫┣<D>╋▶GNTWN◀╋>BJH┫┣MJMJN╋M<DJH╋BLGH┫┣CM<JH╋
    ╋XVWC┫┣CKNJH╋RXWM╋MRMWT┫┣<D>╋▶GNTWJ◀╋>BJH┫┣MJMJN╋M<DJH╋BLGH┫┣CM<JH╋

Action: incidental variation in lexeme

2_Chronicles 2:12 ==> slot 407543 ==> 407554
    ╋>JC╋XKM┫┣JD<┫┣BJNH┫┣L╋▶XWRM_>BJ◀┫┣BN╋>CH┫┣MN╋BT╋DN╋
    ╋>JC╋XKM┫┣JD<┫┣BJNH┫┣L╋▶XWRM◀┫┣>B┫┣BN╋>CH┫┣MN╋BT╋

Action: split into 1 extra slot

2_Chronicles 4:16 ==> slot 408429 ==> 408441
    ╋W┫┣>T╋KL╋KLJ┫┣<FH┫┣▶XWRM_>BJ◀┫┣L╋H╋MLK┫┣CLMH┫┣L╋
    ╋W╋>T╋KL╋KLJ┫┣<FH┫┣▶XWRM◀┫┣>B┫┣L╋H╋MLK┫┣CLMH╋

Action: split into 1 extra slot

No more differences.
Found 20 points of disturbance

4b => 2016

We need other cases.

In [16]:
cases.update(
    {
        ("4b", "2016"): {
            28423: ("split", 2),
            28455: ("split", 2),
            91193: ("split", 1),
            91197: ("split", 1),
            122218: ("split", 1),
            122247: ("split", 1),
            123160: ("split", 1),
            184086: ("split", 1),
            394186: ("collapse", 1),
            395150: ("ok", None),
            395190: ("ok", None),
            401036: ("split", 2),
            404503: ("ok", None),
            419138: ("split", 2),
        },
    }
)
In [17]:
doDiffs("4b", "2016")
Genesis 50:10 ==> slot 28423 ==> 28423
    ╋KBD╋M>D┫┣W┫┣BW>┫┣<D╋▶GRN_>VD◀┫┣>CR┫┣B╋<BR╋H╋JRDN╋
    ╋KBD╋M>D┫┣W┫┣BW>┫┣<D╋▶GRN◀╋H╋>VD┫┣>CR┫┣B╋<BR╋

Action: split into 2 extra slots

Genesis 50:11 ==> slot 28455 ==> 28457
    ╋KN<NJ┫┣>T╋H╋>BL┫┣B╋▶GRN_>VD◀┫┣W┫┣>MR┫┣>BL╋KBD┫┣ZH╋
    ╋KN<NJ┫┣>T╋H╋>BL┫┣B╋▶GRN◀╋H╋>VD┫┣W┫┣>MR┫┣>BL╋

Action: split into 2 extra slots

Numbers 33:45 ==> slot 91193 ==> 91197
    ╋MN╋<JJM┫┣W┫┣XNH┫┣B╋▶DJBWN_GD◀┫┣W┫┣NS<┫┣MN╋DJBWN_GD┫┣W╋
    ╋MN╋<JJM┫┣W┫┣XNH┫┣B╋▶DJBN◀╋GD┫┣W┫┣NS<┫┣MN╋DJBN╋

Action: split into 1 extra slot

Numbers 33:46 ==> slot 91197 ==> 91202
    ╋B╋DJBWN_GD┫┣W┫┣NS<┫┣MN╋▶DJBWN_GD◀┫┣W┫┣XNH┫┣B╋<LMWN_DBLTJMH┫┣W╋
    ╋B╋DJBN┫┣W┫┣NS<┫┣MN╋▶DJBN◀╋GD┫┣W┫┣XNH┫┣B╋<LMWN_DBLTJMH╋

Action: split into 1 extra slot

Joshua 16:3 ==> slot 122218 ==> 122224
    ╋GBWL╋H╋JPLVJ┫┣<D╋GBWL╋▶BJT_XRWN_TXTWN◀╋W╋<D╋GZR┫┣W┫┣HJH╋
    ╋GBWL╋H╋JPLVJ┫┣<D╋GBWL╋▶BJT_XWRWN◀╋TXTWN╋W╋<D╋GZR┫┣W╋

Action: split into 1 extra slot

Joshua 16:5 ==> slot 122247 ==> 122254
    ╋GBWL╋NXLH┫┣MZRX┫┣<VRWT_>DR┫┣<D╋▶BJT_XRWN_<LJWN◀┫┣W┫┣JY>┫┣H╋GBWL┫┣H╋
    ╋GBWL╋NXLH┫┣MZRX┫┣<VRWT_>DR┫┣<D╋▶BJT_XWRWN◀╋<LJWN┫┣W┫┣JY>┫┣H╋GBWL╋

Action: split into 1 extra slot

Joshua 18:13 ==> slot 123160 ==> 123168
    ╋HR┫┣>CR┫┣MN╋NGB┫┣L╋▶BJT_XRWN_TXTWN◀┫┣W┫┣T>R┫┣H╋GBWL┫┣W╋
    ╋HR┫┣>CR┫┣MN╋NGB┫┣L╋▶BJT_XWRWN◀╋TXTWN┫┣W┫┣T>R┫┣H╋GBWL╋

Action: split into 1 extra slot

1_Kings 9:17 ==> slot 184086 ==> 184095
    ╋CLMH┫┣>T╋GZR╋W╋>T╋▶BJT_XRWN_TXTWN◀┫┣W┫┣>T╋B<LT╋W╋>T╋
    ╋CLMH┫┣>T╋GZR╋W╋>T╋▶BJT_XWRWN◀╋TXTWN┫┣W┫┣>T╋B<LT╋W╋

Action: split into 1 extra slot

1_Chronicles 6:13 ==> slot 394186 ==> 394196
    ╋W┫┣BN╋CMW>L┫┣H╋BKR╋▶W◀╋CNJ╋W╋>BJH┫┣BN╋MRRJ╋
    ╋W┫┣BN╋CMW>L┫┣H╋BKR┫┣▶WCNJ◀┫┣W┫┣>BJH┫┣BN╋MRRJ┫┣MXLJ╋

Action: collapse 1 fewer slot

1_Chronicles 7:12 ==> slot 395150 ==> 395159
    ╋YB>┫┣L╋H╋MLXMH┫┣W┫┣▶CPM◀╋W╋XPJM┫┣BN╋<JR┫┣XCM╋
    ╋YB>┫┣L╋H╋MLXMH┫┣W┫┣▶CPJM◀╋W╋XPJM┫┣BN╋<JR┫┣XCM╋

Action: incidental variation in lexeme

1_Chronicles 7:15 ==> slot 395190 ==> 395199
    ╋>CH┫┣L╋XPJM╋W╋L╋▶CPM◀┫┣W┫┣CM╋>XWT┫┣M<KH┫┣W╋
    ╋>CH┫┣L╋XPJM╋W╋L╋▶CPJM◀┫┣W┫┣CM╋>XWT┫┣M<KH┫┣W╋

Action: incidental variation in lexeme

1_Chronicles 18:12 ==> slot 401036 ==> 401045
    ╋YRWJH┫┣NKH┫┣>T╋>DWM┫┣B╋▶GJ>_MLX◀┫┣CMNH╋<FR╋>LP┫┣W┫┣FJM╋
    ╋YRWJH┫┣NKH┫┣>T╋>DWM┫┣B╋▶GJ>◀╋H╋MLX┫┣CMNH╋<FR╋>LP╋

Action: split into 2 extra slots

1_Chronicles 26:16 ==> slot 404503 ==> 404514
    ╋BN┫┣BJT╋H╋>SP┫┣L╋▶CPM◀╋W╋L╋XSH┫┣L╋H╋
    ╋BN┫┣BJT╋H╋>SP┫┣L╋▶CPJM◀╋W╋L╋XSH┫┣L╋H╋

Action: incidental variation in lexeme

2_Chronicles 25:11 ==> slot 419138 ==> 419149
    ╋NHG┫┣>T╋<M┫┣W┫┣HLK┫┣▶GJ>_MLX◀┫┣W┫┣NKH┫┣>T╋BN╋F<JR╋
    ╋NHG┫┣>T╋<M┫┣W┫┣HLK┫┣▶GJ>◀╋H╋MLX┫┣W┫┣NKH┫┣>T╋

Action: split into 2 extra slots

No more differences.
Found 14 points of disturbance

2016 => 2017

We need other cases.

In [12]:
cases.update(
    {
        ("2016", "2017"): {
            16562: ("split", 1),
            392485: ("split", 2),
        },
    }
)
In [13]:
doDiffs("2016", "2017")
Genesis 31:11 ==> slot 16562 ==> 16562
    ╋>MR┫┣>L┫┣ML>K╋H╋>LHJM┫┣▶B◀╋XLWM┫┣J<QB┫┣W┫┣>MR┫┣HNH╋
    ╋>MR┫┣>L┫┣ML>K╋H╋>LHJM┫┣▶B◀╋H╋XLWM┫┣J<QB┫┣W┫┣>MR╋

Action: split into 1 extra slot

1_Chronicles 2:52 ==> slot 392485 ==> 392486
    ╋L╋CWBL┫┣>B╋QRJT_J<RJM┫┣HR>H┫┣▶XYJ_HMNXWT◀┫┣W┫┣MCPXH╋QRJT_J<RJM┫┣H╋JTRJ╋
    ╋L╋CWBL┫┣>B╋QRJT_J<RJM┫┣HR>H┫┣▶XYJ◀╋H╋MNWXH┫┣W┫┣MCPXH╋QRJT_J<RJM╋

Action: split into 2 extra slots

No more differences.
Found 2 points of disturbance

2017 => 2021

No changes expected right now.

In [33]:
cases.update(
    {
        ("2017", "2021"): {},
    }
)
In [34]:
doDiffs("2017", "2021")
Genesis 24:10 ==> slot 11325 ==> 11325
    ╋W┫┣QWM┫┣W┫┣HLK┫┣>L╋▶>RM_NHRJM◀┫┣>L╋<JR╋NXWR┫┣W┫┣BRK╋
    ╋W┫┣QWM┫┣W┫┣HLK┫┣>L╋▶>RM◀╋NHR┫┣>L╋<JR╋NXWR┫┣W╋

Action: split on _ into 1 extra slot

Deuteronomy 23:5 ==> slot 105981 ==> 105982
    ╋BL<M┫┣BN╋B<WR┫┣MN╋PTWR╋▶>RM_NHRJM◀┫┣L╋QLL┫┣W┫┣L>┫┣>BH╋
    ╋BL<M┫┣BN╋B<WR┫┣MN╋PTWR╋▶>RM◀╋NHR┫┣L╋QLL┫┣W┫┣L>╋

Action: split on _ into 1 extra slot

Judges 3:8 ==> slot 128871 ==> 128873
    ╋MKR┫┣B╋JD╋KWCN_RC<TJM┫┣MLK╋▶>RM_NHRJM◀┫┣W┫┣<BD┫┣BN╋JFR>L┫┣>T╋
    ╋MKR┫┣B╋JD╋KWCN_RC<TJM┫┣MLK╋▶>RM◀╋NHR┫┣W┫┣<BD┫┣BN╋JFR>L╋

Action: split on _ into 1 extra slot

Psalms 60:2 ==> slot 320252 ==> 320255
    ╋L╋LMD┫┣B╋NYH┫┣>T╋▶>RM_NHRJM◀╋W╋>T╋>RM╋YWB>┫┣W╋
    ╋L╋LMD┫┣B╋NYH┫┣>T╋▶>RM◀╋NHR╋W╋>T╋>RM╋YWB>╋

Action: split on _ into 1 extra slot

1_Chronicles 19:6 ==> slot 401289 ==> 401293
    ╋KSP┫┣L╋FKR┫┣L┫┣MN╋▶>RM_NHRJM◀╋W╋MN╋>RM_M<KH╋W╋MN╋
    ╋KSP┫┣L╋FKR┫┣L┫┣MN╋▶>RM◀╋NHR╋W╋MN╋>RM╋M<KH╋

Action: split on _ into 1 extra slot

1_Chronicles 19:6 ==> slot 401292 ==> 401297
    ╋L┫┣MN╋>RM_NHRJM╋W╋MN╋▶>RM_M<KH◀╋W╋MN╋YWB>┫┣RKB╋W╋
    ╋L┫┣MN╋>RM╋W╋MN╋▶>RM◀╋M<KH╋W╋MN╋YWB>┫┣RKB╋

Action: split on _ into 1 extra slot

No more differences.
Found 6 points of disturbance

c => 2021

No changes expected right now.

In [13]:
cases.update(
    {
        ("c", "2021"): {},
    }
)
In [14]:
doDiffs("c", "2021")
Genesis 24:10 ==> slot 11325 ==> 11325
    ╋W┫┣QWM┫┣W┫┣HLK┫┣>L╋▶>RM_NHRJM◀┫┣>L╋<JR╋NXWR┫┣W┫┣BRK╋
    ╋W┫┣QWM┫┣W┫┣HLK┫┣>L╋▶>RM◀╋NHR┫┣>L╋<JR╋NXWR┫┣W╋

Action: split on _ into 1 extra slot

Deuteronomy 23:5 ==> slot 105981 ==> 105982
    ╋BL<M┫┣BN╋B<WR┫┣MN╋PTWR╋▶>RM_NHRJM◀┫┣L╋QLL┫┣W┫┣L>┫┣>BH╋
    ╋BL<M┫┣BN╋B<WR┫┣MN╋PTWR╋▶>RM◀╋NHR┫┣L╋QLL┫┣W┫┣L>╋

Action: split on _ into 1 extra slot

Judges 3:8 ==> slot 128871 ==> 128873
    ╋MKR┫┣B╋JD╋KWCN_RC<TJM┫┣MLK╋▶>RM_NHRJM◀┫┣W┫┣<BD┫┣BN╋JFR>L┫┣>T╋
    ╋MKR┫┣B╋JD╋KWCN_RC<TJM┫┣MLK╋▶>RM◀╋NHR┫┣W┫┣<BD┫┣BN╋JFR>L╋

Action: split on _ into 1 extra slot

Psalms 60:2 ==> slot 320252 ==> 320255
    ╋L╋LMD┫┣B╋NYH┫┣>T╋▶>RM_NHRJM◀╋W╋>T╋>RM╋YWB>┫┣W╋
    ╋L╋LMD┫┣B╋NYH┫┣>T╋▶>RM◀╋NHR╋W╋>T╋>RM╋YWB>╋

Action: split on _ into 1 extra slot

1_Chronicles 19:6 ==> slot 401289 ==> 401293
    ╋KSP┫┣L╋FKR┫┣L┫┣MN╋▶>RM_NHRJM◀╋W╋MN╋>RM_M<KH╋W╋MN╋
    ╋KSP┫┣L╋FKR┫┣L┫┣MN╋▶>RM◀╋NHR╋W╋MN╋>RM╋M<KH╋

Action: split on _ into 1 extra slot

1_Chronicles 19:6 ==> slot 401292 ==> 401297
    ╋L┫┣MN╋>RM_NHRJM╋W╋MN╋▶>RM_M<KH◀╋W╋MN╋YWB>┫┣RKB╋W╋
    ╋L┫┣MN╋>RM╋W╋MN╋▶>RM◀╋M<KH╋W╋MN╋YWB>┫┣RKB╋

Action: split on _ into 1 extra slot

No more differences.
Found 6 points of disturbance

Clearly, the only difference between versions c and 2021 is that some composite words in c have been split in version 2021.

In [35]:
edgesFromMaps()
..............................................................................................
.      6m 40s Make edge from slot mapping 2017 => 2021                                       .
..............................................................................................

Extending to node mappings

In [36]:
nodeMapping = {}
diagnosis = {}
In [37]:
statLabels = collections.OrderedDict(
    b="unique, perfect",
    d="multiple, one perfect",
    c="unique, imperfect",
    f="multiple, cleanly composed",
    e="multiple, non-perfect",
    a="not mapped",
)
In [38]:
def makeNodeMapping(nodeType, v, w, force=False):
    caption(2, "Mapping {} nodes {} ==> {}".format(nodeType, v, w))
    mapKey = (v, w)
    edge = edges[mapKey]

    if not force and mapKey in nodeMapping and nodeType in nodeMapping[mapKey]:
        mapping = nodeMapping[mapKey][nodeType]
        diag = diagnosis[mapKey][nodeType]

    else:
        mapping = {}
        diag = {}
        caption(
            0, "Extending slot mapping {} ==> {} for {} nodes".format(*mapKey, nodeType)
        )
        for n in api[v].F.otype.s(nodeType):
            slots = api[v].E.oslots.s(n)
            mappedSlotsTuple = reduce(
                lambda x, y: x + y,
                [tuple(edge.get(s, ())) for s in slots],
                (),
            )
            mappedSlots = set(mappedSlotsTuple)
            mappedNodes = reduce(
                set.union,
                [set(api[w].L.u(s, nodeType)) for s in mappedSlots],
                set(),
            )
            result = {}
            nMs = len(mappedNodes)
            if nMs == 0:
                diag[n] = "a"

            elif nMs >= 1:
                theseMSlots = {}
                for m in mappedNodes:
                    mSlots = set(api[w].E.oslots.s(m))
                    dis = len(mappedSlots | mSlots) - len(mappedSlots & mSlots)
                    result[m] = dis
                    theseMSlots[m] = mSlots
                mapping[n] = result

                # we wait further case analysis before we put these counterparts of n into the edge

                if nMs == 1:
                    m = list(mappedNodes)[0]
                    dis = result[m]
                    if dis == 0:
                        diag[n] = "b"
                        edge[n] = {
                            m: None
                        }  # this is the most freqent case, hence an optimization: no dis value.
                        # all other cases require the dis value to be passed on, even if 0
                    else:
                        diag[n] = "c"
                        edge[n] = {m: dis}
                else:
                    edge[n] = result
                    dis = min(result.values())
                    if dis == 0:
                        diag[n] = "d"
                    else:
                        allMSlots = reduce(
                            set.union,
                            [set(theseMSlots[m]) for m in mappedNodes],
                            set(),
                        )
                        composed = allMSlots == mappedSlots and sum(
                            result.values()
                        ) == len(mappedSlots) * (len(mappedNodes) - 1)

                        if composed:
                            diag[n] = "f"
                        else:
                            diag[n] = "e"

        diagnosis.setdefault(mapKey, {})[nodeType] = diag
        nodeMapping.setdefault(mapKey, {})[nodeType] = mapping
        caption(0, "\tDone")
In [39]:
def exploreNodeMapping(nodeType, v, w, force=False):
    caption(4, "Statistics for {} ==> {} ({})".format(v, w, nodeType))
    mapKey = (v, w)
    diag = diagnosis[mapKey][nodeType]
    total = len(diag)
    if total == 0:
        return

    reasons = collections.Counter()

    for (n, dia) in diag.items():
        reasons[dia] += 1

    caption(0, "\t{:<30} : {:6.2f}% {:>7}x".format("TOTAL", 100, total))
    for stat in statLabels:
        statLabel = statLabels[stat]
        amount = reasons[stat]
        if amount == 0:
            continue
        perc = 100 * amount / total
        caption(0, "\t{:<30} : {:6.2f}% {:>7}x".format(statLabel, perc, amount))
In [40]:
# ntypes = api["3"].F.otype.all
ntypes = api["2021"].F.otype.all
for (i, v) in enumerate(versions):
    if i == 0:
        continue
    prev = versions[i - 1]
    ntypes = api[v].F.otype.all
    for ntype in ntypes[0:-1]:
        makeNodeMapping(ntype, prev, v, force=False)
        exploreNodeMapping(ntype, prev, v)
**********************************************************************************************
*                                                                                            *
*      6m 46s Mapping book nodes 2017 ==> 2021                                               *
*                                                                                            *
**********************************************************************************************

|      6m 46s Extending slot mapping 2017 ==> 2021 for book nodes
|      6m 57s 	Done
..............................................................................................
.      6m 57s Statistics for 2017 ==> 2021 (book)                                            .
..............................................................................................
|      6m 57s 	TOTAL                          : 100.00%      39x
|      6m 57s 	unique, perfect                : 100.00%      39x

**********************************************************************************************
*                                                                                            *
*      6m 57s Mapping chapter nodes 2017 ==> 2021                                            *
*                                                                                            *
**********************************************************************************************

|      6m 57s Extending slot mapping 2017 ==> 2021 for chapter nodes
|      6m 59s 	Done
..............................................................................................
.      6m 59s Statistics for 2017 ==> 2021 (chapter)                                         .
..............................................................................................
|      6m 59s 	TOTAL                          : 100.00%     929x
|      6m 59s 	unique, perfect                : 100.00%     929x

**********************************************************************************************
*                                                                                            *
*      6m 59s Mapping lex nodes 2017 ==> 2021                                                *
*                                                                                            *
**********************************************************************************************

|      6m 59s Extending slot mapping 2017 ==> 2021 for lex nodes
|      7m 14s 	Done
..............................................................................................
.      7m 14s Statistics for 2017 ==> 2021 (lex)                                             .
..............................................................................................
|      7m 14s 	TOTAL                          : 100.00%    9233x
|      7m 14s 	unique, perfect                :  99.79%    9214x
|      7m 14s 	unique, imperfect              :   0.13%      12x
|      7m 14s 	multiple, cleanly composed     :   0.02%       2x
|      7m 14s 	multiple, non-perfect          :   0.05%       5x

**********************************************************************************************
*                                                                                            *
*      7m 14s Mapping verse nodes 2017 ==> 2021                                              *
*                                                                                            *
**********************************************************************************************

|      7m 14s Extending slot mapping 2017 ==> 2021 for verse nodes
|      7m 16s 	Done
..............................................................................................
.      7m 16s Statistics for 2017 ==> 2021 (verse)                                           .
..............................................................................................
|      7m 16s 	TOTAL                          : 100.00%   23213x
|      7m 16s 	unique, perfect                : 100.00%   23213x

**********************************************************************************************
*                                                                                            *
*      7m 16s Mapping half_verse nodes 2017 ==> 2021                                         *
*                                                                                            *
**********************************************************************************************

|      7m 16s Extending slot mapping 2017 ==> 2021 for half_verse nodes
|      7m 19s 	Done
..............................................................................................
.      7m 19s Statistics for 2017 ==> 2021 (half_verse)                                      .
..............................................................................................
|      7m 19s 	TOTAL                          : 100.00%   45180x
|      7m 19s 	unique, perfect                : 100.00%   45178x
|      7m 19s 	unique, imperfect              :   0.00%       2x

**********************************************************************************************
*                                                                                            *
*      7m 19s Mapping sentence nodes 2017 ==> 2021                                           *
*                                                                                            *
**********************************************************************************************

|      7m 19s Extending slot mapping 2017 ==> 2021 for sentence nodes
|      7m 22s 	Done
..............................................................................................
.      7m 22s Statistics for 2017 ==> 2021 (sentence)                                        .
..............................................................................................
|      7m 22s 	TOTAL                          : 100.00%   63711x
|      7m 22s 	unique, perfect                :  99.76%   63559x
|      7m 22s 	unique, imperfect              :   0.15%      94x
|      7m 22s 	multiple, cleanly composed     :   0.05%      35x
|      7m 22s 	multiple, non-perfect          :   0.04%      23x

**********************************************************************************************
*                                                                                            *
*      7m 22s Mapping sentence_atom nodes 2017 ==> 2021                                      *
*                                                                                            *
**********************************************************************************************

|      7m 22s Extending slot mapping 2017 ==> 2021 for sentence_atom nodes
|      7m 24s 	Done
..............................................................................................
.      7m 24s Statistics for 2017 ==> 2021 (sentence_atom)                                   .
..............................................................................................
|      7m 24s 	TOTAL                          : 100.00%   64486x
|      7m 24s 	unique, perfect                :  99.78%   64342x
|      7m 24s 	unique, imperfect              :   0.14%      92x
|      7m 24s 	multiple, cleanly composed     :   0.07%      44x
|      7m 24s 	multiple, non-perfect          :   0.01%       8x

**********************************************************************************************
*                                                                                            *
*      7m 24s Mapping clause nodes 2017 ==> 2021                                             *
*                                                                                            *
**********************************************************************************************

|      7m 24s Extending slot mapping 2017 ==> 2021 for clause nodes
|      7m 27s 	Done
..............................................................................................
.      7m 27s Statistics for 2017 ==> 2021 (clause)                                          .
..............................................................................................
|      7m 27s 	TOTAL                          : 100.00%   88101x
|      7m 27s 	unique, perfect                :  99.85%   87967x
|      7m 27s 	unique, imperfect              :   0.09%      75x
|      7m 27s 	multiple, cleanly composed     :   0.06%      50x
|      7m 27s 	multiple, non-perfect          :   0.01%       9x

**********************************************************************************************
*                                                                                            *
*      7m 27s Mapping clause_atom nodes 2017 ==> 2021                                        *
*                                                                                            *
**********************************************************************************************

|      7m 27s Extending slot mapping 2017 ==> 2021 for clause_atom nodes
|      7m 30s 	Done
..............................................................................................
.      7m 30s Statistics for 2017 ==> 2021 (clause_atom)                                     .
..............................................................................................
|      7m 30s 	TOTAL                          : 100.00%   90669x
|      7m 30s 	unique, perfect                :  99.86%   90543x
|      7m 30s 	unique, imperfect              :   0.08%      69x
|      7m 30s 	multiple, cleanly composed     :   0.06%      55x
|      7m 30s 	multiple, non-perfect          :   0.00%       2x

**********************************************************************************************
*                                                                                            *
*      7m 30s Mapping phrase nodes 2017 ==> 2021                                             *
*                                                                                            *
**********************************************************************************************

|      7m 30s Extending slot mapping 2017 ==> 2021 for phrase nodes
|      7m 34s 	Done
..............................................................................................
.      7m 34s Statistics for 2017 ==> 2021 (phrase)                                          .
..............................................................................................
|      7m 34s 	TOTAL                          : 100.00%  253187x
|      7m 34s 	unique, perfect                :  99.94%  253042x
|      7m 34s 	unique, imperfect              :   0.04%      93x
|      7m 34s 	multiple, cleanly composed     :   0.02%      50x
|      7m 34s 	multiple, non-perfect          :   0.00%       2x

**********************************************************************************************
*                                                                                            *
*      7m 34s Mapping phrase_atom nodes 2017 ==> 2021                                        *
*                                                                                            *
**********************************************************************************************

|      7m 34s Extending slot mapping 2017 ==> 2021 for phrase_atom nodes
|      7m 37s 	Done
..............................................................................................
.      7m 37s Statistics for 2017 ==> 2021 (phrase_atom)                                     .
..............................................................................................
|      7m 37s 	TOTAL                          : 100.00%  267519x
|      7m 37s 	unique, perfect                :  99.95%  267396x
|      7m 37s 	unique, imperfect              :   0.03%      84x
|      7m 37s 	multiple, cleanly composed     :   0.01%      39x

**********************************************************************************************
*                                                                                            *
*      7m 37s Mapping subphrase nodes 2017 ==> 2021                                          *
*                                                                                            *
**********************************************************************************************

|      7m 37s Extending slot mapping 2017 ==> 2021 for subphrase nodes
|      7m 39s 	Done
..............................................................................................
.      7m 39s Statistics for 2017 ==> 2021 (subphrase)                                       .
..............................................................................................
|      7m 39s 	TOTAL                          : 100.00%  113784x
|      7m 39s 	unique, perfect                :  63.33%   72063x
|      7m 39s 	multiple, one perfect          :  36.49%   41522x
|      7m 39s 	unique, imperfect              :   0.00%       3x
|      7m 39s 	multiple, cleanly composed     :   0.00%       4x
|      7m 39s 	multiple, non-perfect          :   0.15%     168x
|      7m 39s 	not mapped                     :   0.02%      24x

Writing mappings as TF edges

In [41]:
def writeMaps():
    for ((v1, v2), edge) in sorted(edges.items()):
        fName = "[email protected]{}-{}".format(v1, v2)
        caption(4, "Write edge as TF feature {}".format(fName))

        edgeFeatures = {fName: edge}
        metaData = {
            fName: {
                "description": "⚠️ Maps the nodes of version {} to {}".format(
                    v1, v2
                ),
                "encoder": "Dirk Roorda by a semi-automatic method",
                "see": "https://github.com/ETCBC/bhsa/blob/master/programs/versionMappings.ipynb",
                "valueType": "int",
                "edgeValues": True,
            }
        }
        activate(v2)
        TF.save(
            nodeFeatures={},
            edgeFeatures=edgeFeatures,
            metaData=metaData,
        )
In [42]:
caption(4, "Write mappings as TF edges")
for (v1, v2) in sorted(mappings.keys()):
    caption(0, "\t {:>4} ==> {:<4}".format(v1, v2))

writeMaps()
..............................................................................................
.      7m 45s Write mappings as TF edges                                                     .
..............................................................................................
|      7m 45s 	 2017 ==> 2021
..............................................................................................
.      7m 45s Write edge as TF feature [email protected]                                        .
..............................................................................................
..............................................................................................
.      7m 45s Active version is now -> 2021 <-                                               .
..............................................................................................
  0.00s Exporting 0 node and 1 edge and 0 config features to ~/github/etcbc/bhsa/tf/2021:
   |     3.44s T [email protected]       to ~/github/etcbc/bhsa/tf/2021
  3.44s Exported 0 node features and 1 edge features and 0 config features to ~/github/etcbc/bhsa/tf/2021
In [ ]: