Parity Blocks and Checksum Limits

An even-parity bit makes the total number of ones in the protected group even; odd parity makes it odd. For data 1101, three ones require parity 1 for even parity and 0 for odd parity. The bit is a check on the group, not encryption. One flipped bit changes parity, while an even number of flips in the same group can preserve it.

Two-dimensional parity adds checks for rows and columns of a data block. Under the even-parity model below, each data row gets one parity bit and a final row checks the columns, including a consistent corner bit. For a single changed bit, one row and one column report failure, locating the intersection. This reasoning assumes the declared single-error model.

Changing all four corners of a rectangle can flip two bits in each affected row and two in each affected column. Every even-parity check can still pass. Two-dimensional parity therefore does not prove that an arbitrary block is unchanged and must not be presented as detecting every possible corruption. Several failures can also make correction ambiguous.

The original code validates a rectangular binary block and computes parity by sums modulo two. It returns the failing row/column indices after a selected bit flip. The block includes parity positions; a single error in a parity position also has a detectable syndrome. Correcting data automatically needs a specified error assumption rather than guessing whenever any row happens to fail.

def validate_bits(block):
    if not block or not block[0] or any(len(row) != len(block[0]) for row in block):
        raise ValueError('Use a nonempty rectangular block')
    if any(type(bit) is not int or bit not in (0, 1) for row in block for bit in row):
        raise ValueError('Use binary integer bits')

def add_even_parity(data):
    validate_bits(data)
    block = [list(row) + [sum(row) % 2] for row in data]
    bottom = [sum(row[column] for row in data) % 2 for column in range(len(data[0]))]
    bottom.append(sum(bottom) % 2)
    return block + [bottom]

def parity_errors(block):
    validate_bits(block)
    rows = [index for index, row in enumerate(block) if sum(row) % 2]
    columns = [column for column in range(len(block[0])) if sum(row[column] for row in block) % 2]
    return rows, columns

data = [[1, 0, 1, 1], [0, 1, 0, 1], [1, 1, 0, 0]]
block = add_even_parity(data)
print(block)
block[1][2] ^= 1
print(parity_errors(block))

This teaching checksum sums data bytes and stores the negative sum modulo 256, so data plus check byte have remainder zero. For bytes 12,250,9, the total is 271 and the check byte is 241, because 271+241=512. A different checksum algorithm, such as an Internet ones’-complement checksum, needs its own rules; do not mix their calculations.

Changing the data to 13,250,8 preserves the total and passes this simple checksum despite changing two values. A checksum is useful for its stated accidental-error model, but not an authentication proof against an active adversary who can recompute it. If authenticity is required, the system needs an appropriate cryptographic authentication mechanism and key/trust design, not just more confidence in an unkeyed arithmetic check.

def check_byte(data):
    return (-sum(data)) % 256

data = bytes([12, 250, 9])
check = check_byte(data)
print(check)
print((sum(data) + check) % 256 == 0)
changed = bytes([13, 250, 8])
print((sum(changed) + check) % 256 == 0)

Attempt the task before opening its worked response. Record each change of state, explain the rule used, and check the result against the original requirements. Code examples labelled Python 3 use that language’s conventions; pseudocode states its own assumptions.