def test_merge_slide_one_side(board):
"""Tests merge slide.
Splits a1 to a4 and d1 and then merges to d4.
The square c4 will block one path of the merge in superposition.
"""
b = board(u.squares_to_bitboard(['a1', 'c3']))
assert b.perform_moves(
'a1^a4d1:SPLIT_SLIDE:BASIC',
'c3^c4c5:SPLIT_JUMP:BASIC',
'a4d1^d4:MERGE_SLIDE:BASIC',
)
possibilities = [
u.squares_to_bitboard(['a4', 'c4']),
u.squares_to_bitboard(['d4', 'c4']),
u.squares_to_bitboard(['d4', 'c5']),
]
assert_samples_in(b, possibilities)
probs = b.get_probability_distribution(20000)
assert_fifty_fifty(probs, qb.square_to_bit('c4'))
assert_fifty_fifty(probs, qb.square_to_bit('c5'))
assert_prob_about(probs, qb.square_to_bit('a4'), 0.25)
assert_prob_about(probs, qb.square_to_bit('d4'), 0.75)
board_probs = b.get_board_probability_distribution(20000)
assert len(board_probs) == len(possibilities)
assert_prob_about(board_probs, possibilities[0], 0.25)
assert_prob_about(board_probs, possibilities[1], 0.25)
assert_prob_about(board_probs, possibilities[2], 0.5)
def test_merge_slide_one_side():
"""Tests merge slide.
Splits a1 to a4 and d1 and then merges to d4.
The square c4 will block one path of the merge in superposition.
"""
b = simulator(u.squares_to_bitboard(["a1", "c3"]))
assert b.perform_moves(
"a1^a4d1:SPLIT_SLIDE:BASIC",
"c3^c4c5:SPLIT_JUMP:BASIC",
"a4d1^d4:MERGE_SLIDE:BASIC",
)
possibilities = [
u.squares_to_bitboard(["a4", "c4"]),
u.squares_to_bitboard(["d4", "c4"]),
u.squares_to_bitboard(["d4", "c5"]),
]
assert_samples_in(b, possibilities)
probs = b.get_probability_distribution(20000)
assert_fifty_fifty(probs, qb.square_to_bit("c4"))
assert_fifty_fifty(probs, qb.square_to_bit("c5"))
assert_prob_about(probs, qb.square_to_bit("a4"), 0.25)
assert_prob_about(probs, qb.square_to_bit("d4"), 0.75)
board_probs = b.get_board_probability_distribution(20000)
assert len(board_probs) == len(possibilities)
assert_prob_about(board_probs, possibilities[0], 0.25)
assert_prob_about(board_probs, possibilities[1], 0.25)
assert_prob_about(board_probs, possibilities[2], 0.5)
def test_pawn_capture(board):
"""Tests pawn capture with entanglement.
Rook on a3 => a4/a5 and rook on c3 => c4/c5.
Pawn on b3 attempts to capture both rooks.
The first capture should put the pawn in super-position,
and the second should force a measurement.
"""
b = board.with_state(u.squares_to_bitboard(['a3', 'b3', 'c3']))
# Capture and put the pawn in superposition
assert b.perform_moves('a3a4a5:SPLIT_JUMP:BASIC',
'b3a4:PAWN_CAPTURE:BASIC')
possibilities = [
u.squares_to_bitboard(['a5', 'b3', 'c3']),
u.squares_to_bitboard(['a4', 'c3']),
]
assert_samples_in(b, possibilities)
probs = b.get_probability_distribution(5000)
assert_fifty_fifty(probs, qb.square_to_bit('a5'))
assert_fifty_fifty(probs, qb.square_to_bit('a4'))
assert_fifty_fifty(probs, qb.square_to_bit('b3'))
did_it_move = b.perform_moves('c3c4c5:SPLIT_JUMP:BASIC',
'b3c4:PAWN_CAPTURE:BASIC')
if did_it_move:
possibilities = [
u.squares_to_bitboard(['a5', 'b3', 'c5']),
u.squares_to_bitboard(['a5', 'c4']),
]
else:
possibilities = [
u.squares_to_bitboard(['a4', 'c4']),
u.squares_to_bitboard(['a4', 'c5']),
]
assert_samples_in(b, possibilities)
def test_superposition_slide_move(board):
"""Tests a basic slide through a superposition.
Sets up superposition of c1 and f1 with a slide from a1 to d1.
Valid end state should be a1 and c1 (blocked), state = 5, or
d1 and f1 (unblocked), state = 40.
"""
b = board.with_state(u.squares_to_bitboard(['a1', 'e1']))
b.do_move(
move.Move('e1',
'f1',
target2='c1',
move_type=enums.MoveType.SPLIT_JUMP,
move_variant=enums.MoveVariant.BASIC))
b.do_move(
move.Move('a1',
'd1',
move_type=enums.MoveType.SLIDE,
move_variant=enums.MoveVariant.BASIC))
blocked = u.squares_to_bitboard(['a1', 'c1'])
moved = u.squares_to_bitboard(['d1', 'f1'])
assert_samples_in(b, [blocked, moved])
probs = b.get_probability_distribution(5000)
assert_fifty_fifty(probs, 0)
assert_fifty_fifty(probs, 2)
assert_fifty_fifty(probs, 3)
assert_fifty_fifty(probs, 5)
def test_merge_slide_both_side(board):
"""Tests a merge slide where both paths are blocked.
Splits a1 to a4/d1 and merges back to d4. c4 and d3 will
block one square on each path.
"""
b = board.with_state(u.squares_to_bitboard(['a1', 'c2', 'c3']))
assert b.perform_moves(
'a1a4d1:SPLIT_SLIDE:BASIC',
'c3c4c5:SPLIT_JUMP:BASIC',
'c2d2e2:SPLIT_JUMP:BASIC',
'a4d4--d1:MERGE_SLIDE:BASIC',
)
possibilities = [
u.squares_to_bitboard(['a4', 'd2', 'c4']),
u.squares_to_bitboard(['d1', 'd2', 'c4']),
u.squares_to_bitboard(['a4', 'e2', 'c4']),
u.squares_to_bitboard(['d4', 'e2', 'c4']),
u.squares_to_bitboard(['d1', 'd2', 'c5']),
u.squares_to_bitboard(['d4', 'd2', 'c5']),
u.squares_to_bitboard(['d4', 'e2', 'c5']),
]
assert_samples_in(b, possibilities)
probs = b.get_probability_distribution(20000)
assert_fifty_fifty(probs, qb.square_to_bit('c4'))
assert_fifty_fifty(probs, qb.square_to_bit('c5'))
assert_fifty_fifty(probs, qb.square_to_bit('d2'))
assert_fifty_fifty(probs, qb.square_to_bit('e2'))
assert_fifty_fifty(probs, qb.square_to_bit('d4'))
assert_prob_about(probs, qb.square_to_bit('a4'), 0.25)
assert_prob_about(probs, qb.square_to_bit('d1'), 0.25)
def test_entangled_qs_castle(board):
"""Queenside castling move with b-square blocked by superposition.
This should entangle the castling rook/king with the piece.
"""
b = board(u.squares_to_bitboard(["e1", "b3", "a1"]))
b.do_move(
move.Move(
"b3",
"b2",
target2="b1",
move_type=enums.MoveType.SPLIT_SLIDE,
move_variant=enums.MoveVariant.BASIC,
))
assert b.do_move(
move.Move(
"e1",
"c1",
move_type=enums.MoveType.QS_CASTLE,
move_variant=enums.MoveVariant.BASIC,
))
possibilities = [
u.squares_to_bitboard(["a1", "b1", "e1"]),
u.squares_to_bitboard(["c1", "b2", "d1"]),
]
assert_samples_in(b, possibilities)
def test_split_merge_slide_self_intersecting(board):
"""Tests merge slide with a source square in the path."""
b = board(u.squares_to_bitboard(["c1"]))
assert b.perform_moves(
"c1^e3g5:SPLIT_SLIDE:BASIC",
"e3g5^d2:MERGE_SLIDE:BASIC",
)
assert_samples_in(b, [u.squares_to_bitboard(["d2"])])
def test_classical_jump_move(board):
"""Tests a jump move in a classical position."""
b = board.with_state(u.squares_to_bitboard(['a1', 'c1']))
m = move.Move('a1',
'b1',
move_type=enums.MoveType.JUMP,
move_variant=enums.MoveVariant.BASIC)
b.do_move(m)
assert_samples_in(b, [u.squares_to_bitboard(['b1', 'c1'])])
def test_split_slide_merge_slide_coherence(board):
b = board(u.squares_to_bitboard(['b4', 'd3']))
assert b.perform_moves(
'd3^c5e5:SPLIT_JUMP:BASIC',
'b4^b8e7:SPLIT_SLIDE:BASIC',
'b8e7^b4:MERGE_SLIDE:BASIC',
'c5e5^d3:MERGE_JUMP:BASIC',
)
assert_samples_in(b, [u.squares_to_bitboard(['b4', 'd3'])])
def test_unblocked_blackqueenside_castle(board):
"""Tests classical queenside black castling move."""
b = board.with_state(u.squares_to_bitboard(['e8', 'a8']))
m = move.Move('e8',
'c8',
move_type=enums.MoveType.QS_CASTLE,
move_variant=enums.MoveVariant.BASIC)
assert b.do_move(m)
assert_samples_in(b, [u.squares_to_bitboard(['d8', 'c8'])])
def test_unblocked_whitequeenside_castle(board):
"""Tests classical queenside white castling move."""
b = board(u.squares_to_bitboard(['e1', 'a1']))
m = move.Move('e1',
'c1',
move_type=enums.MoveType.QS_CASTLE,
move_variant=enums.MoveVariant.BASIC)
assert b.do_move(m)
assert_samples_in(b, [u.squares_to_bitboard(['d1', 'c1'])])
def test_unblocked_white_castle(board):
"""Tests classical kingside white castling move."""
b = board.with_state(u.squares_to_bitboard(['e1', 'h1']))
m = move.Move('e1',
'g1',
move_type=enums.MoveType.KS_CASTLE,
move_variant=enums.MoveVariant.BASIC)
assert b.do_move(m)
assert_samples_in(b, [u.squares_to_bitboard(['f1', 'g1'])])
def test_split_slide_merge_slide_coherence():
b = simulator(u.squares_to_bitboard(["b4", "d3"]))
assert b.perform_moves(
"d3^c5e5:SPLIT_JUMP:BASIC",
"b4^b8e7:SPLIT_SLIDE:BASIC",
"b8e7^b4:MERGE_SLIDE:BASIC",
"c5e5^d3:MERGE_JUMP:BASIC",
)
assert_samples_in(b, [u.squares_to_bitboard(["b4", "d3"])])
def test_classical_jump_move(board):
"""Tests a jump move in a classical position."""
b = board(u.squares_to_bitboard(["a1", "c1"]))
m = move.Move("a1",
"b1",
move_type=enums.MoveType.JUMP,
move_variant=enums.MoveVariant.BASIC)
b.do_move(m)
assert_samples_in(b, [u.squares_to_bitboard(["b1", "c1"])])
def test_classical_ep2(board):
"""Fully classical en passant."""
b = board.with_state(u.squares_to_bitboard(['e4', 'd4']))
m = move.Move('e4',
'd3',
move_type=enums.MoveType.PAWN_EP,
move_variant=enums.MoveVariant.BASIC)
b.do_move(m)
assert_samples_in(b, [u.squares_to_bitboard(['d3'])])
def test_unentangled_pawn_capture(board):
"""Classical pawn capture."""
b = board.with_state(u.squares_to_bitboard(['a4', 'b3', 'c3']))
m = move.Move('b3',
'a4',
move_type=enums.MoveType.PAWN_CAPTURE,
move_variant=enums.MoveVariant.BASIC)
assert b.do_move(m)
assert_samples_in(b, [u.squares_to_bitboard(['a4', 'c3'])])
def test_unblocked_black_castle(board):
"""Tests classical kingside black castling move."""
b = board(u.squares_to_bitboard(['e8', 'h8']))
m = move.Move('e8',
'g8',
move_type=enums.MoveType.KS_CASTLE,
move_variant=enums.MoveVariant.BASIC)
assert b.do_move(m)
assert_samples_in(b, [u.squares_to_bitboard(['f8', 'g8'])])
def test_pawn_capture_bits(board):
"""Tests correctly setting the classical bits with pawn capture.
White: Nb4
Black: Pa7, Pb7
"""
b = board(u.squares_to_bitboard(["c2", "a6", "b7"]))
assert b.perform_moves("c2^b4a1:SPLIT_JUMP:BASIC", "b4a6.m1:JUMP:CAPTURE",
"b7a6:PAWN_CAPTURE:CAPTURE")
assert_samples_in(b, [u.squares_to_bitboard(["a6"])])
def test_unblocked_blackqueenside_castle(board):
"""Tests classical queenside black castling move."""
b = board(u.squares_to_bitboard(["e8", "a8"]))
m = move.Move(
"e8",
"c8",
move_type=enums.MoveType.QS_CASTLE,
move_variant=enums.MoveVariant.BASIC,
)
assert b.do_move(m)
assert_samples_in(b, [u.squares_to_bitboard(["d8", "c8"])])
def test_classical_ep2(board):
"""Fully classical en passant."""
b = board(u.squares_to_bitboard(["e4", "d4"]))
m = move.Move(
"e4",
"d3",
move_type=enums.MoveType.PAWN_EP,
move_variant=enums.MoveVariant.BASIC,
)
b.do_move(m)
assert_samples_in(b, [u.squares_to_bitboard(["d3"])])
def test_unentangled_pawn_capture(board):
"""Classical pawn capture."""
b = board(u.squares_to_bitboard(["a4", "b3", "c3"]))
m = move.Move(
"b3",
"a4",
move_type=enums.MoveType.PAWN_CAPTURE,
move_variant=enums.MoveVariant.BASIC,
)
assert b.do_move(m)
assert_samples_in(b, [u.squares_to_bitboard(["a4", "c3"])])
def test_unblocked_white_castle(board):
"""Tests classical kingside white castling move."""
b = board(u.squares_to_bitboard(["e1", "h1"]))
m = move.Move(
"e1",
"g1",
move_type=enums.MoveType.KS_CASTLE,
move_variant=enums.MoveVariant.BASIC,
)
assert b.do_move(m)
assert_samples_in(b, [u.squares_to_bitboard(["f1", "g1"])])
def test_basic_ep():
b = simulator(u.squares_to_bitboard(["b8", "b5", "c7"]))
assert b.perform_moves(
"b8^a6c6:SPLIT_JUMP:BASIC",
"b5a6:PAWN_CAPTURE:BASIC",
"c6b8:JUMP:BASIC",
"c7c5:PAWN_TWO_STEP:BASIC",
"b5c6:PAWN_EP:BASIC",
)
possibilities = [
u.squares_to_bitboard(["b8", "c6"]),
u.squares_to_bitboard(["a6", "c5"]),
]
assert_samples_in(b, possibilities)
def test_basic_ep():
b = qb.CirqBoard(u.squares_to_bitboard(['b8', 'b5', 'c7']))
assert b.perform_moves(
'b8a6c6:SPLIT_JUMP:BASIC',
'b5a6:PAWN_CAPTURE:BASIC',
'c6b8:JUMP:BASIC',
'c7c5:PAWN_TWO_STEP:BASIC',
'b5c6:PAWN_EP:BASIC',
)
possibilities = [
u.squares_to_bitboard(['b8', 'c6']),
u.squares_to_bitboard(['a6', 'c5']),
]
assert_samples_in(b, possibilities)
def test_jump_with_successful_measurement_outcome(board):
b = board(u.squares_to_bitboard(['b1', 'c2']))
b.do_move(
move.Move('b1',
'a3',
target2='c3',
move_type=enums.MoveType.SPLIT_JUMP,
move_variant=enums.MoveVariant.BASIC))
b.do_move(
move.Move('c2',
'c3',
move_type=enums.MoveType.JUMP,
move_variant=enums.MoveVariant.EXCLUDED,
measurement=1))
assert_samples_in(b, [u.squares_to_bitboard(['c3', 'a3'])])
def test_2block_ks_castle(board):
"""Kingside castling move blocked by 2 pieces in superposition."""
b = board(u.squares_to_bitboard(["e8", "f6", "g6", "h8"]))
did_it_move = b.perform_moves(
"f6^f7f8:SPLIT_JUMP:BASIC",
"g6^g7g8:SPLIT_JUMP:BASIC",
"e8g8:KS_CASTLE:BASIC",
)
if did_it_move:
possibilities = [u.squares_to_bitboard(["g8", "f7", "g7", "f8"])]
else:
possibilities = [
u.squares_to_bitboard(["e8", "f8", "g7", "h8"]),
u.squares_to_bitboard(["e8", "f7", "g8", "h8"]),
u.squares_to_bitboard(["e8", "f8", "g8", "h8"]),
]
assert_samples_in(b, possibilities)
def test_2block_ks_castle(board):
"""Kingside castling move blocked by 2 pieces in superposition."""
b = board.with_state(u.squares_to_bitboard(['e8', 'f6', 'g6', 'h8']))
did_it_move = b.perform_moves(
'f6f7f8:SPLIT_JUMP:BASIC',
'g6g7g8:SPLIT_JUMP:BASIC',
'e8g8:KS_CASTLE:BASIC',
)
if did_it_move:
possibilities = [u.squares_to_bitboard(['g8', 'f7', 'g7', 'f8'])]
else:
possibilities = [
u.squares_to_bitboard(['e8', 'f8', 'g7', 'h8']),
u.squares_to_bitboard(['e8', 'f7', 'g8', 'h8']),
u.squares_to_bitboard(['e8', 'f8', 'g8', 'h8']),
]
assert_samples_in(b, possibilities)
def test_merge_move(board):
"""Splits piece on a1 to b1 and c1 and then merges back to a1."""
b = board.with_state(u.squares_to_bitboard(['a1']))
b.do_move(
move.Move('a1',
'b1',
target2='c1',
move_type=enums.MoveType.SPLIT_JUMP,
move_variant=enums.MoveVariant.BASIC))
b.do_move(
move.Move('b1',
'a1',
source2='c1',
move_type=enums.MoveType.MERGE_JUMP,
move_variant=enums.MoveVariant.BASIC))
assert_samples_in(b, [u.squares_to_bitboard(['a1'])])
assert b.get_full_squares_bitboard() == 1
def test_capture_ep2():
"""Tests capture en passant.
Splits b8 to a6/c6. Move c7 to c5 and perform en passant on c6. This should
either capture the knight or the pawn.
"""
b = qb.CirqBoard(u.squares_to_bitboard(['b8', 'b5', 'c7']))
did_it_move = b.perform_moves(
'b8a6c6:SPLIT_JUMP:BASIC',
'c7c5:PAWN_TWO_STEP:BASIC',
'b5c6:PAWN_EP:CAPTURE',
)
assert did_it_move
possibilities = [
u.squares_to_bitboard(['c6', 'c7']),
u.squares_to_bitboard(['c6', 'a6']),
]
assert_samples_in(b, possibilities)
def test_capture_ep2():
"""Tests capture en passant.
Splits b8 to a6/c6. Move c7 to c5 and perform en passant on c6. This should
either capture the knight or the pawn.
"""
b = simulator(u.squares_to_bitboard(["b8", "b5", "c7"]))
did_it_move = b.perform_moves(
"b8^a6c6:SPLIT_JUMP:BASIC",
"c7c5:PAWN_TWO_STEP:BASIC",
"b5c6:PAWN_EP:CAPTURE",
)
assert did_it_move
possibilities = [
u.squares_to_bitboard(["c6", "c7"]),
u.squares_to_bitboard(["c6", "a6"]),
]
assert_samples_in(b, possibilities)
