Предполагается, что функция умножает 2 двоичных числа (без специальных функций), но это не так

У вас много проблем с вашим кодом:

1. Вы не используете: younger_result_list. Предполагается, что это будет содержать результат низкого порядка.
2. Вы повторяете elder_result_list в обратном порядке, но обновляете его, используя прямые индексы.
3. Строки: elder_result_list.pop(0) удаляет результаты не с того конца.

Я переписал его следующим образом: я использую временный список result_list для хранения результатов сложения, удаляю правильный бит из elder_result_list и добавляю его в younger_result_list:

def result_first_diapazone(bin1, bin2):
    carry = 0
    elder_result_list = ['0', '0', '0', '0', '0', '0', '0', '0']
    younger_result_list = []
    bin1_list = list(reversed(bin1))
    bin2_list = list(reversed(bin2))

    for bit in bin2_list:
        if bit == '1':
            result_list = []
            for i, (x, y) in enumerate(zip(bin1_list, reversed(elder_result_list))):
                if (x, y) == ('0', '0') and carry == 0:
                    result_list.append('0')
                    carry = 0
                elif (x, y) == ('0', '0') and carry == 1:
                    result_list.append('1')
                    carry = 0
                elif (x, y) == ('1', '0') and carry == 0:
                    result_list.append('1')
                    carry = 0
                elif (x, y) == ('1', '0') and carry == 1:
                    result_list.append('0')
                    carry = 1
                elif (x, y) == ('0', '1') and carry == 0:
                    result_list.append('1')
                    carry = 0
                elif (x, y) == ('0', '1') and carry == 1:
                    result_list.append('0')
                    carry = 1
                elif (x, y) == ('1', '1') and carry == 0:
                    result_list.append('0')
                    carry = 1
                elif (x, y) == ('1', '1') and carry == 1:
                    result_list.append('1')
                    carry = 1
                else:
                    result_list.append('1')
                    carry = 1
            result_list.append(str(carry))
            elder_result_list = list(reversed(result_list))
        else:
            elder_result_list.insert(0,'0')
        low = elder_result_list.pop()
        younger_result_list.append(low)

    elder_result_str = ''.join(map(str, elder_result_list))
    younger_result_str = ''.join(map(str, reversed(younger_result_list)))
    result_result = elder_result_str + ' ' + younger_result_str
    return result_result

Пример кода для расчета 42*42=1764:

result = result_first_diapazone('00101010', '00101010')
print(result)

Выход:

00000110 11100100

Обновлять:

addition_table = {
    ('0', '0', '0'): ('0', '0'),
    ('0', '0', '1'): ('1', '0'),
    ('0', '1', '0'): ('1', '0'),
    ('0', '1', '1'): ('0', '1'),
    ('1', '0', '0'): ('1', '0'),
    ('1', '0', '1'): ('0', '1'),
    ('1', '1', '0'): ('0', '1'),
    ('1', '1', '1'): ('1', '1')
}


def binary_add(augend, addend):
    result = ['0'] * 8
    carry = '0'
    for i, (x, y) in enumerate(zip(augend, addend)):
        result[i], carry = addition_table[(x, y, carry)]
    return result, carry


def binary_multiply(multiplier, multiplicand):
    upper_result_list = ['0'] * 8
    lower_result_list = []

    for bit in multiplier:
        if bit == '1':
            upper_result_list, carry = binary_add(multiplicand, upper_result_list)
            upper_result_list.append(carry)
        else:
            upper_result_list.append('0')

        low = upper_result_list.pop(0)
        lower_result_list.append(low)
    return upper_result_list, lower_result_list

def l_r(i):
    return list(reversed(i))

def result_first_diapazone(multiplier, multiplicand):
    upper, lower = binary_multiply(l_r(multiplier), l_r(multiplicand))
    return ''.join(reversed(upper))+ ' ' + ''.join(reversed(lower))

Вывод как указано выше.

Обратите внимание, что мой первый пример кода в некоторых случаях выдает неправильный результат, поскольку переменная carry определена слишком рано. Он должен быть внутри первого цикла for, а не в начале. Мой обновленный код все делает правильно, поскольку он является частью функции binary_add().