Mobile Networks

In all three range classes of the previous lesson, the serving point was singular and never moved from its spot. As the client moved away its tier dropped, eventually it could not associate, and no one offered it a different point. Yet the other way to cover a wide area is not to strengthen a single point but to line up many points side by side and hand the client off between them.

This is cellular architecture’s founding idea. This lesson’s question has two parts: who makes the handover decision, and how much should two cells’ coverage overlap? The second question is a design variable, and it is paid for in both directions at once.

Cellular Architecture’s Core Components

The architecture splits into two halves. On the radio access side stand base stations; a base station carries one or more cells, and every cell has an identity. Cells are neighbors of one another, and every cell knows its neighbor list — handover starts from this list.

On the core side, three jobs get done. Mobility management keeps track of where every client is; for a connected client this information is at cell level, for an idle client it is at tracking area level. An idle client’s exact cell is not known and does not need to be; when the client needs to be reached, a page goes out to the whole tracking area. The gateway is where the data plane exits to the outside network. The subscriber register holds credentials and permissions.

On the client side, two components are counted: the identity module, which carries the credential, and the measurement report, which reports neighboring cells’ signal strength.

# taught layout , not executed
# component names and identity values are fictional

radio access side                  core side
  base station                       mobility management
    cell A (identity 1001)             connected client record
    cell B (identity 1002)             tracking area record
  handover interface                 gateway
    neighbor list                      data plane exit
    context transfer                 subscriber register
                                        credential and permission record

client
  identity module     : carries the credential
  measurement report  : reports neighboring cells' signal strength

The real distinction this layout carries is that the control plane and the data plane are separate. Handover is a control-plane job: it covers the decision, the transfer of context, and updating the record. The data plane does not stop in the meantime; the flow is carried from the old cell to the new one. The two planes being separate is the condition for service not being interrupted during a handover.

Handover

Handover is a change of the serving cell, and it is roaming’s cellular counterpart. But the decision flow runs backward. In a wireless local area network, the one that measures and the one that decides are both the client. In cellular architecture, the client measures, the network decides: the client reports neighboring cells’ signal strength through the measurement report, the serving cell evaluates the report, agrees on context with the target cell, and sends the handover command to the client.

This reversal has two consequences. First, the decision is gathered in a single hand: the network can also factor in neighboring cells’ load and state; the client cannot see these. Second, the decision carries a round-trip debt — no handover happens before the report goes out and the command comes back.

The decision’s threshold is the handover margin: a handover is not started until the target cell’s signal strength exceeds the serving cell’s by this many units. If the margin were zero, every client whose signal from the two cells was close would be handed back and forth continuously. In this lesson the margin is held fixed; the only thing changed is inter-site distance.

A handover failing to complete is a separate case. If, after the report is sent, the serving cell’s signal drops below the threshold before the command arrives, the bond breaks; at this point the client cannot wait for the handover, it starts re-establishing with whichever cell it finds best and builds context from scratch. This is the exact opposite of the continuity handover is trying to buy, and it is a late handover decision’s real cost. This case does not show up as a separate column in the measurement; it stands behind the missed handover count.

How Many Kinds of Handover There Are, and the Idle Client

Not every handover carries the same cost. If the two cells are on the same base station, context is carried inside the station and the core side does not need to know. If the two cells are on separate base stations, context passes through the handover interface and the record in mobility management gets updated. If the data plane’s exit point also changes, one more operation is needed on the gateway side. Three operations carrying the same name mean three separate loads on the control plane; this is why the neighbor list determines not only which cells are neighbors but also which kind of handover each will be.

Sectorisation directly affects this table. When a base station carries multiple cells through directional antennas, handovers between those cells fall into the cheap kind; growing the cell count does not cost the same as spreading cells across separate stations.

The idle client carries a separate balance. A connected client’s cell is known; an idle client’s tracking area alone is known, and when it needs to be reached a page goes out to the whole area. If the tracking area is grown, the client does not send a location update unless it changes area, and the control plane is relieved; in exchange, every page spreads across more cells. If the area is shrunk, paging gets cheaper and updating gets more expensive. This is another appearance, inside the architecture, of the two directions the course keeps counting: a setting that cheapens one direction makes the other more expensive, and a measurement that looks at only one direction ranks both wrong.

Overlap Is a Design Variable

As two cells draw closer to each other, their coverage overlaps. Overlap guarantees leaving no gap and provides an area where a handover can complete; in exchange, the two cells cover the same ground a second time, and clients around the midline stay unstable between the two cells.

The measurement’s assumptions:

• WN65. Clients sit on the line joining cells A and B. Every client’s distance to A comes from the shared fiction; its distance to B is the absolute value of the difference between the inter-site distance and its distance to A.
• WN66. The two cells’ power is equal, at 58; the design radius is 30 for both. Interference is the client’s own value and is the same for both cells.
• WN67. Service intent is the union of the two design radii: if the client is within the design radius of either cell, it should receive service. Intent is built from the shared fiction’s cell intent, using the distance to the nearer cell.
• WN68. Handover intent is a separate question: a handover should happen only if it raises the client’s rate tier. A handover that does not change the tier is unnecessary.
• WN69. The handover mechanism looks for two conditions: the target cell’s signal has to exceed the association threshold, and exceed the serving cell’s signal by the handover margin. The handover margin is 3 and stays fixed throughout the measurement.
• WN70. An overlapping client is one that receives above-threshold signal from both cells. A ping-pong client is, among overlapping clients, one whose two-signal difference falls below the handover margin.
• WN71. A client left in the gap is one that cannot exceed the threshold from either cell.
• WN72. The set’s resolution is forty clients; the smallest measurable difference is 1/40 = 0.025.

Measurement

"""Handover and coverage overlap.

Part 1 - as overlap changes, service's two-directional error.
Part 2 - the handover decision's own two-directional error.
"""
SEED = 20260811
THRESHOLD = 18
TIERS = ((34, 6), (28, 4), (22, 2), (18, 1))
POWER = 58
MARGIN = 3
SPANS = (30, 45, 60, 75, 90)


def generator(seed):
    d = seed % 2147483646 + 1

    def r(n):
        nonlocal d
        d = (d * 48271) % 2147483647
        return d % n
    return r


def gap(events, intent, mechanism):
    d = {"correct_admit": 0, "correct_deny": 0, "false_admit": 0, "false_deny": 0}
    for e in events:
        n, m = intent(e), mechanism(e)
        if n and m:
            d["correct_admit"] += 1
        elif not n and not m:
            d["correct_deny"] += 1
        elif m:
            d["false_admit"] += 1
        else:
            d["false_deny"] += 1
    return d


def clients(count=40, seed=SEED):
    r, pool = generator(seed), []
    for i in range(count):
        pool.append({"no": i + 1, "distance": 5 + r(41), "interference": r(13)})
    return pool


def cell_intent(c, radius=30):
    return c["distance"] <= radius


def pair(c, span):
    """Distance to and signal from both cells."""
    da, db = c["distance"], abs(span - c["distance"])
    return da, db, POWER - da - c["interference"], POWER - db - c["interference"]


def tier(signal):
    for threshold, k in TIERS:
        if signal >= threshold:
            return k
    return 0


def service_intent(c, span):
    """The design's promise: the union of the two cells' radii is covered."""
    da, db, _, _ = pair(c, span)
    return cell_intent({"distance": min(da, db)})


def service(c, span):
    _, _, ia, ib = pair(c, span)
    return max(ia, ib) >= THRESHOLD


def handover_intent(c, span):
    """A handover should happen only if it raises the rate tier."""
    _, _, ia, ib = pair(c, span)
    return tier(ib) > tier(ia)


def handover(c, span):
    _, _, ia, ib = pair(c, span)
    return ib >= THRESHOLD and ib - ia >= MARGIN


pool = clients()
print(f"clients {len(pool)} | inside cell {sum(cell_intent(c) for c in pool)} | "
      f"served by a single cell "
      f"{sum(1 for c in pool if POWER - c['distance'] - c['interference'] >= THRESHOLD)}")
print()
print("service: union of the two cells")
print(f"{'span':>4s} {'overlapping':>11s} {'ping-pong':>9s} {'in gap':>6s} "
      f"{'served':>6s} {'false admit':>11s} {'false deny':>11s}")
for span in SPANS:
    d = gap(pool, lambda c, s=span: service_intent(c, s),
            lambda c, s=span: service(c, s))
    overlapping = pingpong = in_gap = 0
    for c in pool:
        _, _, ia, ib = pair(c, span)
        if ia >= THRESHOLD and ib >= THRESHOLD:
            overlapping += 1
            if abs(ia - ib) < MARGIN:
                pingpong += 1
        elif ia < THRESHOLD and ib < THRESHOLD:
            in_gap += 1
    print(f"{span:4d} {overlapping:11d} {pingpong:9d} {in_gap:6d} "
          f"{d['correct_admit'] + d['false_admit']:6d} "
          f"{d['false_admit']:11d} {d['false_deny']:11d}")
print()
print("handover: must raise the tier")
print(f"{'span':>4s} {'intended handover':>17s} {'handover made':>13s} "
      f"{'false admit':>11s} {'false deny':>11s}")
for span in SPANS:
    d = gap(pool, lambda c, s=span: handover_intent(c, s),
            lambda c, s=span: handover(c, s))
    print(f"{span:4d} {sum(handover_intent(c, span) for c in pool):17d} "
          f"{d['correct_admit'] + d['false_admit']:13d} "
          f"{d['false_admit']:11d} {d['false_deny']:11d}")

