Computer NetworksLine Coding - Bipolar

Line Coding: Bipolar Encoding Schemes

LevelIntermediate

Duration60 mins

TopicLine Coding - Bipolar

2 / 5

B8ZS (Bipolar with 8-Zero Substitution)

Solving AMI's Achilles Heel

As we explored in the previous page, Alternate Mark Inversion delivers elegant DC balance and built-in error detection—but suffers from a critical vulnerability: long runs of zeros produce no signal transitions, causing receiver clock drift and synchronization failures. In the telecommunications infrastructure of North America, this problem demanded an immediate solution.

The challenge was considerable. Any solution had to:

Maintain backward compatibility with existing AMI-based equipment
Preserve DC balance to remain transformer-compatible
Guarantee transitions even with arbitrary data containing many zeros
Introduce minimal overhead to maintain bandwidth efficiency
Be economically implementable with existing technology

Bipolar with 8-Zero Substitution (B8ZS) emerged as the North American solution to this challenge, becoming the standard encoding scheme for T1 lines (1.544 Mbps) and DS1 signals throughout the United States and Canada.

What You Will Master

By the end of this page, you will understand the complete design, logic, and implementation of B8ZS. You'll learn how intentional bipolar violations are used as markers, how the substitution pattern maintains DC balance, and how B8ZS achieves clock recovery without sacrificing any of AMI's advantages.

The Core Innovation: Intentional Violations

B8ZS is built on a surprisingly clever insight: if bipolar violations are normally errors, we can use deliberate violations as signals.

In pure AMI, a bipolar violation—two consecutive marks with the same polarity—indicates a transmission error. The receiver detects these violations and reports them as errors. But what if we intentionally insert violations in a specific, recognizable pattern?

This is exactly what B8ZS does. When the encoder encounters a sequence of eight consecutive zeros, it replaces that sequence with a special pattern containing intentional bipolar violations. The receiver recognizes this pattern, knows it represents eight zeros, and decodes accordingly—while the violations ensure signal transitions occur for clock recovery.

The Name Decoded

B8ZS = Bipolar with 8-Zero Substitution. The scheme substitutes (replaces) every sequence of 8 consecutive zeros with a specific pattern. The 'Bipolar' prefix indicates it's based on AMI-style bipolar encoding.

Why eight zeros?

The choice of eight zeros as the trigger threshold represents an engineering trade-off:

Threshold	Trade-offs
4 zeros	More frequent substitution → more overhead, but better sync
8 zeros	Balanced: rare enough to minimize overhead, frequent enough for T1 timing requirements
16 zeros	Too few substitutions → synchronization may still fail

For T1 lines operating at 1.544 Mbps, eight zeros represents approximately 5.2 microseconds of silence. This is near the limit of what receivers can tolerate without timing drift—making 8 the optimal threshold.

The B8ZS Substitution Pattern

The heart of B8ZS is its substitution pattern. When eight consecutive zeros are detected, they are replaced with a specific eight-symbol pattern that:

