Извлечение битов с одним умножением

Очень интересный вопрос. Я перебираю мои два цента, а это значит, что если вы можете сформулировать такие проблемы, как в случае логики первого порядка над теорией битвектора, то теоретические проусоры - ваш друг и потенциально могут обеспечить вас очень быстро ответы на ваши вопросы. Пусть переформулирует задание как теорему:

"Существует некоторая 64-битная константа 'mask' и 'multipicand', так что для всех 64-разрядных битов векторов x в выражении y = (x и mask) * multipicand мы имеем, что y.63 == x.63, y.62 == x.55, y.61 == x.47 и т.д."

Если это предложение на самом деле является теоремой, то верно, что некоторые значения "маски" констант и "мультипликации" удовлетворяют этому свойству. Поэтому давайте раскроем это с точки зрения чего-то, что может понять теоретический прорыв, а именно: SMT-LIB 2 input:

(set-logic BV)

(declare-const mask         (_ BitVec 64))
(declare-const multiplicand (_ BitVec 64))

(assert
  (forall ((x (_ BitVec 64)))
    (let ((y (bvmul (bvand mask x) multiplicand)))
      (and
        (= ((_ extract 63 63) x) ((_ extract 63 63) y))
        (= ((_ extract 55 55) x) ((_ extract 62 62) y))
        (= ((_ extract 47 47) x) ((_ extract 61 61) y))
        (= ((_ extract 39 39) x) ((_ extract 60 60) y))
        (= ((_ extract 31 31) x) ((_ extract 59 59) y))
        (= ((_ extract 23 23) x) ((_ extract 58 58) y))
        (= ((_ extract 15 15) x) ((_ extract 57 57) y))
        (= ((_ extract  7  7) x) ((_ extract 56 56) y))
      )
    )
  )
)

(check-sat)
(get-model)

А теперь попробуем теорему прообраза Z3, является ли это теоремой:

z3.exe /m /smt2 ExtractBitsThroughAndWithMultiplication.smt2

Результат:

