Short-Range and Wide-Area Wireless

The previous lesson added an identity condition to association and counted what it cost coverage. But the whole measurement stayed at a single scale: a thirty-meter cell, distances in the tens of meters, a rate-tier ladder that climbs up to six. This scale is not all of wireless.

The same intent — “the client inside the boundary receives service” — is also built into a pairing bond spanning a few meters, and into a low-power bond stretching for kilometers. This lesson’s question is: with intent’s form held fixed, what does scale itself change? As range grows, what happens to the rate tier, where does false deny go, and is “receiving service” the same thing in every class?

The Three Classes of Range

Wireless bonds fall into three classes according to the area they intend to cover. The classes are not upgraded versions of one another; they are different answers to different intents.

Short range. Covers an area of a few meters and is mostly built between two ends: a peripheral device and the host that uses it, a sensor and the device that reads it. The topology is usually a pairing pair, not a cell. The power budget is small because the device runs on a battery; but because the distance is also small, signal strength stays high and the rate tier can climb. Pairing is this class’s own particular step: before the bond is built, the two ends recognize each other once.

Local range. This is the previous lessons’ cell: one access point, a radius in the tens of meters, many clients. The medium is shared, interference is a measurable cost, and the rate tier steps down with distance.

Wide area. Bonds that stretch for kilometers and run on low power. This class’s solution is to buy range with speed: it works over a narrow band, with small payloads, and infrequent transmission. A device sends a few tens of bytes of measurement a few times a day and stays silent in between. This is the duty cycle — the ratio of the time the device spends on the medium to total time. A sparse duty cycle protects both the battery and the medium.

What Trades for What

All three classes deal with the same three quantities: range, rate tier, and power budget. What is taken from one end is given to the other.

There are two ways to grow range. The first is raising power, and its cost was counted in the previous lessons: as power rises, the number of clients leaking outside the cell also rises. The second is thinning out the information carried — sending the same information over a longer time, in a narrower band, using fewer signal levels. A thinned-out signal can be pulled out from under the noise; in exchange, the number of bits carried per unit time falls. This is why the wide-area class’s rate-tier ceiling is low.

The classes’ distinguishing fields can be collected into a table. The values below are fictional and report no real band allocation, channel plan, or regulatory rule.

# taught dump , not executed
# band names, channel counts, and payload limits are fictional

class          band     channels  frame payload    duty cycle   topology
short range    band-a          6  up to 256 bytes   continuous   pairing pair
local range    band-b         12  up to 1500 bytes  continuous   cell
wide area      band-c          3  up to 64 bytes    sparse       star

The frame payload column produces a conclusion on its own: in the wide-area class, a message that does not fit in sixty-four bytes cannot be sent. An application running on top of this class has to design its message against this limit — protocol choice comes bundled with range choice.

Same Intent, Three Scales

Intent’s form is the same across all three classes: a radius is drawn and “the client inside receives service” is declared. What changes is the radius’s number. The short-range class promises twelve meters, local range thirty, wide area forty.

This is what keeps the measurement fair. Every class is audited against its own promise; a short-range bond is not counted flawed for failing to cover thirty meters. False admit and false deny are computed against the class’s own radius.

The measurement’s assumptions:

• WN58. Forty clients are produced from the shared fiction; distance and interference values are the same across all three classes. The only thing that changes is the class itself.
• WN59. Each class is defined by three numbers: power budget, intent radius, and rate-tier ladder. The local-range class’s ladder comes from the shared fiction; the other two ladders and the power values are fictional.
• WN60. In every class the oracle is that class’s own radius: 12 for short range, 30 for local, 40 for wide area. Intent’s form stays the same, only its number changes.
• WN61. Association means reaching the ladder’s lowest rung; a client whose tier comes out zero cannot associate.
• WN62. Tier numbers are relative speed steps; they carry no unit and can be summed within a class. Because the ladders are fictional, comparing totals across classes is read as an ordering of magnitude, not a ratio.
• WN63. The interference value is independent of class and lies between 0 and 12. In classes with a small power budget, the same interference eats a larger share of the budget.
• WN64. The set’s resolution is forty clients; the smallest measurable difference is 1/40 = 0.025. When a class’s within-intent population is smaller than forty, no finer difference is claimed over that subset.

Measurement