clients 40 | inside cell 27 | served by a single cell 31

service: union of the two cells
span overlapping ping-pong in gap served false admit  false deny
  30          31         1      0     40           0           0
  45          28         3      0     40           0           0
  60          11         4      1     39           0           1
  75           1         0      7     33           7           1
  90           0         0      9     31           5           1

handover: must raise the tier
span intended handover handover made false admit  false deny
  30                27            30           3           0
  45                19            21           2           0
  60                13            12           0           1
  75                 2             2           0           0
  90                 0             0           0           0

As Overlap Narrows

The bottom row is a check point. At span 90, the second cell reaches no one: overlapping is 0, handover is 0, and the service table reproduces the shared fiction’s single-cell power-58 row exactly — 31 served, 5 false admit, 1 false deny. The two-cell measurement collapses into the single-cell measurement once the cells are far enough apart.

As the span narrows, both of service’s errors fall: at 60 they are 0 and 1; at 45 and 30 both are 0. All forty of the forty clients receive service, and none is outside intent. On paper, this is a flawless configuration — and this is exactly where the lesson’s warning sits.

The cost sits in the overlapping column: at span 30, 31 clients receive above-threshold signal from both cells at once. Thirty-one of the forty clients stand on ground both cells cover; the second cell is not extending coverage, it is covering the same ground a second time. The configuration that zeroes out the error columns is the configuration that re-spends half of coverage. This cost does not show up in the two directions the gap function counts; it shows up in a different column.

The span 75 row carries the warning in the other direction. False admit rises to 7 here — higher than the single cell’s 5. As the two cells pull apart, each leaks from its own edge, and the leaks add up; adding a cell does not divide the leak, it multiplies it. In the same row, 7 clients are left in the gap: neither cell exceeds the threshold for them. The same configuration both leaks extra and leaves a gap.

The ping-pong column behaves unexpectedly: 1, 3, 4, 0, 0. The widest overlap has the fewest unstable clients. The reason is this: instability does not depend on the size of the overlap but on client density around the two cells’ midline. At span 30 the midline sits at 15 meters, and few clients sit there; at span 60 the midline shifts to 30 meters, and that is where the crowd happens to fall. Instability is not a coverage measure, it is a placement measure.

Handover’s Own Two Errors

The second table measures the handover decision against its own intent: a handover is correct only if it raises the rate tier.

At span 30, intent wants 27 handovers, the mechanism makes 30, and 3 are unnecessary — handovers that do not change the tier. At span 45 the same direction continues: 2 unnecessary handovers. When overlap is generous, the handover margin gets exceeded for a large number of clients, but the margin it exceeds by is not enough to raise the tier. This is an operation wasted on the control plane: report, context transfer, and command, with no gain at all.

At span 60 the sign flips: unnecessary handovers is 0, missed handovers is 1. As overlap narrows, fewer clients exceed the handover margin, and the margin can end up blocking a handover that would have raised the tier. The same fixed margin produces false admit under generous overlap and false deny under narrow overlap. The error’s direction changed without the margin changing at all; the only thing that changed was the distance between the cells.

Placing the two tables side by side gives the lesson’s result. The configurations that look best in the service table — spans 30 and 45 — are the configurations that produce the most unnecessary handovers in the handover table. An audit that looks at only one table gives opposite answers depending on which one it looks at.

Summary

• Cellular architecture splits into a radio access side and a core side; handover is a control-plane job, and the data plane is carried from the old cell to the new one while it happens.
• The network makes the decision, not the client: the client sends the measurement report, the serving cell agrees on context with the target and sends the handover command; this gathers the decision in a single hand and brings a round-trip debt.
• As inter-site distance is pulled in from 90 to 30, service’s two errors fall from 5/1 to 0/0, but overlapping clients rise from 0 to 31; zero error is paid for by spending coverage a second time.
• At span 75, false admit becomes 7 — higher than the single cell’s 5 — and in the same row 7 clients are left in the gap; adding a cell does not divide the leak, it multiplies it.
• A fixed handover margin produces 3 unnecessary handovers under generous overlap and 1 missed handover under narrow overlap; what decides the error’s direction is not the margin’s value but the distance between the cells.

Next Step

Throughout this course’s wireless half, what drew the boundary was always the same kind of thing: distance, interference, power budget, generation ceiling, cell placement. All of them are properties of the medium. No one sat down and wrote a rule saying “let this one through, stop that one”; the boundary emerged as a byproduct of physics and placement, and it departed from intent in both directions at once.

The next topic takes the boundary out of the medium’s hands. Once the boundary is written — once who gets through and who is stopped is declared explicitly, as an ordered list — does the deviation from intent disappear, or does it only change location? The next lesson opens this question, and the two directions it counts stay the same: false admit and false deny.