# Conceptual pseudo-code for block-wise quantization with outlier handling
def quantize_block_wise(tensor_fp, num_bits, block_size, outlier_threshold):
    """
    Applies block-wise quantization, potentially handling outliers.
    """
    quantized_blocks = []
    outlier_map = np.zeros_like(tensor_fp, dtype=bool)
    outlier_values = []

    for i in range(0, tensor_fp.shape[0], block_size):
        for j in range(0, tensor_fp.shape[1], block_size):
            block = tensor_fp[i:i+block_size, j:j+block_size]

            # Identify outliers within the block
            abs_block = np.abs(block)
            block_max = np.max(abs_block)

            # Simple outlier detection: if a value is above N*std dev or abs threshold
            # More advanced: percentiles, separate outlier bit-width
            is_outlier_in_block = abs_block > (outlier_threshold * np.mean(abs_block))

            # Store outlier info
            if np.any(is_outlier_in_block):
                outlier_map[i:i+block_size, j:j+block_size][is_outlier_in_block] = True
                outlier_values.extend(block[is_outlier_in_block].flatten())
                # For quantization, replace outliers with clipped values or zeros
                block_to_quantize = np.where(is_outlier_in_block, 0.0, block) 
            else:
                block_to_quantize = block

            # Quantize the non-outlier part of the block
            q_block, scale, zero_point = quantize_tensor_symmetric(block_to_quantize, num_bits)
            quantized_blocks.append((q_block, scale, zero_point, (i, j)))

    # Need a separate mechanism to store and reconstruct outlier_values and their positions
    # This could involve higher precision, run-length encoding for positions, etc.
    return quantized_blocks, outlier_map, outlier_values