"""Same intent in three range classes.

Part 1 - each class's associated, highest tier reached, two-directional error.
Part 2 - tier distribution and the same client's tier across the three classes.
"""
SEED = 20260811
# (name, power, radius, rate-tier ladder) -- ladders and power values are fictional
CLASSES = (
    ("short range", 40, 12, ((30, 12), (26, 8), (20, 4))),
    ("local range", 52, 30, ((34, 6), (28, 4), (22, 2), (18, 1))),
    ("wide area", 70, 40, ((46, 2), (24, 1))),
)


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 tier(c, power, ladder):
    signal = power - c["distance"] - c["interference"]
    for threshold, k in ladder:
        if signal >= threshold:
            return k
    return 0


pool = clients()
print(f"clients {len(pool)} | distance {min(c['distance'] for c in pool)}"
      f"-{max(c['distance'] for c in pool)} | interference "
      f"{min(c['interference'] for c in pool)}-{max(c['interference'] for c in pool)}")
print()
print(f"{'class':<12s} {'radius':>6s} {'in intent':>9s} {'associated':>10s} "
      f"{'top':>3s} {'at top':>6s} {'total':>6s} {'per client':>10s} "
      f"{'false admit':>12s} {'false deny':>11s}")
for name, power, radius, ladder in CLASSES:
    tiers = [tier(c, power, ladder) for c in pool]
    d = gap(pool, lambda c, r=radius: cell_intent(c, r),
            lambda c, p=power, l=ladder: tier(c, p, l) > 0)
    top = max(tiers)
    admitted = d["correct_admit"] + d["false_admit"]
    print(f"{name:<12s} {radius:6d} {sum(cell_intent(c, radius) for c in pool):9d} "
          f"{admitted:10d} {top:3d} "
          f"{tiers.count(top):6d} {sum(tiers):6d} "
          f"{sum(tiers) / admitted:10.2f} "
          f"{d['false_admit']:12d} {d['false_deny']:11d}")
print()
print("tier distribution (0 means unable to associate)")
for name, power, radius, ladder in CLASSES:
    count = {}
    for c in pool:
        k = tier(c, power, ladder)
        count[k] = count.get(k, 0) + 1
    print(f"  {name:<12s} " + "  ".join(f"tier {k}: {count[k]:2d}"
                                         for k in sorted(count, reverse=True)))
print()
print("the same client in three classes")
print(f"  {'no':>3s} {'distance':>8s} {'interference':>12s} "
      + " ".join(f"{name:>12s}" for name, _, _, _ in CLASSES))
for no in (3, 11, 38, 26):
    c = pool[no - 1]
    print(f"  {c['no']:3d} {c['distance']:8d} {c['interference']:12d} "
          + " ".join(f"{tier(c, p, l):12d}" for _, p, _, l in CLASSES))

clients 40 | distance 6-44 | interference 0-12

class        radius in intent associated top at top  total per client  false admit  false deny
short range      12         8         11   8      7     72       6.55            3           0
local range      30        27         23   6      9     88       3.83            0           4
wide area        40        38         37   2     13     50       1.35            1           2

tier distribution (0 means unable to associate)
  short range  tier 8:  7  tier 4:  4  tier 0: 29
  local range  tier 6:  9  tier 4:  4  tier 2:  8  tier 1:  2  tier 0: 17
  wide area    tier 2: 13  tier 1: 24  tier 0:  3

the same client in three classes
   no distance interference  short range  local range    wide area
    3       13            0            8            6            2
   11       18            2            4            4            2
   38       31           11            0            0            1
   26       44            1            0            0            1

What Falls as Range Grows

The top column is the lesson’s main measure: the highest rate tier actually reached in each class is 8, 6, and 2. As range grows the ceiling falls, and this is not a configuration flaw but the trade-off itself. The at top column next to it moves the other way: the number of clients at the top tier is 7, 9, and 13. The wide-area class lifts a larger share of its population to its own ceiling — but that ceiling is very low.

The associated and total columns have to be read together. The wide-area class reaches 37 clients, the highest of the three; the tier total it carries is 50, the lowest of the three. The local-range class reaches only 23 clients but carries 88. Short range carries 72 with 11 clients. The class that reaches the most clients carries the least speed. Because the ladders are fictional, this comparison is an ordering of magnitude, not a ratio.

The per client column is their quotient, and it falls in a single direction as range grows: 6.55, 3.83, 1.35. Reaching more clients does not grow the carried total; it compresses the share. This column shows that choosing a class is as much a density decision as it is a coverage decision.