Contains signal transitions (for clock recovery)
Contains recognizable bipolar violations (so the receiver knows it's a substitution)
Maintains overall DC balance (so AMI's transformer compatibility is preserved)

The B8ZS substitution patterns:

The pattern used depends on the polarity of the previous mark (the last 1-bit before the string of zeros):

Previous Mark Polarity	8-Zero Substitution Pattern
Positive (+V)	0 0 0 + - 0 - +
Negative (-V)	0 0 0 - + 0 + -

In shorthand notation:

After +V: 000+-0-+
After -V: 000-+0+-

Anatomy of the substitution pattern:

Let's analyze the pattern 000+-0-+ (used after a positive mark):

Position:    1   2   3   4   5   6   7   8
Original:    0   0   0   0   0   0   0   0
B8ZS:        0   0   0   +   -   0   -   +
                         ↑   ↑       ↑   ↑
                         │   │       │   │
                         V   V       V   V
                        Violation  Violation
                        (same      (same  
                        polarity   polarity
                        as prev)   as pos 5)

The two bipolar violations:

Position 4 (+): After the previous positive mark, the next mark should be negative per AMI rules. Instead, it's positive—a bipolar violation.
Position 7 (-): This follows position 5 (-), so the next mark should be positive. Instead, it's negative—another bipolar violation.

Why two violations?

Using two violations in a specific pattern makes the substitution highly recognizable and distinguishable from random errors. A single-bit error might create one violation, but creating exactly this pattern of two violations in positions 4 and 7 is virtually impossible by chance.

DC Balance Verification

The substitution pattern maintains DC balance: in 000+-0-+, the sum of voltages is (+1) + (-1) + (-1) + (+1) = 0. This is critical—any net DC component would defeat AMI's primary advantage. Both substitution patterns sum to zero.

B8ZS Encoding Algorithm

The B8ZS encoding algorithm processes the input bit stream and applies both AMI encoding and zero-substitution rules.

b8zs_encoder.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
def b8zs_encode(bit_stream: list[int]) -> list[int]:
    """
    Encode a binary bit stream using B8ZS (Bipolar with 8-Zero Substitution).
    
    Algorithm:
    1. Scan for sequences of 8 consecutive zeros
    2. Replace each 8-zero sequence with the appropriate substitution pattern
    3. Apply AMI encoding to the (possibly modified) stream
    
    Args:
        bit_stream: List of binary values (0s and 1s)
    
    Returns:
        List of voltage levels: -1, 0, or +1
    """
    # Track the polarity for AMI encoding
    current_polarity = 1  # Start positive
    encoded_signal = []
    
    i = 0
    while i < len(bit_stream):
        # Check for 8 consecutive zeros
        if i <= len(bit_stream) - 8:
            if all(bit_stream[i:i+8] == [0] * 8 for _ in [0]):
                if bit_stream[i:i+8] == [0, 0, 0, 0, 0, 0, 0, 0]:
                    # Apply B8ZS substitution based on previous polarity
                    # The "previous polarity" is what the LAST mark was
                    # which is the NEGATIVE of current_polarity 
                    # (since current_polarity is what the NEXT mark will be)
                    last_mark_polarity = -current_polarity
                    
                    if last_mark_polarity > 0:  # Last mark was positive
                        # Pattern: 0 0 0 + - 0 - +
                        substitution = [0, 0, 0, 1, -1, 0, -1, 1]
                    else:  # Last mark was negative
                        # Pattern: 0 0 0 - + 0 + -
                        substitution = [0, 0, 0, -1, 1, 0, 1, -1]
                    
                    encoded_signal.extend(substitution)
                    # After substitution, polarity state is preserved
                    # (both patterns have equal + and - pulses)
                    i += 8
                    continue
        
        # Normal AMI encoding for non-substituted bits
        if bit_stream[i] == 0:
            encoded_signal.append(0)
        else:
            encoded_signal.append(current_polarity)
            current_polarity = -current_polarity
        i += 1
    
    return encoded_signal
 
 
def b8zs_decode(signal: list[int]) -> list[int]:
    """
    Decode a B8ZS signal back to binary.
    
    Algorithm:
    1. Scan for B8ZS substitution patterns
    2. Replace substitution patterns with 8 zeros
    3. Decode remaining signal using AMI rules
    """
    decoded_bits = []
    i = 0
    
    while i < len(signal):
        # Check for B8ZS substitution pattern (8 symbols)
        if i <= len(signal) - 8:
            segment = signal[i:i+8]
            
            # Pattern after positive mark: [0, 0, 0, +1, -1, 0, -1, +1]
            if segment == [0, 0, 0, 1, -1, 0, -1, 1]:
                decoded_bits.extend([0, 0, 0, 0, 0, 0, 0, 0])
                i += 8
                continue
            
            # Pattern after negative mark: [0, 0, 0, -1, +1, 0, +1, -1]
            if segment == [0, 0, 0, -1, 1, 0, 1, -1]:
                decoded_bits.extend([0, 0, 0, 0, 0, 0, 0, 0])
                i += 8
                continue
        
        # Normal AMI decoding: non-zero = 1, zero = 0
        decoded_bits.append(0 if signal[i] == 0 else 1)
        i += 1
    
    return decoded_bits
 
 
# Example demonstrating B8ZS substitution
print("=== B8ZS Encoding Example ===
")
 
# Data with 8 consecutive zeros
data_with_zeros = [1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1]
print(f"Original data:   {data_with_zeros}")
 
# Encode with B8ZS
encoded = b8zs_encode(data_with_zeros)
print(f"B8ZS encoded:    {encoded}")
 
# Notice: positions 3-10 contain the substitution pattern
# The violations at positions 4 (+1 after +1) and 7 (-1 after -1)
# mark this as a B8ZS substitution
 
# Decode back
decoded = b8zs_decode(encoded)
print(f"Decoded data:    {decoded}")
 
# Verify correct round-trip
print(f"
Round-trip correct: {data_with_zeros == decoded}")

Step-by-step encoding example:

Let's trace through encoding the sequence 1 0 0 0 0 0 0 0 0 1 1 0 1:

Bit 1 (value: 1): First mark, encode as +1. Polarity flips to -1.
Bits 2-9 (eight 0s): Detected as 8-zero run. Last mark was +1, so use pattern 000+-0-+.
Bit 10 (value: 1): Normal mark, polarity is still -1 (preserved by substitution), encode as -1. Flip to +1.
Bit 11 (value: 1): Normal mark, encode as +1. Flip to -1.
Bit 12 (value: 0): Encode as 0.
Bit 13 (value: 1): Normal mark, encode as -1.

Result: [+1, 0, 0, 0, +1, -1, 0, -1, +1, -1, +1, 0, -1]

Why the Substitution Pattern Works

The B8ZS substitution pattern is carefully engineered to satisfy all requirements simultaneously. Let's verify each property:

Pattern Properties

•DC Balance: Pattern 000+-0-+ has voltages [0,0,0,+V,-V,0,-V,+V]. Sum = +V-V-V+V = 0. ✓
•Transitions Guaranteed: The pattern contains 4 non-zero pulses, ensuring at least 4 transitions per 8-bit period. ✓
•Uniquely Identifiable: The two bipolar violations at specific positions (4 and 7) create a signature that cannot occur in valid AMI. ✓
•Polarity Preservation: Equal positive and negative pulses mean the polarity state is unchanged after substitution. ✓
•Fixed Length: Exactly 8 symbols replace exactly 8 zeros—no expansion or compression. ✓

The Elegance of Duality

Having two substitution patterns (one for each previous polarity) ensures the pattern is always recognizable. If we used a single pattern regardless of previous polarity, it might accidentally look like valid AMI in some contexts. The duality eliminates this ambiguity.

Violation structure analysis:

In pattern 000+-0-+ (after positive mark):

Position:  1   2   3   4   5   6   7   8
Value:     0   0   0   +   -   0   -   +

Expected AMI after position 4 (+): next mark should be -
Actual value at position 5: - ✓ (valid)

Expected AMI after position 5 (-): next mark should be +
Actual value at position 7: - ✗ (VIOLATION)

Expected AMI after position 7 (-): next mark should be +
Actual value at position 8: + ✓ (valid)

Wait—where's the first violation? It's at position 4 itself:

Last mark before substitution: + (positive)
Expected first mark in substitution: - (should alternate)
Actual value at position 4: + ✗ (VIOLATION)

So the violations are:

Position 4: Same polarity as the previous mark (before the zeros)
Position 7: Same polarity as position 5

Clock Recovery Mechanism

The primary purpose of B8ZS is enabling reliable clock recovery—the process by which the receiver synchronizes its sampling clock with the transmitted signal. Understanding this mechanism is essential for appreciating why B8ZS enables long-distance digital transmission.

How clock recovery works:

Modern receivers use Phase-Locked Loops (PLLs) to track the transmitter's clock. The PLL:

Detects signal transitions (edges between voltage levels)
Compares transition timing to its local clock
Adjusts the local clock frequency to minimize timing error
Uses the synchronized clock to sample bit values

The critical requirement: transitions must occur frequently enough for the PLL to maintain lock.

B8ZS transition guarantee:

With B8ZS, no matter what data is transmitted:

Maximum gap between transitions: At most 7 bit periods (the zeros before the substitution pulses begin)
Minimum transitions per 8-bit period: 4 (from the substitution pattern pulses)

This is sufficient for T1/DS1 clock recovery requirements:

Metric	Pure AMI	B8ZS
Max zeros without transition	Unlimited	3 consecutive
Transition density (worst case)	0%	50% (4/8)
Clock recovery reliability	Data-dependent	Guaranteed
Suitable for arbitrary data	No	Yes

PLL Timing Requirements

T1 PLL specifications typically require at least one transition per 15-20 bit periods to maintain lock. B8ZS guarantees transitions at least every 7 bit periods (when hitting maximum zeros before substitution kicks in), providing comfortable margin even with low-cost oscillators.

transition_analysis.py
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
def analyze_transitions(signal: list[int]) -> dict:
    """
    Analyze transition characteristics of an encoded signal.
    
    Transitions occur when the signal changes from one level to another.
    """
    transitions = []
    last_level = None
    last_transition_pos = 0
    max_gap = 0
    gaps = []
    
    for i, level in enumerate(signal):
        if level != last_level and last_level is not None:
            gap = i - last_transition_pos
            gaps.append(gap)
            if gap > max_gap:
                max_gap = gap
            transitions.append(i)
            last_transition_pos = i
        last_level = level
    
    return {
        "total_symbols": len(signal),
        "transition_count": len(transitions),
        "transition_density": len(transitions) / len(signal) if signal else 0,
        "max_gap_between_transitions": max_gap,
        "average_gap": sum(gaps) / len(gaps) if gaps else 0,
        "clock_recovery_safe": max_gap <= 15  # T1 PLL requirement
    }
 
 
# Compare AMI vs B8ZS for problematic data
problematic_data = [1] + [0] * 20 + [1]  # Long zero run
 
# Pure AMI encoding (no substitution)
def ami_only_encode(bits):
    polarity = 1
    result = []
    for bit in bits:
        if bit == 0:
            result.append(0)
        else:
            result.append(polarity)
            polarity = -polarity
    return result
 
ami_signal = ami_only_encode(problematic_data)
b8zs_signal = b8zs_encode(problematic_data)
 
print("Data with 20 consecutive zeros:")
print(f"
Pure AMI: {analyze_transitions(ami_signal)}")
print(f"B8ZS:     {analyze_transitions(b8zs_signal)}")
 
# Pure AMI: max_gap = 20+ (CLOCK RECOVERY FAILURE)
# B8ZS:     max_gap ≤ 7  (Clock recovery guaranteed)

Implementation in T1/DS1 Systems

B8ZS is the standard encoding scheme for T1 digital transmission systems throughout North America. Understanding its role in this infrastructure provides essential context for telecommunications engineering.

The T1 system hierarchy:

T1 (or DS1) is a digital transmission standard operating at 1.544 Mbps:

24 voice channels × 64 Kbps = 1.536 Mbps
Plus 8 Kbps framing overhead = 1.544 Mbps
Frame structure: 193 bits (192 payload + 1 framing bit)
Frame rate: 8,000 frames per second

T1/DS1 Specifications with B8ZS
Parameter	Value	Notes
Line Rate	1.544 Mbps	Standard North American rate
Encoding	B8ZS	Ensures clock recovery for all data patterns
Pulse Shape	Bipolar Return-to-Zero	50% duty cycle pulses
Voltage Levels	±3V nominal	Measured at DSX-1 cross-connect
Maximum Cable Length	6,000 feet (copper)	Without repeaters
Error Monitoring	Bipolar Violations	B8ZS violations don't count as errors

The "Clear Channel" capability:

Before B8ZS, T1 systems used alternative methods to ensure sufficient ones density:

Bit stuffing: Forcing certain bit positions to be 1s
Bit robbery: Using the least significant bit of voice samples for signaling

These methods limited usability for data transmission because not all 64 Kbps were available for user data.

B8ZS enables Clear Channel Capability (CCC)—full 64 Kbps per channel for arbitrary data:

Feature	Without B8ZS	With B8ZS
Usable bits per channel	56 Kbps (7 bits × 8 kHz)	64 Kbps (8 bits × 8 kHz)
Arbitrary data support	No	Yes
ISDN compatibility	Limited	Full
Modern data protocols	Problematic	Transparent

Historical Impact

B8ZS enabled the transition from voice-only T1 lines to modern data services. Without clear channel capability, technologies like ISDN PRI (23 B-channels + 1 D-channel at 64 Kbps each) would have been impossible. B8ZS was a prerequisite for the digital data revolution on existing telecommunications infrastructure.

B8ZS Compared to Alternatives

B8ZS exists in an ecosystem of encoding schemes, each with distinct trade-offs. Understanding these comparisons helps engineers select appropriate schemes for different applications.

Line Coding Scheme Comparison
Scheme	Zero Handling	DC Component	Transition Density	Application
AMI	None	Zero	Data-dependent	Low-ones data only
B8ZS	8-zero substitution	Zero	≥50% (worst case)	T1/DS1 (North America)
HDB3	4-zero substitution	Zero	≥75% (worst case)	E1 (Europe, ITU)
Manchester	Every bit transitions	Zero	100%	Ethernet (10 Mbps)
4B/5B + NRZI	Block encoding	Low	≥80% (guaranteed)	Fast Ethernet, FDDI

B8ZS Advantages

•Backward compatible with AMI: B8ZS signals can be partially interpreted by older AMI-only equipment (though with errors)
•Minimal overhead: Only 8-zero sequences are modified; sparse zero runs pass unchanged
•Simple hardware: Detection and substitution logic is straightforward to implement
•Proven reliability: Decades of deployment in production telecommunications networks

B8ZS Limitations

•Regional: Primarily North American; European systems use HDB3 instead
•Error monitoring complexity: Must distinguish intentional violations from real errors
•Still allows 7-zero gaps: Not suitable for applications requiring more dense transitions
•Not used at higher speeds: DS3 and above use different encoding schemes

The HDB3 Alternative

While North America standardized on B8ZS, international telecommunications (ITU-T standards) use HDB3 (High-Density Bipolar 3), which substitutes after only 4 zeros. HDB3 provides higher transition density but with slightly more overhead. Both solve the same fundamental problem with different trade-off points.

Error Monitoring with B8ZS

B8ZS complicates error monitoring because not all bipolar violations indicate errors. The receiver must distinguish between intentional substitution violations and genuine transmission errors.

Distinguishing violations:

Violation Type	Characteristics	Interpretation
B8ZS substitution	Occurs at positions 4 and 7 of recognizable pattern	Normal operation
Transmission error	Isolated single violation	Error detected
Multiple scattered violations	Random positions	Link quality issues

b8zs_error_monitor.py
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
def monitor_b8zs_errors(signal: list[int]) -> dict:
    """
    Monitor a B8ZS signal for transmission errors.
    
    Must distinguish between:
    - Intentional B8ZS substitution violations (not errors)
    - Actual transmission errors (bipolar violations outside patterns)
    """
    true_errors = []
    b8zs_substitutions = 0
    last_mark_polarity = None
    i = 0
    
    while i < len(signal):
        # Check for B8ZS substitution pattern
        if i <= len(signal) - 8:
            segment = signal[i:i+8]
            if segment == [0, 0, 0, 1, -1, 0, -1, 1] or \
               segment == [0, 0, 0, -1, 1, 0, 1, -1]:
                b8zs_substitutions += 1
                # Skip the substitution pattern
                # Update last_mark_polarity based on pattern
                last_mark_polarity = segment[7]  # Last non-zero in pattern
                i += 8
                continue
        
        # Check current symbol
        if signal[i] != 0:
            # This is a mark - check for bipolar violation
            if last_mark_polarity is not None:
                if signal[i] == last_mark_polarity:
                    # Same polarity - this is an error!
                    true_errors.append({
                        "position": i,
                        "expected": -last_mark_polarity,
                        "received": signal[i]
                    })
            last_mark_polarity = signal[i]
        
        i += 1
    
    return {
        "signal_length": len(signal),
        "b8zs_substitutions_detected": b8zs_substitutions,
        "true_error_count": len(true_errors),
        "errors": true_errors,
        "link_status": "HEALTHY" if len(true_errors) == 0 else 
                       "DEGRADED" if len(true_errors) < 10 else "FAILED"
    }
 
 
# Example: Signal with B8ZS substitution and one real error
test_signal = [
    1,              # Normal mark
    0, 0, 0, 1, -1, 0, -1, 1,  # B8ZS substitution (not an error)
    -1,             # Normal mark
    1,              # Normal mark (should be -1)
    -1,             # Oops! This is an error - same polarity as previous
]
 
print("B8ZS Error Monitoring:")
result = monitor_b8zs_errors(test_signal)
print(f"Substitutions: {result['b8zs_substitutions_detected']}")
print(f"True errors: {result['true_error_count']}")
print(f"Link status: {result['link_status']}")

Production error monitoring:

In real T1/E1 systems, error monitoring is continuous and feeds into network management systems:

Errored Seconds (ES): Seconds with at least one error
Severely Errored Seconds (SES): Seconds with error rate > 10⁻³
Unavailable Seconds (UAS): Link effectively down
Code Violations (CV): Raw count of non-B8ZS bipolar violations

These metrics help network operators identify degrading links before complete failure, enabling preventive maintenance.

Summary: B8ZS Fundamentals

B8ZS represents a masterful engineering solution that maintains all of AMI's benefits while eliminating its critical weakness. The scheme's continued use in T1 infrastructure worldwide testifies to its effectiveness.

Key Takeaways

•B8ZS solves AMI's synchronization problem by substituting 8-zero sequences with patterns containing intentional bipolar violations
•Two substitution patterns exist (000+-0-+ and 000-+0+-), selected based on the previous mark's polarity
•DC balance is maintained because each substitution pattern sums to zero voltage
•Clock recovery is guaranteed with maximum 7-bit zero runs before substitution provides transitions
•Clear Channel Capability enables full 64 Kbps per channel for arbitrary digital data
•Error monitoring must distinguish between intentional B8ZS violations and actual transmission errors

What's next:

While North America standardized on B8ZS with its 8-zero threshold, international standards follow a different path. The next page covers HDB3 (High-Density Bipolar 3)—the European and ITU solution that substitutes after only 4 zeros, providing even higher transition density at the cost of more frequent pattern insertions.

Page Complete

You now have comprehensive understanding of B8ZS—its design rationale, substitution patterns, implementation algorithms, and application in T1 telecommunications infrastructure. This knowledge is essential for working with North American digital transmission systems.

2 / 5

Loading learning content...

Computer NetworksLine Coding - Bipolar

Line Coding: Bipolar Encoding Schemes

LevelIntermediate

Duration60 mins

TopicLine Coding - Bipolar

2 / 5

B8ZS (Bipolar with 8-Zero Substitution)

Solving AMI's Achilles Heel

The challenge was considerable. Any solution had to:

Maintain backward compatibility with existing AMI-based equipment
Preserve DC balance to remain transformer-compatible
Guarantee transitions even with arbitrary data containing many zeros
Introduce minimal overhead to maintain bandwidth efficiency
Be economically implementable with existing technology

What You Will Master

The Core Innovation: Intentional Violations

B8ZS is built on a surprisingly clever insight: if bipolar violations are normally errors, we can use deliberate violations as signals.

The Name Decoded

Why eight zeros?

The choice of eight zeros as the trigger threshold represents an engineering trade-off:

Threshold	Trade-offs
4 zeros	More frequent substitution → more overhead, but better sync
8 zeros	Balanced: rare enough to minimize overhead, frequent enough for T1 timing requirements
16 zeros	Too few substitutions → synchronization may still fail

The B8ZS Substitution Pattern

The heart of B8ZS is its substitution pattern. When eight consecutive zeros are detected, they are replaced with a specific eight-symbol pattern that:

Contains signal transitions (for clock recovery)
Contains recognizable bipolar violations (so the receiver knows it's a substitution)
Maintains overall DC balance (so AMI's transformer compatibility is preserved)

The B8ZS substitution patterns:

The pattern used depends on the polarity of the previous mark (the last 1-bit before the string of zeros):

Previous Mark Polarity	8-Zero Substitution Pattern
Positive (+V)	0 0 0 + - 0 - +
Negative (-V)	0 0 0 - + 0 + -

In shorthand notation:

After +V: 000+-0-+
After -V: 000-+0+-

Anatomy of the substitution pattern:

Let's analyze the pattern 000+-0-+ (used after a positive mark):

Position:    1   2   3   4   5   6   7   8
Original:    0   0   0   0   0   0   0   0
B8ZS:        0   0   0   +   -   0   -   +
                         ↑   ↑       ↑   ↑
                         │   │       │   │
                         V   V       V   V
                        Violation  Violation
                        (same      (same  
                        polarity   polarity
                        as prev)   as pos 5)

The two bipolar violations:

Position 4 (+): After the previous positive mark, the next mark should be negative per AMI rules. Instead, it's positive—a bipolar violation.
Position 7 (-): This follows position 5 (-), so the next mark should be positive. Instead, it's negative—another bipolar violation.

Why two violations?

DC Balance Verification

B8ZS Encoding Algorithm

The B8ZS encoding algorithm processes the input bit stream and applies both AMI encoding and zero-substitution rules.

b8zs_encoder.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
def b8zs_encode(bit_stream: list[int]) -> list[int]:
    """
    Encode a binary bit stream using B8ZS (Bipolar with 8-Zero Substitution).
    
    Algorithm:
    1. Scan for sequences of 8 consecutive zeros
    2. Replace each 8-zero sequence with the appropriate substitution pattern
    3. Apply AMI encoding to the (possibly modified) stream
    
    Args:
        bit_stream: List of binary values (0s and 1s)
    
    Returns:
        List of voltage levels: -1, 0, or +1
    """
    # Track the polarity for AMI encoding
    current_polarity = 1  # Start positive
    encoded_signal = []
    
    i = 0
    while i < len(bit_stream):
        # Check for 8 consecutive zeros
        if i <= len(bit_stream) - 8:
            if all(bit_stream[i:i+8] == [0] * 8 for _ in [0]):
                if bit_stream[i:i+8] == [0, 0, 0, 0, 0, 0, 0, 0]:
                    # Apply B8ZS substitution based on previous polarity
                    # The "previous polarity" is what the LAST mark was
                    # which is the NEGATIVE of current_polarity 
                    # (since current_polarity is what the NEXT mark will be)
                    last_mark_polarity = -current_polarity
                    
                    if last_mark_polarity > 0:  # Last mark was positive
                        # Pattern: 0 0 0 + - 0 - +
                        substitution = [0, 0, 0, 1, -1, 0, -1, 1]
                    else:  # Last mark was negative
                        # Pattern: 0 0 0 - + 0 + -
                        substitution = [0, 0, 0, -1, 1, 0, 1, -1]
                    
                    encoded_signal.extend(substitution)
                    # After substitution, polarity state is preserved
                    # (both patterns have equal + and - pulses)
                    i += 8
                    continue
        
        # Normal AMI encoding for non-substituted bits
        if bit_stream[i] == 0:
            encoded_signal.append(0)
        else:
            encoded_signal.append(current_polarity)
            current_polarity = -current_polarity
        i += 1
    
    return encoded_signal
 
 
def b8zs_decode(signal: list[int]) -> list[int]:
    """
    Decode a B8ZS signal back to binary.
    
    Algorithm:
    1. Scan for B8ZS substitution patterns
    2. Replace substitution patterns with 8 zeros
    3. Decode remaining signal using AMI rules
    """
    decoded_bits = []
    i = 0
    
    while i < len(signal):
        # Check for B8ZS substitution pattern (8 symbols)
        if i <= len(signal) - 8:
            segment = signal[i:i+8]
            
            # Pattern after positive mark: [0, 0, 0, +1, -1, 0, -1, +1]
            if segment == [0, 0, 0, 1, -1, 0, -1, 1]:
                decoded_bits.extend([0, 0, 0, 0, 0, 0, 0, 0])
                i += 8
                continue
            
            # Pattern after negative mark: [0, 0, 0, -1, +1, 0, +1, -1]
            if segment == [0, 0, 0, -1, 1, 0, 1, -1]:
                decoded_bits.extend([0, 0, 0, 0, 0, 0, 0, 0])
                i += 8
                continue
        
        # Normal AMI decoding: non-zero = 1, zero = 0
        decoded_bits.append(0 if signal[i] == 0 else 1)
        i += 1
    
    return decoded_bits
 
 
# Example demonstrating B8ZS substitution
print("=== B8ZS Encoding Example ===
")
 
# Data with 8 consecutive zeros
data_with_zeros = [1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1]
print(f"Original data:   {data_with_zeros}")
 
# Encode with B8ZS
encoded = b8zs_encode(data_with_zeros)
print(f"B8ZS encoded:    {encoded}")
 
# Notice: positions 3-10 contain the substitution pattern
# The violations at positions 4 (+1 after +1) and 7 (-1 after -1)
# mark this as a B8ZS substitution
 
# Decode back
decoded = b8zs_decode(encoded)
print(f"Decoded data:    {decoded}")
 
# Verify correct round-trip
print(f"
Round-trip correct: {data_with_zeros == decoded}")

Step-by-step encoding example:

Let's trace through encoding the sequence 1 0 0 0 0 0 0 0 0 1 1 0 1:

Bit 1 (value: 1): First mark, encode as +1. Polarity flips to -1.
Bits 2-9 (eight 0s): Detected as 8-zero run. Last mark was +1, so use pattern 000+-0-+.
Bit 10 (value: 1): Normal mark, polarity is still -1 (preserved by substitution), encode as -1. Flip to +1.
Bit 11 (value: 1): Normal mark, encode as +1. Flip to -1.
Bit 12 (value: 0): Encode as 0.
Bit 13 (value: 1): Normal mark, encode as -1.

Result: [+1, 0, 0, 0, +1, -1, 0, -1, +1, -1, +1, 0, -1]

Why the Substitution Pattern Works

The B8ZS substitution pattern is carefully engineered to satisfy all requirements simultaneously. Let's verify each property:

Pattern Properties

•DC Balance: Pattern 000+-0-+ has voltages [0,0,0,+V,-V,0,-V,+V]. Sum = +V-V-V+V = 0. ✓
•Transitions Guaranteed: The pattern contains 4 non-zero pulses, ensuring at least 4 transitions per 8-bit period. ✓
•Uniquely Identifiable: The two bipolar violations at specific positions (4 and 7) create a signature that cannot occur in valid AMI. ✓
•Polarity Preservation: Equal positive and negative pulses mean the polarity state is unchanged after substitution. ✓
•Fixed Length: Exactly 8 symbols replace exactly 8 zeros—no expansion or compression. ✓

The Elegance of Duality

Violation structure analysis:

In pattern 000+-0-+ (after positive mark):

Position:  1   2   3   4   5   6   7   8
Value:     0   0   0   +   -   0   -   +

Expected AMI after position 4 (+): next mark should be -
Actual value at position 5: - ✓ (valid)

Expected AMI after position 5 (-): next mark should be +
Actual value at position 7: - ✗ (VIOLATION)

Expected AMI after position 7 (-): next mark should be +
Actual value at position 8: + ✓ (valid)

Wait—where's the first violation? It's at position 4 itself:

Last mark before substitution: + (positive)
Expected first mark in substitution: - (should alternate)
Actual value at position 4: + ✗ (VIOLATION)

So the violations are:

Position 4: Same polarity as the previous mark (before the zeros)
Position 7: Same polarity as position 5

Clock Recovery Mechanism

How clock recovery works:

Modern receivers use Phase-Locked Loops (PLLs) to track the transmitter's clock. The PLL:

Detects signal transitions (edges between voltage levels)
Compares transition timing to its local clock
Adjusts the local clock frequency to minimize timing error
Uses the synchronized clock to sample bit values

The critical requirement: transitions must occur frequently enough for the PLL to maintain lock.

B8ZS transition guarantee:

With B8ZS, no matter what data is transmitted:

Maximum gap between transitions: At most 7 bit periods (the zeros before the substitution pulses begin)
Minimum transitions per 8-bit period: 4 (from the substitution pattern pulses)

This is sufficient for T1/DS1 clock recovery requirements:

Metric	Pure AMI	B8ZS
Max zeros without transition	Unlimited	3 consecutive
Transition density (worst case)	0%	50% (4/8)
Clock recovery reliability	Data-dependent	Guaranteed
Suitable for arbitrary data	No	Yes

PLL Timing Requirements

transition_analysis.py
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
def analyze_transitions(signal: list[int]) -> dict:
    """
    Analyze transition characteristics of an encoded signal.
    
    Transitions occur when the signal changes from one level to another.
    """
    transitions = []
    last_level = None
    last_transition_pos = 0
    max_gap = 0
    gaps = []
    
    for i, level in enumerate(signal):
        if level != last_level and last_level is not None:
            gap = i - last_transition_pos
            gaps.append(gap)
            if gap > max_gap:
                max_gap = gap
            transitions.append(i)
            last_transition_pos = i
        last_level = level
    
    return {
        "total_symbols": len(signal),
        "transition_count": len(transitions),
        "transition_density": len(transitions) / len(signal) if signal else 0,
        "max_gap_between_transitions": max_gap,
        "average_gap": sum(gaps) / len(gaps) if gaps else 0,
        "clock_recovery_safe": max_gap <= 15  # T1 PLL requirement
    }
 
 
# Compare AMI vs B8ZS for problematic data
problematic_data = [1] + [0] * 20 + [1]  # Long zero run
 
# Pure AMI encoding (no substitution)
def ami_only_encode(bits):
    polarity = 1
    result = []
    for bit in bits:
        if bit == 0:
            result.append(0)
        else:
            result.append(polarity)
            polarity = -polarity
    return result
 
ami_signal = ami_only_encode(problematic_data)
b8zs_signal = b8zs_encode(problematic_data)
 
print("Data with 20 consecutive zeros:")
print(f"
Pure AMI: {analyze_transitions(ami_signal)}")
print(f"B8ZS:     {analyze_transitions(b8zs_signal)}")
 
# Pure AMI: max_gap = 20+ (CLOCK RECOVERY FAILURE)
# B8ZS:     max_gap ≤ 7  (Clock recovery guaranteed)

Implementation in T1/DS1 Systems

The T1 system hierarchy:

T1 (or DS1) is a digital transmission standard operating at 1.544 Mbps:

24 voice channels × 64 Kbps = 1.536 Mbps
Plus 8 Kbps framing overhead = 1.544 Mbps
Frame structure: 193 bits (192 payload + 1 framing bit)
Frame rate: 8,000 frames per second

T1/DS1 Specifications with B8ZS
Parameter	Value	Notes
Line Rate	1.544 Mbps	Standard North American rate
Encoding	B8ZS	Ensures clock recovery for all data patterns
Pulse Shape	Bipolar Return-to-Zero	50% duty cycle pulses
Voltage Levels	±3V nominal	Measured at DSX-1 cross-connect
Maximum Cable Length	6,000 feet (copper)	Without repeaters
Error Monitoring	Bipolar Violations	B8ZS violations don't count as errors

The "Clear Channel" capability:

Before B8ZS, T1 systems used alternative methods to ensure sufficient ones density:

Bit stuffing: Forcing certain bit positions to be 1s
Bit robbery: Using the least significant bit of voice samples for signaling

These methods limited usability for data transmission because not all 64 Kbps were available for user data.

B8ZS enables Clear Channel Capability (CCC)—full 64 Kbps per channel for arbitrary data:

Feature	Without B8ZS	With B8ZS
Usable bits per channel	56 Kbps (7 bits × 8 kHz)	64 Kbps (8 bits × 8 kHz)
Arbitrary data support	No	Yes
ISDN compatibility	Limited	Full
Modern data protocols	Problematic	Transparent

Historical Impact

B8ZS Compared to Alternatives

B8ZS exists in an ecosystem of encoding schemes, each with distinct trade-offs. Understanding these comparisons helps engineers select appropriate schemes for different applications.

Line Coding Scheme Comparison
Scheme	Zero Handling	DC Component	Transition Density	Application
AMI	None	Zero	Data-dependent	Low-ones data only
B8ZS	8-zero substitution	Zero	≥50% (worst case)	T1/DS1 (North America)
HDB3	4-zero substitution	Zero	≥75% (worst case)	E1 (Europe, ITU)
Manchester	Every bit transitions	Zero	100%	Ethernet (10 Mbps)
4B/5B + NRZI	Block encoding	Low	≥80% (guaranteed)	Fast Ethernet, FDDI

B8ZS Advantages

•Backward compatible with AMI: B8ZS signals can be partially interpreted by older AMI-only equipment (though with errors)
•Minimal overhead: Only 8-zero sequences are modified; sparse zero runs pass unchanged
•Simple hardware: Detection and substitution logic is straightforward to implement
•Proven reliability: Decades of deployment in production telecommunications networks

B8ZS Limitations

•Regional: Primarily North American; European systems use HDB3 instead
•Error monitoring complexity: Must distinguish intentional violations from real errors
•Still allows 7-zero gaps: Not suitable for applications requiring more dense transitions
•Not used at higher speeds: DS3 and above use different encoding schemes

The HDB3 Alternative

Error Monitoring with B8ZS

B8ZS complicates error monitoring because not all bipolar violations indicate errors. The receiver must distinguish between intentional substitution violations and genuine transmission errors.

Distinguishing violations:

Violation Type	Characteristics	Interpretation
B8ZS substitution	Occurs at positions 4 and 7 of recognizable pattern	Normal operation
Transmission error	Isolated single violation	Error detected
Multiple scattered violations	Random positions	Link quality issues

b8zs_error_monitor.py
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
def monitor_b8zs_errors(signal: list[int]) -> dict:
    """
    Monitor a B8ZS signal for transmission errors.
    
    Must distinguish between:
    - Intentional B8ZS substitution violations (not errors)
    - Actual transmission errors (bipolar violations outside patterns)
    """
    true_errors = []
    b8zs_substitutions = 0
    last_mark_polarity = None
    i = 0
    
    while i < len(signal):
        # Check for B8ZS substitution pattern
        if i <= len(signal) - 8:
            segment = signal[i:i+8]
            if segment == [0, 0, 0, 1, -1, 0, -1, 1] or \
               segment == [0, 0, 0, -1, 1, 0, 1, -1]:
                b8zs_substitutions += 1
                # Skip the substitution pattern
                # Update last_mark_polarity based on pattern
                last_mark_polarity = segment[7]  # Last non-zero in pattern
                i += 8
                continue
        
        # Check current symbol
        if signal[i] != 0:
            # This is a mark - check for bipolar violation
            if last_mark_polarity is not None:
                if signal[i] == last_mark_polarity:
                    # Same polarity - this is an error!
                    true_errors.append({
                        "position": i,
                        "expected": -last_mark_polarity,
                        "received": signal[i]
                    })
            last_mark_polarity = signal[i]
        
        i += 1
    
    return {
        "signal_length": len(signal),
        "b8zs_substitutions_detected": b8zs_substitutions,
        "true_error_count": len(true_errors),
        "errors": true_errors,
        "link_status": "HEALTHY" if len(true_errors) == 0 else 
                       "DEGRADED" if len(true_errors) < 10 else "FAILED"
    }
 
 
# Example: Signal with B8ZS substitution and one real error
test_signal = [
    1,              # Normal mark
    0, 0, 0, 1, -1, 0, -1, 1,  # B8ZS substitution (not an error)
    -1,             # Normal mark
    1,              # Normal mark (should be -1)
    -1,             # Oops! This is an error - same polarity as previous
]
 
print("B8ZS Error Monitoring:")
result = monitor_b8zs_errors(test_signal)
print(f"Substitutions: {result['b8zs_substitutions_detected']}")
print(f"True errors: {result['true_error_count']}")
print(f"Link status: {result['link_status']}")

Production error monitoring:

In real T1/E1 systems, error monitoring is continuous and feeds into network management systems:

Errored Seconds (ES): Seconds with at least one error
Severely Errored Seconds (SES): Seconds with error rate > 10⁻³
Unavailable Seconds (UAS): Link effectively down
Code Violations (CV): Raw count of non-B8ZS bipolar violations

These metrics help network operators identify degrading links before complete failure, enabling preventive maintenance.

Summary: B8ZS Fundamentals

Key Takeaways

•B8ZS solves AMI's synchronization problem by substituting 8-zero sequences with patterns containing intentional bipolar violations
•Two substitution patterns exist (000+-0-+ and 000-+0+-), selected based on the previous mark's polarity
•DC balance is maintained because each substitution pattern sums to zero voltage
•Clock recovery is guaranteed with maximum 7-bit zero runs before substitution provides transitions
•Clear Channel Capability enables full 64 Kbps per channel for arbitrary digital data
•Error monitoring must distinguish between intentional B8ZS violations and actual transmission errors

What's next:

Page Complete

2 / 5