sat
(model
  (define-fun mask () (_ BitVec 64)
    #x8080808080808080)
  (define-fun multiplicand () (_ BitVec 64)
    #x0002040810204081)
)

Бинго! Он воспроизводит результат, указанный в исходном сообщении за 0,06 секунды.

Рассматривая это с более общей точки зрения, мы можем рассматривать это как экземпляр проблемы синтеза программ первого порядка, которая является зарождающейся областью исследований, о которой было опубликовано несколько статей. Поиск "program synthesis" filetype:pdf должен начать вас.

Каждый 1-бит в множителе используется для копирования одного из битов в правильное положение:

• 1 уже находится в правильном положении, поэтому умножьте на 0x0000000000000001.
• 2 необходимо сдвинуть 7-битные позиции влево, поэтому мы умножим на 0x0000000000000080 (бит 7 установлен).
• 3 должно быть сдвинуто на 14 бит влево, поэтому умножим на 0x0000000000000400 (бит 14 установлен).
• и т.д., пока
• 8 должно быть сдвинуто на 49 бит влево, поэтому умножим на 0x0002000000000000 (бит 49 установлен).

Умножитель представляет собой сумму умножителей для отдельных битов.

Это работает только потому, что бит, который нужно собрать, не слишком близко друг к другу, так что умножение битов, которые не принадлежат друг другу в нашей схеме, либо выходит за пределы 64 бит, либо в нижней части, не требующей обслуживания.

Обратите внимание, что остальные биты исходного номера должны быть 0. Это может быть достигнуто путем маскировки их с помощью операции И.

(Я никогда раньше этого не видел. Этот трюк замечательный!)

Я немного расскажу о утверждении Флориса о том, что при извлечении битов n вам нужно n-1 пробел между любыми нескончаемыми битами:

Моя первоначальная мысль (мы увидим через минуту, как это не совсем работает) заключается в том, что вы можете сделать лучше: если вы хотите извлечь биты n, у вас будет столкновение при извлечении/смещении бит i, если у вас есть кто-то (не последовательный с битом i) в бит i-1, предшествующий или n-i бит, следующий.

Я приведу несколько примеров для иллюстрации:

...a..b...c... Работает (никто из 2-х бит после a, бит до и бит после b, и никто не находится в двух битах до c):

  a00b000c
+ 0b000c00
+ 00c00000
= abc.....

...a.b....c... Сбой, потому что b находится в 2 битах после a (и при переносе в другое место при сдвиге a):

  a0b0000c
+ 0b0000c0
+ 00c00000
= abX.....

...a...b.c... Сбой, потому что b находится в 2 битах, предшествующих c (и попадает в другое место при сдвиге c):

  a000b0c0
+ 0b0c0000
+ b0c00000
= Xbc.....

...a...bc...d... Работает, потому что последовательные биты сдвигаются вместе:

  a000bc000d
+ 0bc000d000
+ 000d000000
= abcd000000

Но у нас есть проблема. Если мы используем n-i вместо n-1, у нас может быть следующий сценарий: что, если у нас есть столкновение за пределами той части, о которой мы заботимся, что-то мы замаскировали бы в конце, но чьи носовые бит в конечном итоге мешали важному не маскируемому диапазону? (и обратите внимание: требование n-1 гарантирует, что этого не произойдет, убедившись, что бит i-1 после нашего незамаскированного диапазона становится ясным, когда мы сдвигаем бит i th)

...a...b..c...d... Потенциальный сбой на переносных битах, c находится в n-1 после b, но удовлетворяет критериям n-i:

  a000b00c000d
+ 0b00c000d000
+ 00c000d00000
+ 000d00000000
= abcdX.......

Итак, почему бы нам просто не вернуться к требованию "n-1 бит пространства"? Потому что мы можем сделать лучше:

...a....b..c...d.. Не удалось выполнить тест "n-1 бит пространства", но работает для нашего утилизатора бит:

+ a0000b00c000d00
+ 0b00c000d000000
+ 00c000d00000000
+ 000d00000000000
= abcd...0X......

Я не могу придумать хороший способ охарактеризовать эти поля, у которых нет пробелов между ключевыми битами n-1, но все равно будет работать для нашей работы. Однако, поскольку мы знаем заранее, какие биты мы интересуем, мы можем проверить наш фильтр, чтобы убедиться, что мы не сталкиваемся с бит-битами:

Сравните (-1 AND mask) * shift с ожидаемым результатом all-ones, -1 << (64-n) (для 64-разрядного без знака)

Магический сдвиг/умножение для извлечения наших битов работает тогда и только тогда, когда они равны.

В дополнение к уже отличным ответам на этот очень интересный вопрос, было бы полезно знать, что этот побитовый трюк умножения известен в компьютерном шахматном сообществе с 2007 года, где он находится под именем Magic BitBoards.

Многие компьютерные шахматы используют несколько 64-битных целых чисел (называемых битами) для представления различных наборов фигур (1 бит на каждый квадрат). Предположим, что скользящая часть (ладья, слон, королева) на определенном квадрате происхождения может переместиться в квадраты не более K, если не было блокирующих кусков. Использование побитового и из этих разбросанных бит K с битовой частью занятых квадратов дает конкретное слово K -bit, встроенное в 64-битное целое число.

Магическое умножение может использоваться для сопоставления этих разбросанных бит K с нижними битами K 64-разрядного целого числа. Эти более низкие биты K могут затем использоваться для индексации таблицы предварительно вычисленных битов, которые представляют разрешенные квадраты, которые кусок на его исходном квадрате может фактически перемещаться (заботясь о блокировке фигур и т.д.).

Типичный шахматный движок с использованием этого подхода имеет 2 таблицы (один для грачей, один для епископов, ферзей, используя комбинацию обоих) из 64 записей (по одному на квадрат начала), которые содержат такие предварительно рассчитанные результаты. И самый высокий рейтинг закрытого источника ( Houdini) и движок с открытым исходным кодом ( Stockfish) в настоящее время используют этот подход для очень высокой производительности.

Поиск этих волшебных множителей выполняется либо с помощью исчерпывающего поиска (оптимизированного с помощью ранних отключений), либо с помощью trial и erorr (например, попробуйте множество случайных 64-битных целых чисел). Не было никаких бит-шаблонов, используемых во время генерации движения, для которых не было обнаружено никакой волшебной константы. Однако эффекты побитового переноса обычно необходимы, когда биты, которые должны быть отображены, имеют (почти) соседние индексы.

AFAIK, самый общий подход SAT-solver by @Syzygy не использовался в компьютерных шахматах, и также не существует какой-либо формальной теории относительно существования и уникальности таких магических констант.