The distribution table says the same thing once more. In the wide-area class, 24 of forty clients sit at the lowest tier; only three cannot associate at all. In the local-range class, 17 clients cannot associate at all, but nine of those who do are at the top tier. The two classes have chosen two different things: one chose leaving no one out, the other chose serving whoever it reaches fast.

The last table shows this client by client. Client 3 is at thirteen meters with no interference: it gets tier 8 on short range, 6 on local, 2 on wide area — the same client, the same spot, three different speeds. Client 26 is at forty-four meters: it cannot associate at all in the two nearer classes, and bonds at tier 1 on wide area. Client 38 is at thirty-one meters but its interference is 11; the local-range class’s budget cannot absorb this interference and the client counts as outside the cell, while the wide-area budget can absorb it.

The Sign of the Error Is the Result of the Tuning

The two error columns do not move in a single direction with range, and this is the lesson’s second result.

Short range: 3 false admit, 0 false deny. This class keeps its promise and then some. All eight of the eight clients inside the twelve-meter radius associate, and on top of that three more clients from outside the radius get in. The power budget is generous relative to the given radius.

Local range: 0 false admit, 4 false deny. This class runs the other way: no leakage at all, but it cannot serve four clients inside its own cell. The budget is tight relative to the given radius.

Wide area: 1 false admit, 2 false deny. Both directions are small and balanced.

The pattern is: the sign of the error comes not from the class’s range but from how the radius is tuned against the power budget. The same class could be moved from false admit to false deny by growing its radius by two meters. Choosing a range class does not resolve this error; it only sets at which scale it will happen. This is why a comparison that reports only one direction ranks all three classes wrong: looking at false admit makes short range look worst, looking at false deny makes local range look worst.

Interference’s share also changes by class. The interference value is the same across all three classes and is at most 12; but that 12 is more than a quarter of a forty-unit budget, and less than a sixth of a seventy-unit budget. In small-budget classes interference dominates, in large-budget classes distance dominates — client 38’s situation across the three classes is a one-line proof of this.

Medium Access and How the Identity Condition Takes Shape by Class

The per client column raises the next question: how do the thirty-seven clients sharing the same medium take their turn? The three classes solve this in three different ways.

In short range the bond is built through pairing, and the two ends usually follow a schedule; transmission moments are known in advance, and there is almost no contention. In local range the medium is shared and the right to transmit is won through contention; as the client count grows, contention’s share grows too. In wide area, contention is not resolved, it is thinned out: the device transmits a few times a day, with a short payload, mostly without agreeing with a central point first. Collisions happen and the lost transmission is retried; because the sparse duty cycle keeps collision probability low, this comes cheap.

The previous lesson’s identity condition also changes shape by class. In local range the condition is run again at every association. In short range the condition runs once, at the moment of pairing; the two ends recognize each other at that moment, and later bonds use that recognition — the condition’s round trip has been taken out of association and moved to a one-time step. In wide area the device is recognized once as it joins the network, and later transmissions are verified one by one; there is usually no separate step called association. What the three classes share is this: the identity condition does not disappear, only which moment it is placed at changes.

Topology comes bundled with these three answers too. Short range’s pairing pair, local range’s cell around an access point, and wide area’s star — all three are names for where medium access gets resolved.

Summary

• The three range classes are not upgraded versions of one another; they are three separate answers that trade range, rate tier, and power budget differently.
• As range grows, the highest rate tier reached falls 8 → 6 → 2; the number of clients at the top tier rises 7 → 9 → 13, because the lower the ceiling, the easier it is to reach.
• The class that reaches the most clients carries the least speed: wide area, 37 clients and 50 tiers; local range, 23 clients and 88 tiers.
• The sign of the error does not come from range: short range gives 3/0, local range 0/4, wide area 1/2; what decides it is how the radius is tuned against the power budget.
• The same client gets three different tiers in the three classes; interference dominates in small-budget classes, distance dominates in large-budget ones.

Next Step

In the measurement of all three classes, the serving point was singular and never moved from its spot. The client moved away, its tier dropped, and 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. The next lesson builds cellular architecture’s core components and measures handover: how much should two cells’ coverage overlap, how do false admit and ping-pong clients grow as overlap grows, and where does false deny come from as overlap narrows?