Editing Channel Coding

<div style="background-color: #4B0082; color: #FFFFFF; padding: 20px; border-radius: 8px; margin-bottom: 15px;">
{{BloomIntro}}
Channel Coding is the science of sending a message through a "Noisy" environment so that it can be reconstructed perfectly at the other end. While "Data Compression" is about making a message as small as possible, "Channel Coding" is about adding "Smart Redundancy" to protect the message from errors. It is the reason your phone works in a crowded stadium, why CDs don't skip when they have a tiny scratch, and how we can hear the faint whispers of space probes millions of miles away. It is the math of reliability in an unreliable world.
</div>

__TOC__

<div style="background-color: #000080; color: #FFFFFF; padding: 20px; border-radius: 8px; margin-bottom: 15px;">
== <span style="color: #FFFFFF;">Remembering</span> ==
* '''Channel Coding''' — The process of adding redundancy to a message so that errors caused by the channel can be detected and corrected.
* '''Noise''' — Random interference in a communication channel (static, heat, radio interference).
* '''Error Correction Code (ECC)''' — A mathematical code that allows a receiver to "Repair" a broken bit.
* '''Check-sum''' — A simple number added to the end of a message to detect if any bits changed (but not necessarily fix them).
* '''Parity Bit''' — A single bit added to a string to ensure the total number of "1s" is even or odd.
* '''Hamming Distance''' — The number of bits that are different between two messages (the "Gap" between codes).
* '''Block Code''' — A code that breaks a message into fixed-size "Chunks" and adds extra bits to each chunk.
* '''Convolutional Code''' — A code that processes a continuous stream of bits and uses the "Memory" of previous bits to protect current ones.
* '''Reed-Solomon Code''' — A powerful code used in CDs, DVDs, and QR codes that can fix "Bursts" of many errors in a row.
* '''Shannon's Channel Capacity''' — The maximum rate at which information can be sent over a channel with zero errors.
</div>

<div style="background-color: #006400; color: #FFFFFF; padding: 20px; border-radius: 8px; margin-bottom: 15px;">
== <span style="color: #FFFFFF;">Understanding</span> ==
Channel coding is understood through '''Redundancy''' and '''Error Detection'''.

'''1. The Power of "Wait, What?" (Error Detection)''':
If I say "Hello," and you hear "Hxllo," you know something is wrong because "Hxllo" isn't a word.
* Channel coding adds a "Rule" to the message.
* If the receiver sees the rule is broken, it knows there is an error.

'''2. The Power of "Repair" (Error Correction)''':
If I say "Hello" three times ("Hello Hello Hello"), and you hear "Hxllo Hello Hello," you can use the "Best 2-out-of-3" rule to know the first word was actually "Hello."
* This is a simple but inefficient way to fix errors.
* Advanced math (like Hamming or Reed-Solomon) allows us to fix the error using much less "Extra Data."

'''3. The Shannon Limit (The Noise Wall)''':
Shannon proved that no matter how much "Static" is on a wire, as long as you use the right code, you can send data with **zero** errors.
* However, as the noise goes up, the "Speed" must go down.
* You can't beat the physics of the channel, but you can get exactly as close as the math allows.

'''Forward Error Correction (FEC)''': This is when the receiver fixes the error itself without asking the sender to "Send it again." This is essential for things like satellite TV or deep space probes where the sender is too far away to talk back quickly.
</div>

<div style="background-color: #8B0000; color: #FFFFFF; padding: 20px; border-radius: 8px; margin-bottom: 15px;">
== <span style="color: #FFFFFF;">Applying</span> ==
'''Modeling 'The Parity Bit' (Simple error detection):'''
<syntaxhighlight lang="python">
def add_parity_bit(data_string):
    """
    Adds a '1' if the number of ones is odd, to make it 'Even Parity'.
    """
    ones_count = data_string.count('1')
    parity = '1' if ones_count % 2 != 0 else '0'
    return data_string + parity

def check_parity(packet):
    """
    Returns True if the parity is still even.
    """
    return packet.count('1') % 2 == 0

# Sender sends '101'
original = "101"
sent = add_parity_bit(original)
print(f"Sent Packet: {sent}")

# Receiver hears '111' (Middle bit flipped by noise)
received = "1110" 
if not check_parity(received):
    print("ERROR DETECTED: The parity doesn't match!")
</syntaxhighlight>

; Coding Landmarks
: '''Hamming Codes (1950)''' → The first code that could not only detect an error but pinpoint exactly which bit was wrong and flip it back.
: '''Reed-Solomon Codes (1960)''' → The code that made "Digital Media" possible. Without it, a single speck of dust on a CD would make it unplayable.
: '''The Voyager Probes''' → Use advanced channel coding to send photos from the edge of the solar system using a transmitter that has less power than a lightbulb.
: '''QR Codes''' → These contain enough "Error Correction" that you can rip a corner off the paper or spray-paint over part of the code and it will still work.
</div>

<div style="background-color: #8B4500; color: #FFFFFF; padding: 20px; border-radius: 8px; margin-bottom: 15px;">
== <span style="color: #FFFFFF;">Analyzing</span> ==
{| class="wikitable"
|+ Detection vs. Correction
! Feature !! Error Detection (Checksum) !! Error Correction (ECC)
|-
| Goal || To "Know" if something is wrong || To "Fix" it automatically
|-
| Complexity || Low (Easy to calculate) || High (Complex math)
|-
| Extra Data || Tiny (Few bits) || Significant (10% to 50% extra)
|-
| Analogy || A 'Tamper-Evident' seal || A 'Self-Healing' material
|}

'''The Concept of "Hamming Distance"''': Analyzing how "Different" two valid messages are. If your code is "100" and "011," they are very different. If noise flips one bit, "100" becomes "110." Since "110" isn't a valid code, the computer knows it's broken. The further apart your valid codes are, the more errors you can fix.
</div>

<div style="background-color: #483D8B; color: #FFFFFF; padding: 20px; border-radius: 8px; margin-bottom: 15px;">
== <span style="color: #FFFFFF;">Evaluating</span> ==
Evaluating channel coding:
# '''Efficiency''': How much "Waste" (redundancy) can we afford? (In a high-speed network, we want minimal ECC; in space, we want maximum).
# '''Latency''': Does fixing errors slow down the system? (Calculating complex codes takes time, which can "Lag" video games or phone calls).
# '''Reliability''': At what point does the "Noise" become so high that no code can save the message? (The "Cliff Effect" in digital TV—it's perfect until it suddenly disappears).
# '''Security''': Can an attacker "Inject" errors to break a code and read a secret message?
</div>

<div style="background-color: #2F4F4F; color: #FFFFFF; padding: 20px; border-radius: 8px; margin-bottom: 15px;">
== <span style="color: #FFFFFF;">Creating</span> ==
Future Frontiers:
# '''Polar Codes''': A new type of code used in 5G that gets closer to the theoretical "Shannon Limit" than anything before it.
# '''Quantum Error Correction''': The most difficult challenge in physics—fixing errors in quantum bits (which are incredibly fragile) without "Looking" at them (which destroys them).
# '''Biological Error Correction''': Scientists are studying how our cells use "Channel Coding" to copy DNA without mistakes.
# '''AI-Designed Codes''': Using deep learning to "Discover" new mathematical codes that are better than anything humans have invented.

[[Category:Computer Science]]
[[Category:Mathematics]]
[[Category:Technology]]
</div>