public-mirrors/3b1b-videos
1
0
Fork 0
mirror of https://github.com/3b1b/videos.git synced 2025-08-05 16:48:47 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
3b1b-videos/_2020/chess.py
Grant Sanderson 7721ed0bc6 Renamed imports_3b1b => manim_imports_ext
2021-01-01 20:10:38 -08:00

4873 lines
152 KiB
Python
Raw Blame History

from manim_imports_ext import *
def boolian_linear_combo(bools):
return reduce(op.xor, [b * n for n, b in enumerate(bools)], 0)
def string_to_bools(message):
# For easter eggs on the board
as_int = int.from_bytes(message.encode(), 'big')
bits = "{0:b}".format(as_int)
bits = (len(message) * 8 - len(bits)) * '0' + bits
return [bool(int(b)) for b in bits]
def layer_mobject(mobject, nudge=1e-6):
for i, sm in enumerate(mobject.family_members_with_points()):
sm.shift(i * nudge * OUT)
def int_to_bit_coords(n, min_dim=3):
bits = "{0:b}".format(n)
bits = (min_dim - len(bits)) * '0' + bits
return np.array(list(map(int, bits)))
def bit_coords_to_int(bits):
return sum([(2**n) * b for n, b in enumerate(reversed(bits))])
def get_vertex_sphere(height=0.4, color=GREY, resolution=(21, 21)):
sphere = Sphere(resolution=resolution)
sphere.set_height(height)
sphere.set_color(color)
return sphere
def get_bit_string(bit_coords):
result = VGroup(*[Integer(int(b)) for b in bit_coords])
result.arrange(RIGHT, buff=SMALL_BUFF)
result.set_stroke(BLACK, 4, background=True)
return result
class Chessboard(SGroup):
CONFIG = {
"shape": (8, 8),
"height": 7,
"depth": 0.25,
"colors": [LIGHT_GREY, DARKER_GREY],
"gloss": 0.2,
"square_resolution": (3, 3),
"top_square_resolution": (5, 5),
}
def __init__(self, **kwargs):
super().__init__(**kwargs)
nr, nc = self.shape
cube = Cube(square_resolution=self.square_resolution)
# Replace top square with something slightly higher res
top_square = Square3D(resolution=self.top_square_resolution)
top_square.replace(cube[0])
cube.replace_submobject(0, top_square)
self.add(*[cube.copy() for x in range(nc * nr)])
self.arrange_in_grid(nr, nc, buff=0)
self.set_height(self.height)
self.set_depth(self.depth, stretch=True)
for i, j in it.product(range(nr), range(nc)):
color = self.colors[(i + j) % 2]
self[i * nc + j].set_color(color)
self.center()
self.set_gloss(self.gloss)
class Coin(Group):
CONFIG = {
"disk_resolution": (4, 51),
"height": 1,
"depth": 0.1,
"color": GOLD_D,
"tails_color": RED,
"include_labels": True,
"numeric_labels": False,
}
def __init__(self, **kwargs):
super().__init__(**kwargs)
res = self.disk_resolution
self.top = Disk3D(resolution=res, gloss=0.2)
self.bottom = self.top.copy()
self.top.shift(OUT)
self.bottom.shift(IN)
self.edge = Cylinder(height=2, resolution=(res[1], 2))
self.add(self.top, self.bottom, self.edge)
self.rotate(90 * DEGREES, OUT)
self.set_color(self.color)
self.bottom.set_color(RED)
if self.include_labels:
chars = "10" if self.numeric_labels else "HT"
labels = VGroup(*[TextMobject(c) for c in chars])
for label, vect in zip(labels, [OUT, IN]):
label.shift(1.02 * vect)
label.set_height(0.8)
labels[1].rotate(PI, RIGHT)
labels.apply_depth_test()
labels.set_stroke(width=0)
self.add(*labels)
self.labels = labels
self.set_height(self.height)
self.set_depth(self.depth, stretch=True)
def is_heads(self):
return self.top.get_center()[2] > self.bottom.get_center()[2]
def flip(self, axis=RIGHT):
super().flip(axis)
return self
class CoinsOnBoard(Group):
CONFIG = {
"proportion_of_square_height": 0.7,
"coin_config": {},
}
def __init__(self, chessboard, **kwargs):
super().__init__(**kwargs)
prop = self.proportion_of_square_height
for cube in chessboard:
coin = Coin(**self.coin_config)
coin.set_height(prop * cube.get_height())
coin.next_to(cube, OUT, buff=0)
self.add(coin)
def flip_at_random(self, p=0.5):
bools = np.random.random(len(self)) < p
self.flip_by_bools(bools)
return self
def flip_by_message(self, message):
self.flip_by_bools(string_to_bools(message))
return self
def flip_by_bools(self, bools):
for coin, head in zip(self, bools):
if coin.is_heads() ^ head:
coin.flip()
return self
def get_bools(self):
return [coin.is_heads() for coin in self]
class Key(SVGMobject):
CONFIG = {
"file_name": "key",
"fill_color": YELLOW_D,
"fill_opacity": 1,
"stroke_color": YELLOW_D,
"stroke_width": 0,
"gloss": 0.5,
"depth_test": True,
}
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.rotate(PI / 2, OUT)
class FlipCoin(Animation):
CONFIG = {
"axis": RIGHT,
"run_time": 1,
"shift_dir": OUT,
}
def __init__(self, coin, **kwargs):
super().__init__(coin, **kwargs)
self.shift_vect = coin.get_height() * self.shift_dir / 2
def interpolate_mobject(self, alpha):
coin = self.mobject
for sm, start_sm in self.families:
sm.points[:] = start_sm.points
coin.rotate(alpha * PI, axis=self.axis)
coin.shift(4 * alpha * (1 - alpha) * self.shift_vect)
return coin
# Scenes
class IntroducePuzzle(Scene):
CONFIG = {
"camera_class": ThreeDCamera,
}
def construct(self):
# Setup
frame = self.camera.frame
chessboard = Chessboard()
chessboard.move_to(ORIGIN, OUT)
grid = NumberPlane(
x_range=(0, 8), y_range=(0, 8),
faded_line_ratio=0
)
grid.match_height(chessboard)
grid.next_to(chessboard, OUT, 1e-8)
low_grid = grid.copy()
low_grid.next_to(chessboard, IN, 1e-8)
grid.add(low_grid)
grid.set_stroke(GREY, width=2)
grid.set_gloss(0.5)
grid.prepare_for_nonlinear_transform(0)
coins = CoinsOnBoard(chessboard)
coins.set_gloss(0.2)
coins_to_flip = Group()
head_bools = string_to_bools('3b1b :)')
for coin, heads in zip(coins, head_bools):
if not heads:
coins_to_flip.add(coin)
coins_to_flip.shuffle()
count_label = VGroup(
Integer(0, edge_to_fix=RIGHT),
TextMobject("Coins")
)
count_label.arrange(RIGHT, aligned_edge=DOWN)
count_label.to_corner(UL)
count_label.fix_in_frame()
# Draw board and coins
frame.set_rotation(-25 * DEGREES, 70 * DEGREES, 0)
self.play(
FadeIn(chessboard),
ShowCreationThenDestruction(grid, lag_ratio=0.01),
frame.set_theta, 0,
frame.set_phi, 45 * DEGREES,
run_time=3,
)
self.wait()
self.add(count_label)
self.play(
ShowIncreasingSubsets(coins),
UpdateFromFunc(count_label[0], lambda m, c=coins: m.set_value(len(c))),
rate_func=bezier([0, 0, 1, 1]),
run_time=2,
)
self.wait()
self.play(LaggedStartMap(FlipCoin, coins_to_flip, run_time=6, lag_ratio=0.1))
self.add(coins)
self.wait()
# Show key
key = Key()
key.rotate(PI / 4, RIGHT)
key.move_to(3 * OUT)
key.scale(0.8)
key.to_edge(LEFT, buff=1)
k = boolian_linear_combo(head_bools) ^ 63 # To make the flip below the actual solution
key_cube = Cube(square_resolution=(6, 6))
key_cube.match_color(chessboard[k])
key_cube.replace(chessboard[k], stretch=True)
chessboard.replace_submobject(k, key_cube)
key_square = key_cube[0]
chessboard.generate_target()
chessboard.save_state()
for i, cube in enumerate(chessboard.target):
if i == k:
cube[0].set_color(MAROON_E)
else:
cube.set_color(interpolate_color(cube.get_color(), BLACK, 0.8))
key.generate_target()
key.target.rotate(PI / 4, LEFT)
key.target.set_width(0.7 * key_square.get_width())
key.target.next_to(key_square, IN, buff=SMALL_BUFF)
self.play(FadeIn(key, LEFT))
self.wait()
self.play(
FadeOut(coins, lag_ratio=0.01),
MoveToTarget(chessboard),
)
ks_top = key_square.get_top()
self.play(
Rotate(key_square, PI / 2, axis=LEFT, about_point=ks_top),
MoveToTarget(key),
frame.set_phi, 60 * DEGREES,
run_time=2,
)
self.play(
Rotate(key_square, PI / 2, axis=RIGHT, about_point=ks_top),
run_time=2,
)
chessboard.saved_state[k][0].match_color(key_square)
self.play(
chessboard.restore,
FadeIn(coins),
frame.set_phi, 0 * DEGREES,
frame.move_to, 2 * LEFT,
run_time=3
)
# State goal
goal = TextMobject(
"Communicate where\\\\the key is",
" by turning\\\\over one coin.",
alignment=""
)
goal.next_to(count_label, DOWN, LARGE_BUFF, LEFT)
goal.fix_in_frame()
goal[1].set_color(YELLOW)
self.play(FadeIn(goal[0]))
self.wait()
self.play(FadeIn(goal[1]))
self.wait()
coin = coins[63]
rect = SurroundingRectangle(coin, color=TEAL)
rect.set_opacity(0.5)
rect.save_state()
rect.replace(chessboard)
rect.set_stroke(width=0)
rect.set_fill(opacity=0)
self.play(Restore(rect, run_time=2))
self.add(coin, rect)
self.play(FlipCoin(coin), FadeOut(rect))
class PrisonerPuzzleSetting(PiCreatureScene):
CONFIG = {
"camera_config": {
"background_color": GREY_E
}
}
def create_pi_creatures(self):
p1 = PiCreature(color=BLUE_C, height=2)
p2 = PiCreature(color=RED, height=2)
warden = PiCreature(color=GREY_BROWN, height=2.5)
warden.flip()
result = VGroup(p1, p2, warden)
result.arrange(RIGHT, buff=2, aligned_edge=DOWN)
warden.shift(RIGHT)
result.center().to_edge(DOWN, buff=1.5)
return result
def construct(self):
pis = self.pi_creatures
p1, p2, warden = self.pi_creatures
names = VGroup(
TextMobject("Prisoner 1\\\\(you)"),
TextMobject("Prisoner 2"),
TextMobject("Warden"),
)
for name, pi in zip(names, pis):
name.match_color(pi.body)
name.next_to(pi, DOWN)
question = TextMobject(
"Why do mathematicians\\\\always set their puzzles\\\\in prisons?",
alignment=""
)
question.to_corner(UR)
self.remove(warden)
warden.look_at(p2.eyes)
self.play(
LaggedStartMap(FadeIn, pis[:2], run_time=1.5, lag_ratio=0.3),
LaggedStartMap(FadeIn, names[:2], run_time=1.5, lag_ratio=0.3),
)
self.play(
p1.change, "sad",
p2.change, "pleading", warden.eyes
)
self.play(
FadeIn(warden),
FadeIn(names[2]),
)
self.play(warden.change, "conniving", p2.eyes)
self.wait()
self.play(FadeIn(question, lag_ratio=0.1))
self.wait(3)
self.play(FadeOut(question))
self.wait(2)
class FromCoinToSquareMaps(ThreeDScene):
CONFIG = {
"messages": [
"Please, ",
"go watch",
"Stand-up",
"Maths on",
"YouTube."
],
"flip_lag_ratio": 0.05,
}
def construct(self):
messages = self.messages
board1 = Chessboard()
board1.set_width(5.5)
board1.to_corner(DL)
board2 = board1.copy()
board2.to_corner(DR)
coins = CoinsOnBoard(board1)
bools = string_to_bools(messages[0])
for coin, head in zip(coins, bools):
if not head:
coin.flip(RIGHT)
for cube in board2:
cube.original_color = cube.get_color()
arrow = Arrow(board1.get_right(), board2.get_left())
arrow.tip.set_stroke(width=0)
title1 = TextMobject("Pattern of coins")
title2 = TextMobject("Individual square")
for title, board in [(title1, board1), (title2, board2)]:
title.scale(0.5 / title[0][0].get_height())
title.next_to(board, UP, MED_LARGE_BUFF)
title2.align_to(title1, UP)
def get_special_square(coins=coins, board=board2):
bools = [coin.is_heads() for coin in coins]
return board[boolian_linear_combo(bools)]
self.add(board1)
self.add(title1)
self.add(coins)
self.play(
GrowArrow(arrow),
FadeIn(board2, 2 * LEFT)
)
square = get_special_square()
rect = SurroundingRectangle(square, buff=0)
rect.set_color(PINK)
rect.next_to(square, OUT, buff=0.01)
self.play(
square.set_color, MAROON_C,
ShowCreation(rect),
FadeIn(title2)
)
for message in messages[1:]:
new_bools = string_to_bools(message)
coins_to_flip = Group()
for coin, to_heads in zip(coins, new_bools):
if coin.is_heads() ^ to_heads:
coins_to_flip.add(coin)
coins_to_flip.shuffle()
self.play(LaggedStartMap(
FlipCoin, coins_to_flip,
lag_ratio=self.flip_lag_ratio,
run_time=1,
))
new_square = get_special_square()
self.play(
square.set_color, square.original_color,
new_square.set_color, MAROON_C,
rect.move_to, new_square, OUT,
rect.shift, 0.01 * OUT,
)
square = new_square
self.wait()
class FromCoinToSquareMapsSingleFlips(FromCoinToSquareMaps):
CONFIG = {
"messages": [
"FlipBits",
"BlipBits",
"ClipBits",
"ChipBits",
"ChipBats",
"ChipRats",
]
}
class DiagramOfProgression(ThreeDScene):
def construct(self):
# Setup panels
P1_COLOR = BLUE_C
P2_COLOR = RED
rect = Rectangle(4, 2)
rect.set_fill(GREY_E, 1)
panels = Group()
for x in range(4):
panels.add(Group(rect.copy()))
panels.arrange_in_grid(buff=1)
panels[::2].shift(0.5 * LEFT)
panels.set_width(FRAME_WIDTH - 2)
panels.center().to_edge(DOWN)
p1_shift = panels[1].get_center() - panels[0].get_center()
panels[1].move_to(panels[0])
chessboard = Chessboard()
chessboard.set_height(0.9 * panels[0].get_height())
coins = CoinsOnBoard(
chessboard,
coin_config={
"disk_resolution": (2, 25),
}
)
coins.flip_by_message("Tau > Pi")
for panel in panels[1:]:
cb = chessboard.copy()
co = coins.copy()
cb.next_to(panel.get_right(), LEFT)
co.next_to(cb, OUT, 0)
panel.chessboard = cb
panel.coins = co
panel.add(cb, co)
kw = {
"tex_to_color_map": {
"Prisoner 1": P1_COLOR,
"Prisoner 2": P2_COLOR,
}
}
titles = VGroup(
TextMobject("Prisoners conspire", **kw),
TextMobject("Prisoner 1 sees key", **kw),
TextMobject("Prisoner 1 flips coin", **kw),
TextMobject("Prisoner 2 guesses key square", **kw),
)
for panel, title in zip(panels, titles):
title.next_to(panel, UP)
panel.title = title
panel.add(title)
# Darken first chessboard
for coin in panels[1].coins:
coin.remove(coin.edge)
if coin.is_heads():
coin.remove(coin.bottom)
coin.remove(coin.labels[1])
else:
coin.remove(coin.top)
coin.remove(coin.labels[0])
coin.set_opacity(0.25)
# Add characters
prisoner1 = PiCreature(color=P1_COLOR)
prisoner2 = PiCreature(color=P2_COLOR)
pis = VGroup(prisoner1, prisoner2)
pis.arrange(RIGHT, buff=1)
pis.set_height(1.5)
p0_pis = pis.copy()
p0_pis.set_height(2.0, about_edge=DOWN)
p0_pis[1].flip()
p0_pis.next_to(panels[0].get_bottom(), UP, SMALL_BUFF)
p0_pis[0].change("pondering", p0_pis[1].eyes)
p0_pis[1].change("speaking", p0_pis[0].eyes)
panels[0].add(p0_pis)
p1_pi = pis[0].copy()
p1_pi.next_to(panels[1].get_corner(DL), UR, SMALL_BUFF)
p1_pi.change("happy")
key = Key()
key.set_height(0.5)
key.next_to(p1_pi, UP)
key.set_color(YELLOW)
key_cube = panels[1].chessboard[18]
key_square = Square()
key_square.replace(key_cube)
key_square.set_stroke(width=3)
key_square.match_color(key)
p1_pi.look_at(key_square)
key_arrow = Arrow(
key.get_right() + SMALL_BUFF * UP,
key_square.get_corner(UL),
path_arc=-45 * DEGREES,
buff=SMALL_BUFF
)
key_arrow.tip.set_stroke(width=0)
key_arrow.match_color(key)
panels[1].add(p1_pi, key)
p2_pi = pis[0].copy()
p2_pi.next_to(panels[2].get_corner(DL), UR, SMALL_BUFF)
p2_pi.change("tease")
flip_coin = panels[2].coins[38]
panels[3].coins[38].flip()
flip_square = Square()
flip_square.replace(panels[2].chessboard[38])
flip_square.set_stroke(BLUE, 5)
for coin in panels[2].coins:
if coin is not flip_coin:
coin.remove(coin.edge)
if coin.is_heads():
coin.remove(coin.bottom)
coin.remove(coin.labels[1])
else:
coin.remove(coin.top)
coin.remove(coin.labels[0])
coin.set_opacity(0.25)
panels[2].add(p2_pi)
p3_pi = pis[1].copy()
p3_pi.next_to(panels[3].get_corner(DL), UR, SMALL_BUFF)
p3_pi.shift(MED_LARGE_BUFF * RIGHT)
p3_pi.change("confused")
panels[3].add(p3_pi)
# Animate each panel in
self.play(FadeIn(panels[1], DOWN))
self.play(
ShowCreation(key_arrow),
FadeInFromLarge(key_square),
)
panels[1].add(key_arrow, key_square)
self.wait()
self.play(FadeIn(panels[2], UP))
self.play(
ShowCreation(flip_square),
FlipCoin(flip_coin),
p2_pi.look_at, flip_coin,
)
self.wait()
self.play(FadeIn(panels[3], LEFT))
self.wait()
self.play(
FadeIn(panels[0], LEFT),
panels[1].shift, p1_shift,
)
self.wait()
class ImpossibleVariations(FromCoinToSquareMaps):
CONFIG = {
"messages": [
"FlipBits",
"BlipBits",
"ClipBits",
"ChipBits",
"ChipBats",
"ChipRats",
"ChipVats",
"ChipFats",
"ChapFats",
]
}
def construct(self):
# Definitions
frame = self.camera.frame
title = TextMobject("Describe any square\\\\with one flip")
title.set_height(1.2)
title.to_edge(UP)
title.fix_in_frame()
messages = it.cycle(self.messages)
left_board = Chessboard()
right_board = Chessboard()
for board, vect in (left_board, LEFT), (right_board, RIGHT):
board.set_width(4.5)
board.to_corner(DOWN + vect, buff=LARGE_BUFF)
coins = CoinsOnBoard(left_board)
coins.flip_by_message(next(messages))
arrow = Arrow(left_board.get_right(), right_board.get_left())
# Prepare for colorings
for cube in right_board:
cube.original_color = cube.get_color()
def get_special_square(board=right_board, coins=coins):
return board[boolian_linear_combo(coins.get_bools())]
frame.set_phi(45 * DEGREES)
# Introduce boards
self.add(title)
group = Group(*left_board, *coins, *right_board)
self.play(
LaggedStartMap(FadeInFromLarge, group, lambda m: (m, 1.3), lag_ratio=0.01),
GrowArrow(arrow)
)
# Flip one at a time
square = Square()
square.set_stroke(TEAL, 3)
square.replace(right_board[0])
square.move_to(right_board[0], OUT)
self.moving_square = square
self.colored_square = right_board[0]
for x in range(8):
self.set_board_message(next(messages), left_board, coins, get_special_square)
self.wait()
# To 6x6
to_fade = Group()
for grid in left_board, right_board, coins:
for n, mob in enumerate(grid):
row = n // 8
col = n % 8
if not ((0 < row < 7) and (0 < col < 7)):
to_fade.add(mob)
cross = Cross(title)
cross.fix_in_frame()
cross.set_stroke(RED, 8)
cross.shift(2 * LEFT)
imp_words = TextMobject("Impossible!")
imp_words.fix_in_frame()
imp_words.next_to(title, RIGHT, buff=1.5)
imp_words.shift(2 * LEFT)
imp_words.set_height(0.7)
imp_words.set_color(RED)
self.play(to_fade.set_opacity, 0.05)
self.play(
title.shift, 2 * LEFT,
FadeIn(cross, 2 * RIGHT),
FadeIn(imp_words, LEFT)
)
self.wait()
self.play(to_fade.set_opacity, 1)
# Remove a square
to_remove = Group(
left_board[63], right_board[63], coins[63]
)
remove_words = TextMobject("Remove one\\\\square")
remove_words.set_color(RED)
remove_words.to_corner(DOWN, buff=1.5)
remove_words.fix_in_frame()
self.play(
FadeIn(remove_words, DOWN),
FadeOut(to_remove, 3 * IN),
)
def set_board_message(self, message, left_board, coins, get_special_square):
new_bools = string_to_bools(message)
coins_to_flip = Group()
for coin, to_heads in zip(coins, new_bools):
if coin.is_heads() ^ to_heads:
coins_to_flip.add(coin)
coins_to_flip.shuffle()
self.play(LaggedStartMap(
FlipCoin, coins_to_flip,
lag_ratio=self.flip_lag_ratio,
run_time=1,
))
new_colored_square = get_special_square()
self.play(
new_colored_square.set_color, BLUE,
self.colored_square.set_color, self.colored_square.original_color,
self.moving_square.move_to, get_special_square(), OUT,
)
self.colored_square = new_colored_square
class ErrorCorrectionMention(Scene):
def construct(self):
# Setup board
message = "Do math!"
error_message = "Do meth!"
board = Chessboard()
board.set_width(5)
board.to_corner(DL)
coins = CoinsOnBoard(board)
coins.flip_by_message(message)
bools = coins.get_bools()
right_board = board.copy()
right_board.to_corner(DR)
right_board.set_opacity(0.5)
right_board[boolian_linear_combo(bools)].set_color(BLUE, 1)
arrow = Arrow(board.get_right(), right_board.get_left())
words = TextMobject("Feels a bit like ", "Error correction codes", "$\\dots$")
words.scale(1.2)
words.to_edge(UP)
self.add(board, coins, right_board)
self.add(arrow)
self.add(words)
# Go from board diagram to bit string
bits = VGroup()
for coin in coins:
bit = Integer(1 if coin.is_heads() else 0)
bit.replace(coin, dim_to_match=1)
bits.add(bit)
coin.generate_target()
coin.target.rotate(90 * DEGREES, RIGHT)
coin.target.set_opacity(0)
bits_rect = SurroundingRectangle(bits, buff=MED_SMALL_BUFF)
bits_rect.set_stroke(YELLOW, 2)
data_label = TextMobject("Data")
data_label.next_to(bits_rect, UP)
data_label.set_color(YELLOW)
meaning_label = TextMobject(f"``{message}''")
error_meaning_label = TextMobject(f"``{error_message}''")
for label in meaning_label, error_meaning_label:
label.scale(1.5)
label.next_to(arrow, RIGHT)
error_meaning_label[0][5].set_color(RED)
message_label = TextMobject("Message")
message_label.set_color(BLUE)
message_label.next_to(meaning_label, UP, buff=1.5)
message_label.to_edge(RIGHT, LARGE_BUFF)
message_arrow = Arrow(
message_label.get_bottom(),
meaning_label.get_top(),
)
message_arrow = Arrow(
message_label.get_left(),
meaning_label.get_top(),
path_arc=70 * DEGREES,
)
self.play(
LaggedStartMap(MoveToTarget, coins),
LaggedStartMap(FadeOut, board),
Write(bits),
run_time=3
)
self.play(
words[1].set_x, 0,
FadeOut(words[0], LEFT),
FadeOut(words[2], LEFT),
)
self.play(
ShowCreation(bits_rect),
FadeIn(data_label, DOWN)
)
self.play(
FadeOut(right_board),
FadeIn(message_label, DOWN),
ShowCreation(message_arrow),
FadeIn(meaning_label)
)
self.wait()
# Describe ECC
error_index = 8 * 4 + 5
error_bit = bits[error_index]
error_bit.unlock_triangulation()
error_bit_rect = SurroundingRectangle(error_bit)
error_bit_rect.set_stroke(RED, 2)
self.play(
FadeInFromLarge(error_bit_rect),
error_bit.set_value, 1 - error_bit.get_value(),
error_bit.set_color, RED,
)
meaning_label.save_state()
meaning_label.unlock_triangulation()
self.play(
Transform(meaning_label, error_meaning_label)
)
self.wait()
# Ask about correction
question = TextMobject("How can you\\\\detect the error?")
question.next_to(bits_rect, RIGHT, aligned_edge=UP)
self.play(Write(question))
self.wait(2)
ecc = VGroup()
for bit in int_to_bit_coords(boolian_linear_combo(bools), 6):
ecc.add(Integer(bit).match_height(bits[0]))
ecc.arrange(RIGHT, buff=0.2)
ecc.set_color(GREEN)
ecc.next_to(bits, RIGHT, MED_LARGE_BUFF, aligned_edge=DOWN)
ecc_rect = SurroundingRectangle(ecc, buff=MED_SMALL_BUFF)
ecc_rect.set_stroke(GREEN, 2)
ecc_name = words[1]
ecc_name.generate_target()
ecc_name.target[-1].set_opacity(0)
ecc_name.target.scale(0.75)
ecc_name.target.next_to(ecc_rect)
ecc_name.target.match_color(ecc)
frame = self.camera.frame
self.play(
MoveToTarget(ecc_name),
ShowIncreasingSubsets(ecc),
ShowCreation(ecc_rect),
ApplyMethod(frame.move_to, DOWN, run_time=2)
)
self.wait()
# Show correction at play
lines = VGroup()
for bit in bits:
line = Line(ecc_rect.get_top(), bit.get_center())
line.set_stroke(GREEN, 1, opacity=0.7)
lines.add(line)
alert = TexMobject("!!!")[0]
alert.arrange(RIGHT, buff=SMALL_BUFF)
alert.scale(1.5)
alert.set_color(RED)
alert.next_to(ecc_rect, UP)
self.play(LaggedStartMap(
ShowCreationThenFadeOut, lines,
lag_ratio=0.02, run_time=3
))
self.play(FadeIn(alert, DOWN, lag_ratio=0.2))
self.wait()
self.play(ShowCreation(lines, lag_ratio=0))
for line in lines:
line.generate_target()
line.target.become(lines[error_index])
self.play(LaggedStartMap(MoveToTarget, lines, lag_ratio=0, run_time=1))
self.play(
error_bit.set_value, 0,
Restore(meaning_label)
)
self.play(
FadeOut(lines),
FadeOut(alert),
FadeOut(error_bit_rect),
error_bit.set_color, WHITE,
)
self.wait()
# Hamming name
hamming_label = TextMobject("e.g. Hamming codes")
hamming_label.move_to(ecc_name, LEFT)
self.play(
Write(hamming_label),
FadeOut(ecc_name, DOWN)
)
self.wait()
class StandupMathsWrapper(Scene):
CONFIG = {
"title": "Solution on Stand-up Maths"
}
def construct(self):
fsr = FullScreenFadeRectangle()
fsr.set_fill(GREY_E, 1)
self.add(fsr)
title = TextMobject(self.title)
title.scale(1.5)
title.to_edge(UP)
rect = ScreenRectangle(height=6)
rect.set_stroke(WHITE, 2)
rect.set_fill(BLACK, 1)
rect.next_to(title, DOWN)
rb = AnimatedBoundary(rect)
self.add(rect, rb)
self.play(Write(title))
self.wait(30)
class ComingUpWrapper(StandupMathsWrapper):
CONFIG = {
"title": "Coming up"
}
class TitleCard(Scene):
def construct(self):
n = 6
board = Chessboard(shape=(n, n))
for square in board:
square.set_color(interpolate_color(square.get_color(), BLACK, 0.25))
# board[0].set_opacity(0)
grid = NumberPlane(
x_range=(0, n),
y_range=(0, n),
faded_line_ratio=0
)
grid.match_height(board)
grid.next_to(board, OUT, 1e-8)
low_grid = grid.copy()
low_grid.next_to(board, IN, 1e-8)
grid.add(low_grid)
grid.set_stroke(GREY, width=1)
grid.set_gloss(0.5)
grid.prepare_for_nonlinear_transform(0)
grid.rotate(PI, RIGHT)
frame = self.camera.frame
frame.set_phi(45 * DEGREES)
text = TextMobject("The impossible\\\\chessboard puzzle")
# text.set_width(board.get_width() - 0.5)
text.set_width(FRAME_WIDTH - 2)
text.set_stroke(BLACK, 10, background=True)
text.fix_in_frame()
self.play(
ApplyMethod(frame.set_phi, 0, run_time=5),
ShowCreationThenDestruction(grid, lag_ratio=0.02, run_time=3),
LaggedStartMap(FadeIn, board, run_time=3, lag_ratio=0),
Write(text, lag_ratio=0.1, run_time=3, stroke_color=BLUE_A),
)
self.wait(2)
class WhatAreWeDoingHere(TeacherStudentsScene):
def construct(self):
self.student_says(
"Wait, what are we\\\\doing here then?",
target_mode="sassy",
added_anims=[self.get_student_changes("hesitant", "angry", "sassy")],
run_time=2
)
self.play(self.teacher.change, "tease")
self.wait(6)
class HowCanWeVisualizeSolutions(TeacherStudentsScene):
def construct(self):
self.teacher_says(
"How can we\\\\visualize solutions",
bubble_kwargs={
"height": 3,
"width": 4,
"fill_opacity": 0,
},
added_anims=[self.get_student_changes("pondering", "thinking", "pondering")]
)
self.look_at(self.screen),
self.wait(1)
self.change_student_modes("thinking", "erm", "confused")
self.wait(5)
class TwoSquareCase(ThreeDScene):
CONFIG = {
"coin_names": ["c_0", "c_1"]
}
def construct(self):
frame = self.camera.frame
# Transition to just two square
chessboard = Chessboard()
chessboard.shift(2 * IN + UP)
coins = CoinsOnBoard(chessboard)
coins.flip_by_message("To 2 bits")
to_remove = Group(*it.chain(*zip(chessboard[:1:-1], coins[:1:-1])))
small_board = chessboard[:2]
coin_pair = coins[:2]
small_group = Group(small_board, coin_pair)
frame.set_phi(45 * DEGREES)
two_square_words = TextMobject("What about a 2-square board?")
two_square_words.fix_in_frame()
two_square_words.set_height(0.5)
two_square_words.center().to_edge(UP)
self.add(chessboard, coins)
self.play(
Write(two_square_words, run_time=1),
LaggedStartMap(
FadeOut, to_remove,
lambda m: (m, DOWN),
run_time=2,
lag_ratio=0.01
),
small_group.center,
small_group.set_height, 1.5,
frame.set_phi, 10 * DEGREES,
run_time=2
)
self.wait(3)
coins = coin_pair
# Show two locations for the key
key = Key()
key.set_width(0.7 * small_board[0].get_width())
key.move_to(small_board[0])
key.shift(0.01 * OUT)
coin_pair.shift(0.04 * OUT)
s0_top = small_board[0][0].get_top()
s1_top = small_board[1][0].get_top()
s0_rot_group = Group(small_board[0][0], coin_pair[0])
s1_rot_group = Group(small_board[1][0], coin_pair[1])
self.add(key)
angle = 170 * DEGREES
self.play(
Rotate(s0_rot_group, angle, LEFT, about_point=s0_top),
Rotate(s1_rot_group, angle, LEFT, about_point=s1_top),
frame.set_phi, 45 * DEGREES,
)
self.wait()
self.play(
key.match_x, small_board[1],
path_arc=PI,
path_arc_axis=UP,
)
self.wait()
self.play(
Rotate(s0_rot_group, angle, RIGHT, about_point=s0_top),
Rotate(s1_rot_group, angle, RIGHT, about_point=s1_top),
frame.set_phi, 0,
run_time=2,
)
self.wait()
# Show four states pointing to two message
states = VGroup(*[
TextMobject(letters, tex_to_color_map={"H": GOLD, "T": RED_D})
for letters in ["TT", "HT", "TH", "HH"]
])
states.set_height(0.8)
states.arrange(DOWN, buff=1)
states.to_edge(LEFT)
self.play(
FadeOut(two_square_words),
FlipCoin(coins[1]),
FadeIn(states[0])
)
self.play(
FlipCoin(coins[0]),
FadeIn(states[1])
)
self.play(
FlipCoin(coins[0]),
FlipCoin(coins[1]),
FadeIn(states[2])
)
self.play(
FlipCoin(coins[0]),
FadeIn(states[3])
)
self.wait()
key_copy = key.copy()
key_copy.match_x(small_board[0])
small_board_copy = small_board.copy()
small_boards = Group(small_board_copy, small_board)
for board, vect in zip(small_boards, [UP, DOWN]):
board.generate_target()
board.target.set_opacity(0.7)
board.target.shift(2 * vect)
board.target.set_depth(0.01, stretch=True)
self.add(key, key_copy, *small_boards)
self.play(
FadeOut(coins),
MoveToTarget(small_board),
MaintainPositionRelativeTo(key, small_board),
MoveToTarget(small_board_copy),
MaintainPositionRelativeTo(key_copy, small_board_copy),
)
self.add(*small_boards, key, key_copy)
arrows = VGroup()
for i in range(4):
arrows.add(Arrow(states[i].get_right(), small_boards[i // 2].get_left()))
arrows.set_opacity(0.75)
self.play(LaggedStartMap(GrowArrow, arrows, lag_ratio=0.3))
self.wait()
# Show one flip changing interpretation
coins.next_to(states, LEFT, buff=1.5)
def get_state(coins=coins):
bools = [c.is_heads() for c in coins]
return sum([b * (2**n) for n, b in enumerate(reversed(bools))])
n = 3
state_rect = SurroundingRectangle(states[n])
board_rects = VGroup()
for board in small_boards:
br = SurroundingRectangle(board, buff=0)
br.move_to(board, OUT)
br.set_stroke(YELLOW, 3)
board_rects.add(br)
self.play(
ApplyMethod(frame.shift, 4.5 * LEFT, run_time=1),
FadeIn(coins),
FadeIn(state_rect),
FadeIn(board_rects[1]),
arrows[n].set_color, YELLOW,
arrows[n].set_opacity, 1,
)
self.wait()
self.play(
FlipCoin(coins[1]),
FadeOut(board_rects[1]),
FadeIn(board_rects[0]),
state_rect.move_to, states[1],
arrows[3].match_style, arrows[0],
arrows[1].match_style, arrows[3],
)
self.wait()
self.play(
FlipCoin(coins[0]),
state_rect.move_to, states[0],
arrows[0].match_style, arrows[1],
arrows[1].match_style, arrows[3],
)
self.wait()
self.play(
FlipCoin(coins[0]),
state_rect.move_to, states[1],
arrows[0].match_style, arrows[1],
arrows[1].match_style, arrows[0],
)
self.wait()
# Erase H and T, replace with 1 and 0
bin_states = VGroup(*[
TextMobject(letters, tex_to_color_map={"1": GOLD, "0": RED_D})
for letters in ["00", "10", "01", "11"]
])
for bin_state, state in zip(bin_states, states):
for bit, letter in zip(bin_state, state):
bit.replace(letter, dim_to_match=1)
bin_coins = CoinsOnBoard(small_board, coin_config={"numeric_labels": True})
bin_coins[1].flip()
bin_coins.move_to(coins)
self.play(
FadeOut(coins, IN),
FadeIn(bin_coins),
)
self.play(
LaggedStartMap(GrowFromCenter, Group(*bin_states.family_members_with_points())),
LaggedStartMap(ApplyMethod, Group(*states.family_members_with_points()), lambda m: (m.scale, 0)),
)
self.wait()
# Add labels
c_labels = VGroup(*[
TexMobject(name)
for name in self.coin_names
])
arrow_kw = {
"tip_config": {
"width": 0.2,
"length": 0.2,
},
"buff": 0.1,
"color": GREY_B,
}
# s_label_arrows = VGroup()
# for high_square, low_square, label in zip(*small_boards, s_labels):
# label.move_to(Group(high_square, low_square))
# label.arrows = VGroup(
# Arrow(label.get_bottom(), low_square.get_top(), **arrow_kw),
# Arrow(label.get_top(), high_square.get_bottom(), **arrow_kw),
# )
# s_label_arrows.add(*label.arrows)
# self.play(
# FadeIn(label),
# *map(GrowArrow, label.arrows)
# )
c_label_arrows = VGroup()
for label, coin in zip(c_labels, bin_coins):
label.next_to(coin, UP, LARGE_BUFF)
arrow = Arrow(label.get_bottom(), coin.get_top(), **arrow_kw)
c_label_arrows.add(arrow)
self.play(
FadeIn(label),
GrowArrow(arrow)
)
self.wait()
# Coin 1 communicates location
bit1_rect = SurroundingRectangle(
VGroup(
bin_states[0][1],
bin_states[-1][1],
),
buff=SMALL_BUFF,
)
coin1_rect = SurroundingRectangle(
Group(c_labels[1], bin_coins[1]),
buff=SMALL_BUFF,
)
for rect in bit1_rect, coin1_rect:
rect.insert_n_curves(100)
nd = int(12 * get_norm(rect.get_area_vector()))
rect.become(DashedVMobject(rect, num_dashes=nd))
rect.set_stroke(WHITE, 2)
kw = {
"stroke_width": 2,
"stroke_color": YELLOW,
"buff": 0.05,
}
zero_rects, one_rects = [
VGroup(
SurroundingRectangle(bin_states[0][1], **kw),
SurroundingRectangle(bin_states[1][1], **kw),
),
VGroup(
SurroundingRectangle(bin_states[2][1], **kw),
SurroundingRectangle(bin_states[3][1], **kw),
),
]
self.play(
ShowCreation(bit1_rect),
ShowCreation(coin1_rect),
FadeOut(state_rect),
)
self.wait()
self.play(board_rects[0].stretch, 0.5, 0, {"about_edge": LEFT})
self.play(ShowCreation(zero_rects))
self.wait()
self.play(
FadeOut(board_rects[0]),
FadeOut(zero_rects),
FadeIn(board_rects[1])
)
self.play(
board_rects[1].stretch, 0.5, 0, {"about_edge": RIGHT}
)
self.play(
FlipCoin(bin_coins[1]),
arrows[1].match_style, arrows[0],
arrows[3].match_style, arrows[1],
)
self.play(ShowCreation(one_rects[1]))
self.wait()
# Talk about null bit
null_word = TextMobject("Null bit")
null_word.next_to(bin_coins[0], DOWN, buff=1.5, aligned_edge=LEFT)
null_arrow = Arrow(null_word.get_top(), bin_coins[0].get_bottom())
self.play(
Write(null_word),
GrowArrow(null_arrow)
)
self.wait()
for i in (0, 1, 0):
self.play(
FlipCoin(bin_coins[0]),
arrows[3 - i].match_style, arrows[0],
arrows[2 + i].match_style, arrows[3 - i],
FadeOut(one_rects[1 - i]),
FadeIn(one_rects[i]),
)
self.wait()
# Written mathematically
frame.generate_target()
frame.target.set_height(10, about_edge=DOWN)
rule_words = TextMobject("Rule: Just look at coin 1")
rule_words.set_height(0.6)
rule_words.next_to(frame.target.get_corner(UL), DR, buff=0.5)
rule_arrow = Vector(1.5 * RIGHT)
rule_arrow.next_to(rule_words, RIGHT)
rule_arrow.set_color(BLUE)
rule_equation = TexMobject("K", "=", self.coin_names[1])
rule_equation_long = TexMobject(
"K", "=", "0", "\\cdot",
self.coin_names[0], "+", "1", "\\cdot",
self.coin_names[1],
)
for equation in rule_equation, rule_equation_long:
equation.set_color_by_tex("S", YELLOW)
equation.set_height(0.7)
equation.next_to(rule_arrow, RIGHT)
s_labels = VGroup(
TexMobject("K", "= 0"),
TexMobject("K", "= 1"),
)
for label, board in zip(s_labels, small_boards):
label.set_height(0.5)
label.next_to(board, UP)
label.set_color_by_tex("S", YELLOW)
self.play(
MoveToTarget(frame),
FadeIn(rule_words, 2 * DOWN)
)
self.wait()
for label in s_labels:
self.play(Write(label))
self.wait()
self.play(
GrowArrow(rule_arrow),
FadeIn(rule_equation, LEFT),
)
self.wait()
mid_equation = rule_equation_long[2:-1]
mid_equation.save_state()
mid_equation.scale(0, about_edge=LEFT)
self.play(
Transform(rule_equation[:2], rule_equation_long[:2]),
Transform(rule_equation[2], rule_equation_long[-1]),
Restore(mid_equation),
)
self.wait()
self.remove(bin_coins)
for mob in self.mobjects:
for submob in mob.get_family():
if isinstance(submob, TexSymbol):
submob.set_stroke(BLACK, 8, background=True)
self.add(bin_coins)
class TwoSquaresAB(TwoSquareCase):
CONFIG = {
"coin_names": ["a", "b"]
}
class IGotThis(TeacherStudentsScene):
def construct(self):
self.student_says(
"Pssh, I got this",
target_mode="tease",
look_at_arg=self.screen,
added_anims=[self.teacher.change, "happy", self.screen],
run_time=2,
)
self.change_student_modes(
"thinking", "pondering",
look_at_arg=self.screen
)
self.wait(6)
class WalkingTheSquare(ThreeDScene):
def construct(self):
# Setup objects
plane = NumberPlane(
x_range=(-2, 2, 1),
y_range=(-2, 2, 1),
height=15,
width=15,
faded_line_ratio=3,
axis_config={"include_tip": False}
)
plane.move_to(1.5 * DOWN)
plane.add_coordinate_labels()
plane.x_axis.add_numbers([0])
board = Chessboard(shape=(1, 2))
board.set_height(1.5)
board.move_to(plane.c2p(-0.75, 0.75))
coins = CoinsOnBoard(
board,
coin_config={"numeric_labels": True}
)
coins.flip(RIGHT)
coords = [(0, 0), (0, 1), (1, 0), (1, 1)]
coord_labels = VGroup()
dots = VGroup()
for x, y in coords:
label = TexMobject(f"({x}, {y})")
point = plane.c2p(x, y)
label.next_to(point, UR, buff=0.25)
dot = Dot(point, radius=0.075)
dot.set_color(GREY)
dots.add(dot)
coord_labels.add(label)
active_dot = Dot(radius=0.15, color=YELLOW)
active_dot.move_to(plane.c2p(0, 0))
# Walk around square
self.play(Write(plane))
self.play(
FadeIn(board),
FadeIn(coins),
FadeIn(active_dot),
FadeIn(coord_labels[0]),
)
edges = VGroup()
for i, j, c in [(0, 1, 1), (1, 3, 0), (3, 2, 1), (2, 0, 0)]:
edge = Line(plane.c2p(*coords[i]), plane.c2p(*coords[j]))
edge.set_stroke(PINK, 3)
edges.add(edge)
anims = [
FlipCoin(coins[c]),
ShowCreation(edge),
ApplyMethod(active_dot.move_to, dots[j])
]
if j != 0:
anims += [
FadeInFromPoint(coord_labels[j], coord_labels[i].get_center()),
]
self.add(edge, dots[i], active_dot)
self.play(*anims)
self.add(edges, dots, active_dot)
self.wait()
# Show a few more flips
self.play(
FlipCoin(coins[0]),
active_dot.move_to, dots[2],
)
self.play(
FlipCoin(coins[1]),
active_dot.move_to, dots[3],
)
self.play(
FlipCoin(coins[1]),
active_dot.move_to, dots[2],
)
self.wait()
# Circles illustrating scheme
low_rect = SurroundingRectangle(
VGroup(edges[3], coord_labels[0], coord_labels[2], plane.x_axis.numbers[-1]),
buff=0.25,
)
low_rect.round_corners()
low_rect.insert_n_curves(30)
low_rect.set_stroke(YELLOW, 3)
high_rect = low_rect.copy()
high_rect.shift(dots[1].get_center() - dots[0].get_center())
key = Key()
key.set_color(YELLOW)
key.set_gloss(0)
key.match_width(board[0])
key.next_to(board[0], UP, SMALL_BUFF)
s_labels = VGroup(
TexMobject("\\text{Key} = 0").next_to(low_rect, UP, SMALL_BUFF),
TexMobject("\\text{Key} = 1").next_to(high_rect, UP, SMALL_BUFF),
)
self.play(
ShowCreation(low_rect),
)
self.play(
FadeIn(key, DOWN),
FadeIn(s_labels[0], DOWN),
)
self.play(
FlipCoin(coins[0]),
active_dot.move_to, dots[0],
)
self.wait(0.5)
self.play(
FlipCoin(coins[0]),
active_dot.move_to, dots[2],
)
self.wait()
self.play(
TransformFromCopy(low_rect, high_rect),
FadeIn(s_labels[1], DOWN),
low_rect.set_stroke, GREY, 1,
FlipCoin(coins[1]),
active_dot.move_to, dots[3],
key.match_x, board[1],
)
self.wait()
self.play(
FlipCoin(coins[0]),
active_dot.move_to, dots[1],
)
self.wait()
self.play(
FlipCoin(coins[1]),
active_dot.move_to, dots[0],
key.match_x, board[0],
high_rect.match_style, low_rect,
low_rect.match_style, high_rect,
)
self.wait()
class ThreeSquareCase(ThreeDScene):
CONFIG = {
"coin_names": ["c_0", "c_1", "c_2"]
}
def construct(self):
# Show sequence of boards
boards = Group(
Chessboard(shape=(1, 2), height=0.25 * 1),
Chessboard(shape=(1, 3), height=0.25 * 1),
Chessboard(shape=(2, 2), height=0.25 * 2),
Chessboard(shape=(8, 8), height=0.25 * 8),
)
dots = TexMobject("\\dots")
group = Group(*boards[:3], dots, boards[3])
group.arrange(RIGHT)
group.set_width(FRAME_WIDTH - 1)
board_groups = Group()
for board in boards:
board.coins = CoinsOnBoard(board, coin_config={"numeric_labels": True})
board_groups.add(Group(board, board.coins))
boards[0].coins.flip_at_random()
boards[1].coins.flip_by_bools([False, True, False])
boards[2].coins.flip_at_random()
boards[3].coins.flip_by_message("3 Fails!")
def get_board_transform(i, bgs=board_groups):
return TransformFromCopy(
bgs[i], bgs[i + 1],
path_arc=PI / 2,
run_time=2,
)
frame = self.camera.frame
frame.save_state()
frame.scale(0.5)
frame.move_to(boards[:2])
self.add(board_groups[0])
self.play(get_board_transform(0))
turn_animation_into_updater(Restore(frame, run_time=4))
self.add(frame)
self.play(get_board_transform(1))
self.play(
Write(dots),
get_board_transform(2),
)
self.wait()
# Isolate 3 square board
board_group = board_groups[1]
board = boards[1]
coins = board.coins
title = TextMobject("Three square case")
title.set_height(0.7)
title.to_edge(UP)
board_group.generate_target()
board_group.target.set_width(4)
board_group.target.move_to(DOWN, OUT)
self.save_state()
self.play(
MoveToTarget(board_group, rate_func=squish_rate_func(smooth, 0.5, 1)),
Write(title),
LaggedStartMap(FadeOut, Group(
board_groups[0],
board_groups[2],
dots,
board_groups[3],
), lambda m: (m, DOWN)),
run_time=2,
)
self.wait()
# Try 0*c0 + 1*c1 + 2*c2
s_sum = TexMobject(
"0", "\\cdot", self.coin_names[0], "+",
"1", "\\cdot", self.coin_names[1], "+",
"2", "\\cdot", self.coin_names[2],
)
s_sum.set_height(0.6)
c_sum = s_sum.copy()
s_sum.center().to_edge(UP)
c_sum.next_to(s_sum, DOWN, LARGE_BUFF)
coin_copies = Group()
for i in range(3):
part = c_sum.get_part_by_tex(self.coin_names[i], substring=False)
coin_copy = coins[i].copy()
coin_copy.set_height(1.2 * c_sum[0].get_height())
coin_copy.move_to(part)
coin_copy.align_to(c_sum, UP)
part.set_opacity(0)
coin_copies.add(coin_copy)
self.play(
FadeOut(title),
FadeIn(s_sum[:3]),
FadeIn(c_sum[:2]),
)
self.play(TransformFromCopy(coins[0], coin_copies[0]))
self.wait()
self.play(
FadeIn(s_sum[3:7]),
FadeIn(c_sum[3:6]),
)
self.play(TransformFromCopy(coins[1], coin_copies[1]))
self.wait()
self.play(
FadeIn(s_sum[7:11]),
FadeIn(c_sum[7:10]),
)
self.play(TransformFromCopy(coins[2], coin_copies[2]))
self.wait()
self.add(s_sum, c_sum, coin_copies)
rhs = VGroup(TexMobject("="), Integer(1))
rhs.arrange(RIGHT)
rhs[1].set_color(YELLOW)
rhs.match_height(c_sum[0])
rhs.next_to(c_sum, RIGHT, aligned_edge=UP)
braces = VGroup(
Brace(c_sum[0:3], DOWN),
Brace(c_sum[0:7], DOWN),
Brace(c_sum[0:11], DOWN),
)
for brace, n in zip(braces, [0, 1, 1]):
brace.add(brace.get_tex(n))
brace.unlock_triangulation()
self.play(GrowFromCenter(braces[0]))
self.wait()
self.play(ReplacementTransform(braces[0], braces[1]))
self.wait()
self.play(ReplacementTransform(braces[1], braces[2]))
self.play(
TransformFromCopy(braces[2][-1], rhs[1], path_arc=-PI / 2),
Write(rhs[0]),
)
self.play(FadeOut(braces[2]))
self.wait()
# Show values of S
s_labels = VGroup(*[
TexMobject(f"K = {n}")
for n in range(3)
])
for label, square in zip(s_labels, board):
label.next_to(square, UP)
label.set_width(0.8 * square.get_width())
label.set_color(YELLOW)
key = Key(depth_test=False)
key.set_stroke(BLACK, 3, background=True)
key.set_width(0.8 * board[0].get_width())
key.move_to(board[0])
self.play(
coins.next_to, board, DOWN,
coins.match_z, coins,
board.set_opacity, 0.75,
FadeIn(key),
FadeIn(s_labels[0])
)
self.wait(0.5)
for i in (1, 2):
self.play(
ApplyMethod(key.move_to, board[i], path_arc=-45 * DEGREES),
s_labels[i - 1].set_fill, GREY, 0.25,
FadeIn(s_labels[i]),
)
self.wait(0.5)
# Mod 3 label
mod3_label = TextMobject("(mod 3)")
mod3_label.match_height(s_sum)
mod3_label.set_color(BLUE)
mod3_label.next_to(s_sum, RIGHT, buff=0.75)
rhs_rhs = TexMobject("\\equiv 0")
rhs_rhs.match_height(rhs)
rhs_rhs.next_to(rhs, RIGHT)
self.play(Write(mod3_label))
self.wait()
rhs[1].unlock_triangulation()
self.play(
FlipCoin(coins[2]),
FlipCoin(coin_copies[2]),
rhs[1].set_value, 3,
)
self.wait()
self.play(Write(rhs_rhs))
self.wait()
self.play(
rhs[1].set_value, 0,
FadeOut(rhs_rhs)
)
# Show a few flips
for i in [2, 1, 0, 2, 1, 2, 0]:
bools = coins.get_bools()
bools[i] = not bools[i]
new_sum = sum([n * b for n, b in enumerate(bools)]) % 3
self.play(
FlipCoin(coins[i]),
FlipCoin(coin_copies[i]),
rhs[1].set_value, new_sum,
)
self.wait()
# Show general sum
general_sum = TexMobject(r"\sum ^{63}_{n=0}n\cdot c_n")
mod_64 = TextMobject("(mod 64)")
mod_64.next_to(general_sum, DOWN)
general_sum.add(mod_64)
general_sum.to_corner(UL)
self.play(FadeIn(general_sum))
self.wait()
self.play(FadeOut(general_sum))
# Walk through 010 example
board.flip_by_bools([False, False, True])
self.play(
s_labels[2].set_fill, GREY, 0.25,
s_labels[0].set_fill, YELLOW, 1,
ApplyMethod(key.move_to, board[0], path_arc=30 * DEGREES)
)
self.wait()
self.play(
FlipCoin(coins[1]),
FlipCoin(coin_copies[1]),
rhs[1].set_value, 0,
)
self.wait()
square = Square()
square.set_stroke(YELLOW, 3)
square.replace(board[0])
square[0].move_to(board[0], OUT)
self.play(ShowCreation(square))
self.wait()
self.play(FadeOut(square))
# Walk through alternate flip on 010 example
self.play(
FlipCoin(coins[1]),
FlipCoin(coin_copies[1]),
rhs[1].set_value, 1,
)
morty = Mortimer(height=1.5, mode="hooray")
morty.to_corner(DR)
bubble = SpeechBubble(height=2, width=2)
bubble.pin_to(morty)
bubble.write("There's another\\\\way!")
self.play(
FadeIn(morty),
ShowCreation(bubble),
Write(bubble.content, run_time=1),
)
self.play(Blink(morty))
self.play(
FadeOut(VGroup(morty, bubble, bubble.content))
)
self.play(
FlipCoin(coins[2]),
FlipCoin(coin_copies[2]),
rhs[1].set_value, 3,
)
self.wait()
self.play(rhs[1].set_value, 0)
self.wait()
class ThreeSquaresABC(ThreeSquareCase):
CONFIG = {
"coin_names": ["a", "b", "c"]
}
class FailedMod3Addition(Scene):
def construct(self):
coin = Coin(height=0.5, numeric_labels=True)
csum = Group(
TexMobject("0 \\cdot"),
coin.deepcopy().flip(),
TexMobject(" + 1 \\cdot"),
coin.deepcopy().flip(),
TexMobject("+ 2 \\cdot"),
coin.deepcopy(),
TexMobject("="),
Integer(2, color=YELLOW),
)
csum.arrange(RIGHT, buff=SMALL_BUFF)
csum[-1].unlock_triangulation()
csum[-1].shift(SMALL_BUFF * RIGHT)
coins = csum[1:7:2]
csum[-1].add_updater(lambda m, coins=coins: m.set_value(coins[1].is_heads() + 2 * coins[2].is_heads()))
self.add(csum)
for coin in coins[::-1]:
rect = SurroundingRectangle(coin)
self.play(ShowCreation(rect))
self.play(FlipCoin(coin))
self.wait()
self.play(FlipCoin(coin), FadeOut(rect))
self.wait()
self.embed()
class TreeOfThreeFlips(ThreeDScene):
def construct(self):
# Setup sums
csum = Group(
TexMobject("0 \\cdot"),
Coin(numeric_labels=True),
TexMobject("+\\,1 \\cdot"),
Coin(numeric_labels=True),
TexMobject("+\\,2 \\cdot"),
Coin(numeric_labels=True),
TexMobject("="),
Integer(0)
)
csum.coins = csum[1:7:2]
csum.coins.set_height(1.5 * csum[0].get_height())
csum.coins.flip(RIGHT)
csum.coins[1].flip(RIGHT)
csum.arrange(RIGHT, buff=0.1)
csum[-1].align_to(csum[0], DOWN)
csum[-1].shift(SMALL_BUFF * RIGHT)
csum.to_edge(LEFT)
csum_rect = SurroundingRectangle(csum, buff=SMALL_BUFF)
csum_rect.set_stroke(WHITE, 1)
# Set rhs values
def set_rhs_target(cs, colors=[RED, GREEN, BLUE]):
bools = [c.is_heads() for c in cs.coins]
value = sum([n * b for n, b in enumerate(bools)]) % 3
cs[-1].unlock_triangulation()
cs[-1].generate_target()
cs[-1].target.set_value(value)
cs[-1].target.set_color(colors[value])
return cs[-1]
rhs = set_rhs_target(csum)
rhs.become(rhs.target)
# Create copies
new_csums = Group()
for i in range(3):
new_csum = csum.deepcopy()
new_csum.coins = new_csum[1:7:2]
new_csums.add(new_csum)
new_csums.arrange(DOWN, buff=1.5)
new_csums.next_to(csum, RIGHT, buff=3)
# Arrows
arrows = VGroup()
for i, ncs in enumerate(new_csums):
arrow = Arrow(csum_rect.get_right(), ncs.get_left())
label = TextMobject(f"Flip coin {i}")
label.set_height(0.3)
label.set_fill(GREY_A)
label.set_stroke(BLACK, 3, background=True)
label.next_to(ORIGIN, UP, buff=0)
label.rotate(arrow.get_angle(), about_point=ORIGIN)
label.shift(arrow.get_center())
arrow.label = label
arrows.add(arrow)
arrows.set_color(GREY)
# Initial state label
is_label = TextMobject(
"Initial state: 010",
tex_to_color_map={"0": RED_D, "1": GOLD_D}
)
is_label.set_height(0.4)
is_label.next_to(csum_rect, UP, aligned_edge=LEFT)
# Show three flips
self.add(csum)
self.add(csum_rect)
self.add(is_label)
self.wait()
anims = []
for i, arrow, ncs in zip(it.count(), arrows, new_csums):
anims += [
GrowArrow(arrow),
FadeIn(arrow.label, lag_ratio=0.2),
]
self.play(LaggedStart(*anims))
for indices in [[0], [1, 2]]:
self.play(*[
TransformFromCopy(csum, new_csums[i], path_arc=30 * DEGREES, run_time=2)
for i in indices
])
self.wait()
for i in indices:
ncs = new_csums[i]
ncs.coins[i].flip()
rhs = set_rhs_target(ncs)
ncs.coins[i].flip()
self.play(
FlipCoin(ncs.coins[i]),
MoveToTarget(rhs)
)
# Put key in square 2
board = Chessboard(shape=(1, 3), square_resolution=(5, 5))
board.set_gloss(0.5)
board.set_width(3)
board.set_depth(0.25, stretch=True)
board.space_out_submobjects(factor=1.001)
board.next_to(ORIGIN, LEFT)
board.to_edge(UP)
board.shift(IN)
board.rotate(60 * DEGREES, LEFT)
opening_square = board[2][0]
opening_square_top = opening_square.get_corner(UP + IN)
key = Key()
key.to_corner(UL, buff=LARGE_BUFF)
key.shift(OUT)
key.generate_target()
key.target.scale(0.3)
key.target.rotate(60 * DEGREES, LEFT)
key.target.move_to(board[2][0])
self.play(
FadeIn(board, DOWN),
FadeIn(key)
)
self.play(
MoveToTarget(key, path_arc=30 * DEGREES),
Rotate(opening_square, 90 * DEGREES, LEFT, about_point=opening_square_top),
)
self.play(
Rotate(opening_square, 90 * DEGREES, RIGHT, about_point=opening_square_top),
key.next_to, board[1], RIGHT, buff=0.01,
)
self.wait()
self.remove(key)
self.play(Rotate(board, 0 * DEGREES, RIGHT, run_time=0))
self.play(Rotate(board, 60 * DEGREES, RIGHT))
# Put coins on
coins = csum.coins.copy()
for coin, cube in zip(coins, board):
coin.generate_target()
coin.target.next_to(cube, OUT, buff=0)
self.play(LaggedStartMap(MoveToTarget, coins, run_time=2))
self.wait()
class SeventyFivePercentChance(Scene):
def construct(self):
# Setup column
rows = []
n_shown = 5
coins = Group()
nums = VGroup()
for n in it.chain(range(n_shown), range(64 - n_shown, 64)):
coin = Coin(numeric_labels=True)
coin.set_height(0.7)
if (random.random() < 0.5 or (n == 2)) and (n != 62):
coin.flip()
num = Integer(n)
row = Group(
coin,
TexMobject("\\cdot"),
num,
TexMobject("+"),
)
VGroup(*row[1:]).set_stroke(BLACK, 3, background=True)
row.arrange(RIGHT, buff=MED_SMALL_BUFF)
rows.append(row)
coins.add(coin)
nums.add(num)
vdots = TexMobject("\\vdots")
rows = Group(*rows[:n_shown], vdots, *rows[n_shown:])
rows.arrange(DOWN, buff=MED_SMALL_BUFF, aligned_edge=LEFT)
vdots.match_x(rows[0][2])
rows.set_height(7)
rows.to_edge(RIGHT)
rows[-1][-1].set_opacity(0)
nums = VGroup(*nums[:n_shown], vdots, *nums[n_shown:])
self.play(Write(nums))
self.wait()
self.play(
LaggedStartMap(FadeIn, rows, lag_ratio=0.1, run_time=3),
Animation(nums.copy(), remover=True),
)
self.wait()
# Show desired sums
brace = Brace(rows, LEFT)
b_label = brace.get_text("Sum mod 64")
sum_label = TextMobject("=\\, 53 (say)")
sum_label.next_to(b_label, DOWN)
want_label = TextMobject("Need to encode 55 (say)")
want_label.next_to(sum_label, DOWN, buff=0.25, aligned_edge=RIGHT)
want_label.set_color(YELLOW)
need_label = TextMobject("Must add 2")
need_label.next_to(want_label, DOWN, buff=0.25)
need_label.set_color(BLUE)
for label in b_label, sum_label, want_label, need_label:
label.set_stroke(BLACK, 7, background=True)
self.play(
GrowFromCenter(brace),
FadeIn(b_label, RIGHT)
)
self.wait(2)
self.play(FadeIn(sum_label, 0.25 * UP))
self.wait(2)
self.play(LaggedStart(
FadeIn(want_label, UP),
FadeIn(need_label, UP),
lag_ratio=0.3
))
self.wait()
# Show attempts
s_rect = SurroundingRectangle(rows[2])
self.play(ShowCreation(s_rect))
self.wait()
self.play(FlipCoin(rows[2][0]))
self.wait(2)
self.play(
s_rect.move_to, rows[-2],
s_rect.stretch, 1.1, 0,
)
self.wait()
self.play(FlipCoin(rows[-2][0]))
self.wait()
class ModNStrategy(ThreeDScene):
def construct(self):
# Board
n_shown = 5
board = Chessboard()
coins = CoinsOnBoard(board, coin_config={"numeric_labels": True})
coins.flip_by_message(r"75% odds")
nums = VGroup()
for n, square in enumerate(board):
num = Integer(n)
num.set_height(0.4 * square.get_height())
num.next_to(square, OUT, buff=0)
nums.add(num)
nums.set_stroke(BLACK, 3, background=True)
coins.generate_target()
for coin in coins.target:
coin.set_opacity(0.2)
coin[-2:].set_opacity(0)
self.add(board)
self.add(coins)
self.wait()
self.play(
MoveToTarget(coins),
FadeIn(nums, lag_ratio=0.1)
)
self.wait()
# # Compress
# square_groups = Group(*[
# Group(square, coin, num)
# for square, coin, num in zip(board, coins, nums)
# ])
# segments = Group(
# square_groups[:n_shown],
# square_groups[n_shown:-n_shown],
# square_groups[-n_shown:],
# )
# segments.generate_target()
# dots = TexMobject("\\cdots")
# dots.center()
# segments.target[0].next_to(dots, LEFT)
# segments.target[2].next_to(dots, RIGHT)
# segments.target[1].scale(0)
# segments.target[1].move_to(dots)
# self.play(
# Write(dots),
# MoveToTarget(segments),
# )
# self.wait()
# self.remove(segments[1])
# # Raise coins
# coins = Group(*coins[:n_shown], *coins[-n_shown:])
# nums = VGroup(*nums[:n_shown], *nums[-n_shown:])
# board = Group(*board[:n_shown], *board[-n_shown:])
# self.play(
# coins.shift, UP,
# coins.set_opacity, 1,
# )
# Setup sum
mid_coins = coins[n_shown:-n_shown]
mid_nums = nums[n_shown:-n_shown]
coins = Group(*coins[:n_shown], *coins[-n_shown:])
nums = VGroup(*nums[:n_shown], *nums[-n_shown:])
nums.generate_target()
coins.generate_target()
coins.target.set_opacity(1)
full_sum = Group()
to_fade_in = VGroup()
for num, coin in zip(nums.target, coins.target):
coin.set_height(0.7)
num.set_height(0.5)
summand = Group(
coin,
TexMobject("\\cdot"),
num,
TexMobject("+"),
)
to_fade_in.add(summand[1], summand[3])
VGroup(*summand[1:]).set_stroke(BLACK, 3, background=True)
summand.arrange(RIGHT, buff=MED_SMALL_BUFF)
full_sum.add(summand)
dots = TexMobject("\\dots")
full_sum = Group(*full_sum[:n_shown], dots, *full_sum[n_shown:])
full_sum.arrange(RIGHT, buff=MED_SMALL_BUFF)
full_sum.set_width(FRAME_WIDTH - 1)
full_sum[-1][-1].scale(0, about_edge=LEFT)
full_sum.move_to(UP)
brace = Brace(full_sum, DOWN)
s_label = VGroup(
TextMobject("Sum (mod 64) = "),
Integer(53),
)
s_label[1].set_color(BLUE)
s_label[1].match_height(s_label[0][0][0])
s_label.arrange(RIGHT)
s_label[1].align_to(s_label[0][0][0], DOWN)
s_label.next_to(brace, DOWN)
words = TextMobject("Can't know if a flip will add or subtract")
words.to_edge(UP)
for mob in mid_coins, mid_nums:
mob.generate_target()
mob.target.move_to(dots)
mob.target.scale(0)
mob.target.set_opacity(0)
self.play(
FadeOut(board, IN),
MoveToTarget(mid_coins, remover=True),
MoveToTarget(mid_nums, remover=True),
MoveToTarget(nums),
MoveToTarget(coins),
Write(dots),
FadeIn(to_fade_in, lag_ratio=0.1),
run_time=2
)
self.play(
GrowFromCenter(brace),
FadeIn(s_label, 0.25 * UP)
)
self.wait()
self.play(Write(words, run_time=1))
self.wait()
# Do some flips
s_label[1].add_updater(lambda m: m.set_value(m.get_value() % 64))
for x in range(10):
n = random.randint(-n_shown, n_shown - 1)
coin = coins[n]
n = n % 64
diff_label = Integer(n, include_sign=True)
if not coin.is_heads():
diff_label.set_color(GREEN)
else:
diff_label.set_color(RED)
diff_label.set_value(-diff_label.get_value())
diff_label.next_to(coin, UP, aligned_edge=LEFT)
self.play(
ChangeDecimalToValue(
s_label[1],
s_label[1].get_value() + n,
rate_func=squish_rate_func(smooth, 0.5, 1)
),
FlipCoin(coin),
FadeIn(diff_label, 0.5 * DOWN)
)
self.play(FadeOut(diff_label))
self.wait()
class ShowCube(ThreeDScene):
def construct(self):
# Camera stuffs
frame = self.camera.frame
light = self.camera.light_source
light.move_to([-10, -10, 20])
# Plane and axes
plane = NumberPlane(
x_range=(-2, 2, 1),
y_range=(-2, 2, 1),
height=15,
width=15,
faded_line_ratio=3,
axis_config={"include_tip": False}
)
plane.add_coordinate_labels()
plane.coordinate_labels.set_stroke(width=0)
axes = ThreeDAxes(
x_range=(-2, 2, 1),
y_range=(-2, 2, 1),
z_range=(-2, 2, 1),
height=15,
width=15,
depth=15,
)
axes.apply_depth_test()
# Vertices and edges
vert_coords = [
(n % 2, (n // 2) % 2, (n // 4) % 2)
for n in range(8)
]
verts = []
coord_labels = VGroup()
coord_labels_2d = VGroup()
for coords in vert_coords:
vert = axes.c2p(*coords)
verts.append(vert)
x, y, z = coords
label = TexMobject(f"({x}, {y}, {z})")
label.set_height(0.3)
label.next_to(vert, UR, SMALL_BUFF)
label.rotate(89 * DEGREES, RIGHT, about_point=vert)
coord_labels.add(label)
if z == 0:
label_2d = TexMobject(f"({x}, {y})")
label_2d.set_height(0.3)
label_2d.next_to(vert, UR, SMALL_BUFF)
coord_labels_2d.add(label_2d)
edge_indices = [
(0, 1), (0, 2), (1, 3), (2, 3),
(0, 4), (1, 5), (2, 6), (3, 7),
(4, 5), (4, 6), (5, 7), (6, 7),
]
# Vertex and edge drawings
spheres = SGroup()
for vert in verts:
sphere = Sphere(
radius=0.1,
resolution=(9, 9),
)
sphere.set_gloss(0.3)
sphere.set_color(GREY)
sphere.move_to(vert)
spheres.add(sphere)
edges = SGroup()
for i, j in edge_indices:
edge = Line3D(
verts[i], verts[j],
resolution=(5, 51),
width=0.04,
gloss=0.5,
)
edge.set_color(GREY_BROWN)
edges.add(edge)
# Setup highlight animations
def highlight(n, spheres=spheres, coord_labels=coord_labels):
anims = []
for k, sphere, cl in zip(it.count(), spheres, coord_labels):
if k == n:
sphere.save_state()
cl.save_state()
sphere.generate_target()
cl.generate_target()
cl.target.set_fill(YELLOW)
sphere.target.set_color(YELLOW)
Group(cl.target, sphere.target).scale(1.5, about_point=sphere.get_center())
anims += [
MoveToTarget(sphere),
MoveToTarget(cl),
]
elif sphere.get_color() == Color(YELLOW):
anims += [
Restore(sphere),
Restore(cl),
]
return AnimationGroup(*anims)
# Setup 2d case
frame.move_to(1.5 * UP)
self.add(plane)
self.play(
LaggedStartMap(FadeIn, coord_labels_2d),
LaggedStartMap(GrowFromCenter, spheres[:4]),
LaggedStartMap(GrowFromCenter, edges[:4]),
)
self.wait()
# Transition to 3d case
frame.generate_target()
frame.target.set_rotation(-25 * DEGREES, 70 * DEGREES)
frame.target.move_to([1, 2, 0])
frame.target.set_height(10)
to_grow = Group(*edges[4:], *spheres[4:], *coord_labels[4:])
to_grow.save_state()
to_grow.set_depth(0, about_edge=IN, stretch=True)
rf = squish_rate_func(smooth, 0.5, 1)
self.play(
MoveToTarget(frame),
ShowCreation(axes.z_axis),
Restore(to_grow, rate_func=rf),
FadeOut(coord_labels_2d, rate_func=rf),
*[
FadeInFromPoint(cl, cl2.get_center(), rate_func=squish_rate_func(smooth, 0.5, 1))
for cl, cl2 in zip(coord_labels[:4], coord_labels_2d)
],
run_time=3
)
frame.start_time = self.time
frame.scene = self
frame.add_updater(lambda m: m.set_theta(
-25 * DEGREES * math.cos((m.scene.time - m.start_time) * PI / 60)
))
self.add(axes.z_axis)
self.add(edges)
self.add(spheres)
self.play(
LaggedStart(*[Indicate(s, color=GREEN) for s in spheres], run_time=2, lag_ratio=0.1),
LaggedStart(*[Indicate(c, color=GREEN) for c in coord_labels], run_time=2, lag_ratio=0.1),
)
# Add chessboard
board = Chessboard(
shape=(1, 3), height=1,
square_resolution=(5, 5),
)
board.move_to(plane.c2p(-1, 0), DOWN + IN)
coins = CoinsOnBoard(board, coin_config={"numeric_labels": True})
self.play(
FadeIn(board),
FadeIn(coins),
highlight(7)
)
# Walk along a few edges
for ci in [1, 2, 0, 1, 2, 1, 0, 1]:
coin = coins[ci]
curr_n = sum([(2**k) * c.is_heads() for k, c in enumerate(coins)])
coin.flip()
new_n = sum([(2**k) * c.is_heads() for k, c in enumerate(coins)])
coin.flip()
line = Line(verts[curr_n], verts[new_n])
line.set_stroke(YELLOW, 3)
self.play(
FlipCoin(coin),
highlight(new_n),
ShowCreationThenDestruction(line)
)
self.wait()
# Color the corners
self.play(
highlight(-1),
edges.set_color, GREY, 0.5,
)
colors = [RED, GREEN, BLUE_D]
title = TextMobject("Strategy", "\\, $\\Leftrightarrow$ \\,", "Coloring")
title[2].set_submobject_colors_by_gradient(*colors)
title.set_stroke(BLACK, 5, background=True)
title.set_height(0.7)
title.to_edge(UP)
title.shift(LEFT)
title.fix_in_frame()
color_label_templates = [
TexMobject(char, color=color).rotate(PI / 2, RIGHT).match_depth(coord_labels[0])
for char, color in zip("RGB", colors)
]
coord_labels.color_labels = VGroup(*[VMobject() for cl in coord_labels])
def get_coloring_animation(ns,
spheres=spheres,
coord_labels=coord_labels,
colors=colors,
color_label_templates=color_label_templates,
):
anims = []
new_color_labels = VGroup()
for n, sphere, coord_label, old_color_label in zip(ns, spheres, coord_labels, coord_labels.color_labels):
color = colors[int(n)]
sphere.generate_target()
coord_label.generate_target()
sphere.target.set_color(color)
coord_label.target.set_fill(color)
color_label = color_label_templates[n].copy()
color_label.next_to(coord_label, RIGHT, SMALL_BUFF)
anims += [
MoveToTarget(sphere),
MoveToTarget(coord_label),
FadeIn(color_label, 0.25 * IN),
FadeOut(old_color_label, 0.25 * OUT),
]
new_color_labels.add(color_label)
coord_labels.color_labels = new_color_labels
return LaggedStart(*anims, run_time=2)
self.play(
FadeIn(title, DOWN),
get_coloring_animation(np.random.randint(0, 3, 8)),
)
self.wait()
for x in range(4):
self.play(get_coloring_animation(np.random.randint(0, 3, 8)))
self.wait()
# Some specific color examples
S0 = TexMobject("\\text{Key} = 0")
S0.to_edge(LEFT)
S0.shift(UP)
S0.fix_in_frame()
self.play(
FadeIn(S0, DOWN),
get_coloring_animation([0] * 8)
)
self.wait(5)
bit_sum = TexMobject("\\text{Key} = \\,&c_0 + c_1")
bit_sum.scale(0.8)
bit_sum.to_edge(LEFT)
bit_sum.shift(UP)
bit_sum.fix_in_frame()
self.play(
FadeIn(bit_sum, DOWN),
FadeOut(S0, UP),
get_coloring_animation([sum(coords[:2]) for coords in vert_coords])
)
self.wait(6)
bit_sum_with_coefs = TexMobject(
"\\text{Key} = \\,&(0\\cdot c_0 + 1\\cdot c_1 + 2\\cdot c_2) \\\\ &\\quad \\mod 3"
)
bit_sum_with_coefs.scale(0.8)
bit_sum_with_coefs.move_to(bit_sum, LEFT)
bit_sum_with_coefs.fix_in_frame()
self.play(
FadeIn(bit_sum_with_coefs, DOWN),
FadeOut(bit_sum, UP),
get_coloring_animation([np.dot(coords, [0, 1, 2]) % 3 for coords in vert_coords])
)
self.wait(4)
# Focus on (0, 0, 0)
self.play(
FlipCoin(coins),
coord_labels[1:].set_opacity, 0.2,
coord_labels.color_labels[1:].set_opacity, 0.2,
spheres[1:].set_opacity, 0.2,
)
self.wait(2)
lines = VGroup()
for n in [1, 2, 4]:
line = Line(verts[0], verts[n], buff=0.1)
line.set_stroke(YELLOW, 3)
coin = coins[int(np.log2(n))]
self.play(
ShowCreationThenDestruction(line),
spheres[n].set_opacity, 1,
coord_labels[n].set_opacity, 1,
coord_labels.color_labels[n].set_opacity, 1,
FlipCoin(coin)
)
line.reverse_points()
self.add(line, coord_labels)
self.play(
FlipCoin(coin),
ShowCreation(line)
)
lines.add(line)
self.wait(10)
# Focus on (0, 1, 0)
self.play(
FlipCoin(coins[1]),
Uncreate(lines[1]),
FadeOut(lines[::2]),
Group(
spheres[0], coord_labels[0], coord_labels.color_labels[0],
spheres[1], coord_labels[1], coord_labels.color_labels[1],
spheres[4], coord_labels[4], coord_labels.color_labels[4],
).set_opacity, 0.2,
)
self.wait(3)
lines = VGroup()
curr_n = 2
for n in [1, 2, 4]:
new_n = n ^ curr_n
line = Line(verts[curr_n], verts[new_n], buff=0.1)
line.set_stroke(YELLOW, 3)
coin = coins[int(np.log2(n))]
self.play(
ShowCreationThenDestruction(line),
spheres[new_n].set_opacity, 1,
coord_labels[new_n].set_opacity, 1,
coord_labels.color_labels[new_n].set_opacity, 1,
FlipCoin(coin)
)
line.reverse_points()
self.add(line, coord_labels)
self.play(
FlipCoin(coin),
ShowCreation(line)
)
lines.add(line)
self.wait(10)
self.play(
LaggedStartMap(Uncreate, lines),
spheres.set_opacity, 1,
coord_labels.set_opacity, 1,
coord_labels.color_labels.set_opacity, 1,
FadeOut(bit_sum_with_coefs),
)
self.wait()
for x in range(8):
self.play(get_coloring_animation(np.random.randint(0, 3, 8)))
self.wait()
# Count all strategies
count = TextMobject("$3^8$ total strategies")
count64 = TextMobject("$64^{(2^{64})}$ total strategies")
for words in count, count64:
words.to_edge(LEFT, buff=MED_SMALL_BUFF)
words.shift(UP)
words.fix_in_frame()
full_board = Chessboard()
full_board.set_height(6)
full_board.next_to(axes.c2p(0, 0, 0), np.array([-1, 1, 1]), buff=0)
full_board.shift(SMALL_BUFF * UP + LEFT)
full_coins = CoinsOnBoard(full_board, coin_config={"numeric_labels": True})
full_coins.flip_by_message("64^ 2^64")
self.play(FadeIn(count, DOWN))
self.wait(4)
self.remove(board, coins)
frame.clear_updaters()
frame.generate_target()
frame.target.set_rotation(0, 45 * DEGREES)
frame.target.shift(2 * UP)
self.play(
count.shift, UP,
count.set_opacity, 0.5,
ShowIncreasingSubsets(full_board, run_time=4),
ShowIncreasingSubsets(full_coins, run_time=4),
FadeIn(count64, DOWN),
MoveToTarget(frame, run_time=5)
)
messages = [
"Or, use ",
"Burnside",
"to count",
"modulo ",
"symmetry",
]
for message in messages:
bools = string_to_bools(message)
to_flip = Group()
for head, coin in zip(bools, full_coins):
if head ^ coin.is_heads():
to_flip.add(coin)
self.play(
LaggedStartMap(FlipCoin, to_flip, run_time=1)
)
self.wait(0.5)
frame.generate_target()
frame.target.shift(2 * DOWN)
frame.target.set_rotation(-15 * DEGREES, 70 * DEGREES)
self.play(
MoveToTarget(frame, run_time=3),
LaggedStartMap(FadeOut, full_board),
LaggedStartMap(FadeOut, full_coins),
FadeOut(count),
FadeOut(count64),
)
frame.add_updater(lambda m, dt: m.increment_theta(0.01 * dt))
self.wait(30)
class CubeSupplement(ThreeDScene):
CONFIG = {
"try_different_strategies": False,
}
def construct(self):
# Map 8 states to square choices
boards = Group(*[Chessboard(shape=(1, 3)) for x in range(8)])
boards.arrange(DOWN, buff=0.5 * boards[0].get_height())
boards.set_height(7)
boards.to_edge(LEFT)
coin_sets = Group(*[
CoinsOnBoard(board, coin_config={"numeric_labels": True})
for board in boards
])
vert_coords = [[n // 4, (n // 2) % 2, n % 2] for n in range(7, -1, -1)]
for coords, coins in zip(vert_coords, coin_sets):
coins.flip_by_bools(coords)
def get_choice_boards(values, boards):
choices = VGroup()
for value, board in zip(values, boards):
choice = VGroup(*[Square() for x in range(3)])
choice.arrange(RIGHT, buff=0)
choice.match_height(board)
choice.next_to(board, RIGHT, buff=1.25)
choice.set_fill(GREY_D, 1)
choice.set_stroke(WHITE, 1)
choice[value].set_fill(TEAL)
choices.add(choice)
return choices
colors = [RED, GREEN, BLUE_D]
color_words = ["Red", "Green", "Blue"]
s_values = [sum([n * v for n, v in enumerate(cs)]) % 3 for cs in vert_coords]
choice_boards = get_choice_boards(s_values, boards)
c_labels = VGroup()
s_arrows = VGroup()
for value, board, choice_board in zip(s_values, boards, choice_boards):
arrow = Vector(RIGHT)
arrow.next_to(board, RIGHT, SMALL_BUFF)
c_label = TextMobject(color_words[value], color=colors[value])
c_label.next_to(choice_board, RIGHT)
c_labels.add(c_label)
s_arrows.add(arrow)
choice_board.generate_target()
choice_board.target[value].set_fill(colors[value])
self.play(
LaggedStartMap(FadeIn, boards, lag_ratio=0.25),
LaggedStartMap(FadeIn, coin_sets, lag_ratio=0.25),
run_time=3
)
self.play(
LaggedStartMap(GrowArrow, s_arrows, lag_ratio=0.25),
LaggedStartMap(FadeIn, choice_boards, lambda m: (m, LEFT), lag_ratio=0.25),
)
self.wait()
# Fork
if self.try_different_strategies:
for x in range(5):
values = list(np.arange(8) % 3)
random.shuffle(values)
new_cboards = get_choice_boards(values, boards)
self.play(
LaggedStartMap(FadeOut, choice_boards, lambda m: (m, 0.25 * UP)),
LaggedStartMap(FadeIn, new_cboards, lambda m: (m, 0.25 * DOWN)),
)
choice_boards = new_cboards
self.wait(2)
else:
# Associate choices with colors
self.play(
LaggedStartMap(MoveToTarget, choice_boards),
LaggedStartMap(FadeIn, c_labels),
)
self.wait()
class TryDifferentCaseThreeStrategies(CubeSupplement):
CONFIG = {
"try_different_strategies": True,
}
class CubeEdgeDescription(Scene):
CONFIG = {
"camera_config": {"background_color": GREY_E}
}
def construct(self):
bits = VGroup(*[
VGroup(*[
Integer(int(b))
for b in string_to_bools(char)
]).arrange(RIGHT, buff=SMALL_BUFF)
for char in "hi"
])
bits.arrange(DOWN, buff=LARGE_BUFF)
arrow = Arrow(
bits[0][7].get_bottom(),
bits[1][7].get_top(),
buff=SMALL_BUFF,
tip_config={"length": 0.15, "width": 0.15}
)
arrow.set_color(BLUE)
words = TextMobject("Bit flip")
words.set_color(BLUE)
words.next_to(arrow, LEFT)
bf_group = VGroup(bits, arrow, words)
parens = TexMobject("()")[0]
parens.scale(2)
parens.match_height(bf_group, stretch=True)
parens[0].next_to(bf_group, LEFT, SMALL_BUFF)
parens[1].next_to(bf_group, RIGHT, SMALL_BUFF)
bf_group.add(parens)
bf_group.to_edge(UP)
cube_words = TextMobject("Edge of an\\\\n-dimensional cube")
top_group = VGroup(
bf_group,
Vector(RIGHT),
cube_words
)
top_group.arrange(RIGHT)
top_group.to_edge(UP)
self.add(bf_group)
bits.unlock_triangulation()
self.play(
TransformFromCopy(*bits),
GrowArrow(arrow),
FadeIn(words, 0.25 * UP)
)
self.wait()
self.play(
GrowArrow(top_group[1]),
FadeIn(cube_words, LEFT)
)
self.wait()
class EdgeColoringExample(Scene):
def construct(self):
words = VGroup(
TextMobject(
"Color edges\\\\red or blue",
tex_to_color_map={"red": RED, "blue": BLUE}
),
TextMobject("Prove there is a\\\\monochromatic triangle", alignment=""),
)
words.arrange(DOWN, buff=LARGE_BUFF, aligned_edge=LEFT)
words.to_edge(RIGHT)
words.to_edge(UP, buff=LARGE_BUFF)
def get_graph(words=words):
points = compass_directions(6)
points *= 3
verts = VGroup(*[Dot(p, radius=0.1) for p in points])
verts.set_fill(GREY_B, 1)
edges = VGroup(*[
Line(p1, p2, color=random.choice([RED, BLUE]))
for p1, p2 in it.combinations(points, 2)
])
graph = VGroup(verts, edges)
graph.set_height(6)
graph.next_to(words, LEFT, LARGE_BUFF)
graph.set_y(0)
graph.set_stroke(background=True)
return graph
graph = get_graph()
self.add(words)
self.add(graph)
self.wait()
for x in range(2):
new_graph = get_graph()
self.play(
ShowCreation(
new_graph, lag_ratio=0.1,
run_time=3,
),
ApplyMethod(
graph[1].set_stroke, None, 0,
run_time=2,
)
)
graph = new_graph
self.wait(4)
class GrahamsConstantAlt(Scene):
def construct(self):
# lhs = TexMobject("g_{64}", "=")
# lhs[0][1:].scale(0.7, about_edge=DL)
lhs = TexMobject("")
lhs.scale(2)
rhs = VGroup()
for ndots in [1, 3, 6, 7, 9, 12]:
row = VGroup(*[
TexMobject("2"),
TexMobject("\\uparrow\\uparrow"),
VGroup(*[
TexMobject("\\cdot") for x in range(ndots)
]).arrange(RIGHT, buff=0.2),
TexMobject("\\uparrow\\uparrow"),
TexMobject("3"),
])
row.arrange(RIGHT, buff=MED_SMALL_BUFF)
if ndots == 1:
rc = row.get_center()
row[:2].move_to(rc, RIGHT)
row[2].set_opacity(0)
row[3:].move_to(rc, LEFT)
row.add(Brace(row[1:-1], DOWN, buff=SMALL_BUFF))
rhs.add(row)
rhs.replace_submobject(0, Integer(12))
# rhs[0][-1].set_opacity(0)
rhs.replace_submobject(3, TexMobject("\\vdots"))
rhs.arrange(UP)
rhs.next_to(lhs, RIGHT)
rbrace = Brace(rhs[1:], RIGHT)
rbrace_tex = rbrace.get_text("7 times")
equation = VGroup(lhs, rhs, rbrace, rbrace_tex)
equation.center().to_edge(LEFT, buff=LARGE_BUFF)
self.add(lhs, rhs[0])
self.play(TransformFromCopy(rhs[0], rhs[1]),)
self.play(TransformFromCopy(rhs[1], rhs[2]))
self.play(
Write(rhs[3]),
TransformFromCopy(rhs[2], rhs[4]),
)
self.play(
TransformFromCopy(rhs[4], rhs[5]),
GrowFromCenter(rbrace),
Write(rbrace_tex)
)
self.wait()
class ThinkAboutNewTrick(PiCreatureScene, ThreeDScene):
def construct(self):
randy = self.pi_creature
board = Chessboard(shape=(1, 3))
board.set_height(1.5)
coins = CoinsOnBoard(board)
coins.flip_at_random()
self.add(board, coins)
self.play(randy.change, "confused", board)
for x in range(4):
self.play(FlipCoin(random.choice(coins)))
if x == 1:
self.play(randy.change, "maybe")
else:
self.wait()
class AttemptAColoring(ThreeDScene):
def construct(self):
# Setup cube
short_vert_height = 0.3
tall_vert_height = 0.4
vert_coords = np.array(list(map(int_to_bit_coords, range(8))))
vert_coords = vert_coords - 0.5
vert_coords = vert_coords * 4
vert_coords[:, 2] *= 1.25 # Stretch in the z
cube = Group()
cube.verts = SGroup()
cube.edges = VGroup()
cube.add(cube.verts, cube.edges)
for n, coords in enumerate(vert_coords):
vert = Sphere(resolution=(21, 21))
vert.set_height(short_vert_height)
vert.rotate(90 * DEGREES, RIGHT)
vert.move_to(coords)
cube.verts.add(vert)
vert.edges = VGroup()
for m, coords2 in enumerate(vert_coords):
if sum(int_to_bit_coords(n ^ m)) == 1:
edge = Line(coords, coords2)
cube.edges.add(edge)
vert.edges.add(edge)
vert.edges.apply_depth_test()
cube.edges.set_color(GREY)
cube.edges.apply_depth_test()
cube.rotate(30 * DEGREES, DOWN)
cube.to_edge(RIGHT)
cube.set_height(4)
self.play(
ShowCreation(cube.edges, lag_ratio=0.1),
LaggedStartMap(FadeInFromLarge, cube.verts, lambda m: (m, 0.2)),
run_time=2,
)
# Setup cube color
def get_colored_vertices(values, verts=cube.verts):
color_choices = [RED, GREEN, BLUE_D]
color_label_choices = ["R", "G", "B"]
vert_targets = SGroup()
labels = VGroup()
for n, vert in zip(values, verts):
color = color_choices[n]
v_target = vert.copy()
if n == -1:
v_target.set_height(short_vert_height)
v_target.set_color(GREY)
label = VectorizedPoint()
else:
v_target.set_color(color)
v_target.set_height(tall_vert_height)
label = TexMobject(color_label_choices[n])
label.set_color(color)
label.set_stroke(BLACK, 3, background=True)
label.next_to(vert, UR, buff=0)
vert_targets.add(v_target)
labels.add(label)
return vert_targets, labels
new_verts, color_labels = get_colored_vertices(np.arange(0, 8) % 3)
for vert, label in zip(cube.verts, color_labels):
vert.label = label
self.play(
Transform(cube.verts, new_verts),
Write(color_labels),
run_time=2,
)
self.wait()
def get_color_change_animations(values, verts=cube.verts, labels=color_labels, gcv=get_colored_vertices):
new_verts, new_labels = gcv(values)
old_labels = labels.copy()
labels.become(new_labels)
return [
Transform(verts, new_verts),
LaggedStartMap(FadeOut, old_labels, lambda m: (m, 0.5 * UP), lag_ratio=0.03),
LaggedStartMap(FadeIn, labels, lambda m: (m, 0.5 * DOWN), lag_ratio=0.03),
]
# Prepare a few colorings
mod3_strategy = [
np.dot(int_to_bit_coords(n), [0, 1, 2]) % 3
for n in range(8)
]
sum_bits = [sum(int_to_bit_coords(n)) % 3 for n in range(8)]
self.play(*get_color_change_animations(sum_bits))
self.wait()
self.play(*get_color_change_animations(mod3_strategy))
self.wait()
# Pull out vertices with their neighbors
# first just one, then all of them.
trees = Group()
tree_targets = Group()
for n, vert in enumerate(cube.verts):
tree = Group()
tree.root = vert.copy()
tree.root.origin = tree.root.get_center()
tree.edges = VGroup()
tree.leafs = Group()
tree.labels = Group()
for mask in [1, 2, 4]:
leaf = cube.verts[n ^ mask]
leaf.origin = leaf.get_center()
label = leaf.label.copy()
label.original = leaf.label
tree.edges.add(Line(vert.get_center(), leaf.get_center()))
tree.leafs.add(leaf.copy())
tree.labels.add(label)
tree.edges.apply_depth_test()
tree.edges.match_style(vert.edges)
tree.edges.save_state()
tree.add(tree.root, tree.edges, tree.leafs, tree.labels)
trees.add(tree)
tree.generate_target(use_deepcopy=True)
for edge, leaf, label, y in zip(tree.target.edges, tree.target.leafs, tree.target.labels, [0.4, 0, -0.4]):
start = vert.get_center()
end = start + RIGHT + y * UP
edge.set_points_as_corners([start, end])
leaf.move_to(edge.get_end())
label.next_to(leaf, RIGHT, buff=SMALL_BUFF)
label.scale(0.7)
tree_targets.add(tree.target)
tree_targets.arrange_in_grid(4, 2, buff=LARGE_BUFF)
tree_targets[1::2].shift(0.5 * RIGHT)
tree_targets.set_height(6)
tree_targets.center()
tree_targets.to_corner(DL)
self.play(
MoveToTarget(trees[0]),
run_time=3,
)
self.wait()
self.play(
LaggedStartMap(
MoveToTarget, trees[1:],
lag_ratio=0.3,
),
run_time=6,
)
self.add(trees)
self.wait()
# Show what we want
want_rect = SurroundingRectangle(trees, buff=MED_SMALL_BUFF)
want_rect.set_stroke(WHITE, 1)
want_label = TextMobject("What we want")
want_label.next_to(want_rect, UP)
trees.save_state()
anims = []
for tree in trees:
anims.append(ApplyMethod(tree.root.set_color, GREY))
colors = [RED, GREEN, BLUE_D]
letters = ["R", "G", "B"]
for color, letter, leaf, label in zip(colors, letters, tree.leafs, tree.labels):
new_label = TextMobject(letter)
new_label.set_fill(color)
new_label.replace(label, dim_to_match=1)
old_label = label.copy()
label.become(new_label)
anims += [
FadeIn(label, 0.1 * LEFT),
FadeOut(old_label, 0.1 * RIGHT),
ApplyMethod(leaf.set_color, color),
]
cube.verts.generate_target()
cube.verts.save_state()
cube.verts.target.set_color(GREY)
for vert in cube.verts.target:
vert.scale(0.75)
self.play(
ShowCreation(want_rect),
Write(want_label),
LaggedStart(*anims, lag_ratio=0.001, run_time=3),
FadeOut(color_labels),
MoveToTarget(cube.verts),
)
self.add(trees)
self.wait()
# Try to fit these back onto the cube
# First attempt
def restore_tree(tree, **kwargs):
anims = []
for mob in [tree.root, *tree.leafs]:
anims.append(ApplyMethod(mob.move_to, mob.origin))
for label in tree.labels:
label.generate_target()
label.target.replace(label.original, dim_to_match=1)
anims.append(MoveToTarget(label))
anims.append(Restore(tree.edges))
return AnimationGroup(*anims, **kwargs)
tree_copies = trees.deepcopy()
self.play(restore_tree(tree_copies[0], run_time=2))
self.wait()
self.play(restore_tree(tree_copies[1], run_time=2))
self.wait()
frame = self.camera.frame
self.play(
UpdateFromAlphaFunc(
frame,
lambda m, a: m.move_to(0.1 * wiggle(a, 6) * RIGHT),
),
FadeOut(tree_copies[0]),
FadeOut(tree_copies[1]),
)
# Second attempt
def restore_vertex(n, verts=cube.verts, labels=color_labels):
return AnimationGroup(
Transform(verts[n], verts.saved_state[n]),
FadeIn(labels[n], DOWN)
)
for i in [0, 4, 2, 1]:
self.play(restore_vertex(i))
self.wait()
self.play(ShowCreationThenFadeAround(cube.verts[4]))
for i in [6, 5]:
self.play(restore_vertex(i))
self.wait()
q_marks = VGroup(*[TexMobject("???") for x in range(2)])
q_marks[0].next_to(cube.verts[7], UP, SMALL_BUFF)
q_marks[1].next_to(cube.verts[3], UP, SMALL_BUFF)
self.play(Write(q_marks))
self.wait()
# Mention it'll never work
nv_label = TextMobject("It'll never work!")
nv_label.set_height(0.5)
nv_label.next_to(cube, UP, buff=0.75)
cube_copy = cube.deepcopy()
self.remove(cube)
self.add(cube_copy)
new_verts, new_labels = get_colored_vertices([-1] * 8)
self.play(
Transform(cube_copy.verts, new_verts),
FadeOut(q_marks),
FadeOut(color_labels[:3]),
FadeOut(color_labels[4:7]),
)
self.add(cube_copy)
self.play(FadeIn(nv_label, DOWN))
for vert in cube_copy.verts:
vert.generate_target()
vert.target.scale(0.01)
vert.target.set_opacity(0)
self.play(
LaggedStartMap(Uncreate, cube_copy.edges),
LaggedStartMap(MoveToTarget, cube_copy.verts),
)
# Highlight symmetry
rects = VGroup()
for tree in trees:
t_rect = SurroundingRectangle(
Group(tree.leafs, tree.labels),
buff=SMALL_BUFF
)
t_rect.set_stroke(YELLOW, 2)
rects.add(t_rect)
self.play(LaggedStartMap(ShowCreationThenFadeOut, rects, lag_ratio=0.025, run_time=3))
self.wait()
# Show implication
implies = TexMobject("\\Rightarrow")
implies.set_height(0.7)
implies.next_to(want_rect, RIGHT)
number_labels = VGroup(*[
TextMobject("Number of ", f"{color} vertices")
for color in ["red", "green", "blue"]
])
for color, label in zip(colors, number_labels):
label[1].set_color(color)
number_labels.set_height(0.5)
number_labels.arrange(DOWN, buff=1.5, aligned_edge=LEFT)
number_labels.next_to(implies, RIGHT, MED_LARGE_BUFF)
vert_eqs = VGroup(*[TexMobject("=") for x in range(2)])
vert_eqs.scale(1.5)
vert_eqs.rotate(90 * DEGREES)
vert_eqs[0].move_to(number_labels[0:2])
vert_eqs[1].move_to(number_labels[1:3])
rhss = VGroup()
for label in number_labels:
rhs = TexMobject("= \\frac{8}{3}")
rhs.scale(1.25)
rhs.next_to(label, RIGHT)
rhss.add(rhs)
self.play(
Write(implies),
FadeOut(nv_label),
)
self.play(
GrowFromCenter(vert_eqs),
FadeIn(number_labels[0], DOWN),
FadeIn(number_labels[1]),
FadeIn(number_labels[2], UP),
)
self.wait()
self.play(Write(rhss))
self.wait(2)
self.play(
LaggedStartMap(
FadeOut, VGroup(*number_labels, *vert_eqs, *rhss, *implies),
),
ShowCreation(cube.edges, lag_ratio=0.1),
LaggedStartMap(FadeInFromLarge, cube.verts, lambda m: (m, 0.2)),
)
self.add(cube)
new_verts, color_labels = get_colored_vertices(mod3_strategy)
true_trees = trees.saved_state
self.play(
Transform(cube.verts, new_verts),
FadeIn(color_labels),
FadeOut(trees),
FadeOut(want_label)
)
self.play(FadeIn(true_trees))
self.wait()
# Count colors
for edge in cube.edges:
edge.insert_n_curves(10)
red_total = Integer(height=0.6)
red_total.next_to(want_rect, UP)
red_total.set_color(RED)
self.play(FadeIn(red_total))
all_label_rects = VGroup()
for n in range(8):
tree = true_trees[n]
vert = cube.verts[n]
neighbor_highlights = VGroup()
new_edges = VGroup()
label_rects = VGroup()
for mask, label in zip([1, 2, 4], tree.labels):
neighbor = cube.verts[n ^ mask]
edge = Line(vert, neighbor, buff=0)
edge.set_stroke(YELLOW, 5)
edge.insert_n_curves(10)
new_edges.add(edge)
if neighbor.get_color() == Color(RED):
circ = Circle()
circ.set_stroke(YELLOW, 3)
circ.replace(neighbor)
neighbor_highlights.add(circ)
rect = SurroundingRectangle(label, buff=0.025)
rect.set_stroke(YELLOW, 2)
label_rects.add(rect)
new_edges.apply_depth_test()
new_edges.shift(0.01 * OUT)
new_tree_edges = tree.edges.copy()
new_tree_edges.set_stroke(YELLOW, 3)
new_tree_edges.shift(0.01 * OUT)
self.play(
*map(ShowCreation, [*new_edges, *new_tree_edges]),
)
for highlight, rect in zip(neighbor_highlights, label_rects):
self.play(
FadeInFromLarge(highlight, 1.2),
FadeInFromLarge(rect, 1.2),
run_time=0.25
)
red_total.increment_value()
self.wait(0.25)
self.play(
FadeOut(neighbor_highlights),
FadeOut(new_edges),
FadeOut(new_tree_edges),
)
all_label_rects.add(*label_rects)
self.wait()
# Show count to 8
new_verts = get_colored_vertices([-1] * 8)[0]
self.play(
FadeOut(true_trees),
FadeOut(all_label_rects),
FadeOut(red_total),
FadeOut(color_labels),
Transform(cube.verts, new_verts),
)
self.play(FadeIn(trees))
label_rects = VGroup()
for tree in trees:
rect = SurroundingRectangle(tree.labels[0], buff=0.025)
rect.match_style(all_label_rects[0])
label_rects.add(rect)
self.play(
ShowIncreasingSubsets(label_rects, rate_func=linear),
UpdateFromFunc(
red_total, lambda m, lr=label_rects: m.set_value(len(lr))
)
)
self.wait()
# Show red corners
r_verts = SGroup(cube.verts[3], cube.verts[4]).copy()
r_labels = VGroup()
r_edge_groups = VGroup()
for r_vert in r_verts:
r_label = TexMobject("R")
r_label.set_color(RED)
r_label.next_to(r_vert, UR, buff=0)
r_labels.add(r_label)
r_vert.set_height(tall_vert_height)
r_vert.set_color(RED)
edges = VGroup()
for edge in r_vert.edges:
to_r_edge = edge.copy()
to_r_edge.reverse_points()
to_r_edge.set_stroke(YELLOW, 3)
to_r_edge.shift(0.01 * OUT)
edges.add(to_r_edge)
edges.apply_depth_test()
r_edge_groups.add(edges)
self.play(
LaggedStartMap(FadeInFromLarge, r_verts),
LaggedStartMap(FadeInFromLarge, r_labels),
run_time=1,
)
self.wait()
for edges in r_edge_groups:
self.play(ShowCreationThenDestruction(edges, lag_ratio=0.1))
self.wait()
rhs = TexMobject("=", "3", "\\, (\\text{\\# Red corners})")
rhs[2].set_color(RED)
rhs.match_height(red_total)
rhs[:2].match_height(red_total, about_edge=RIGHT)
rhs.next_to(red_total, RIGHT)
self.play(Write(rhs))
self.wait()
three = rhs[1]
three.generate_target()
three.target.move_to(red_total, RIGHT)
over = TexMobject("/")
over.match_height(three)
over.next_to(three.target, LEFT, MED_SMALL_BUFF)
self.play(
MoveToTarget(three, path_arc=90 * DEGREES),
red_total.next_to, over, LEFT, MED_SMALL_BUFF,
FadeIn(over, UR),
rhs[2].move_to, three, LEFT,
)
self.wait()
np_label = TextMobject("Not possible!")
np_label.set_height(0.6)
np_label.next_to(rhs, RIGHT, LARGE_BUFF)
self.play(Write(np_label))
self.wait()
class TryTheProofYourself(TeacherStudentsScene):
def construct(self):
self.teacher_says(
"Can you predict\\\\the proof?",
target_mode="hooray",
bubble_kwargs={
"height": 3,
"width": 3,
},
)
self.teacher.bubble.set_fill(opacity=0)
self.change_student_modes(
"pondering", "thinking", "confused",
look_at_arg=self.screen,
)
self.wait(3)
self.change_student_modes("thinking", "pondering", "erm", look_at_arg=self.screen)
self.wait(4)
self.change_student_modes("tease", "pondering", "thinking", look_at_arg=self.screen)
self.wait(5)
class HighDimensionalCount(ThreeDScene):
def construct(self):
# Definitions
N = 6
colors = [RED, GREEN, BLUE_D, YELLOW, PINK, TEAL]
coords = np.array([0, 1, 1, 1, 0, 0])
# Add chess board
board = Chessboard(shape=(2, 3))
board.set_height(2)
board.to_corner(UL)
grid = NumberPlane(
x_range=(0, 3), y_range=(0, 2),
faded_line_ratio=0
)
grid.match_height(board)
grid.match_width(board, stretch=True)
grid.next_to(board, OUT, 1e-8)
grid.set_gloss(0.5)
coins = CoinsOnBoard(board, coin_config={"numeric_labels": True})
coins.flip_by_bools(coords)
coin_labels = VGroup()
for i, coin in zip(coords, coins):
coin_labels.add(coin.labels[1 - i])
self.play(
ShowCreationThenFadeOut(grid, lag_ratio=0.1),
FadeIn(board),
FadeIn(coins, lag_ratio=0.1),
run_time=2
)
# Setup corners
def get_vert(height=0.4, color=RED):
return get_vertex_sphere(height, color)
def get_vert_label(coords):
args = ["("]
for coord in coords:
args.append(str(coord))
args.append(",")
args[-1] = ")"
return TexMobject(*args)
def get_board_with_highlights(n, height=1, N=N, colors=colors):
board = VGroup(*[Square() for x in range(N)])
board.arrange_in_grid(2, 3, buff=0)
board.set_fill(GREY_E, 1)
board.set_stroke(WHITE, 1)
board.set_height(height)
board[n].set_fill(colors[n])
return board
vert = get_vert()
vert_label = get_vert_label(coords)
vert_board = get_board_with_highlights(0)
vert_label.next_to(vert, LEFT)
vert_board.next_to(vert_label, DOWN, MED_LARGE_BUFF)
neighbors = SGroup()
for color in colors:
neighbors.add(get_vert(color=color))
neighbors.arrange(DOWN, buff=0.75)
neighbors.next_to(vert, RIGHT, buff=2)
neighbor_labels = VGroup()
edges = VGroup()
neighbor_boards = VGroup()
for n, neighbor in enumerate(neighbors):
edge = Line(
vert.get_center(),
neighbor.get_center(),
buff=vert.get_height() / 2,
)
new_coords = list(coords)
new_coords[n] ^= 1
label = get_vert_label(new_coords)
label.next_to(neighbor, RIGHT)
label.add(SurroundingRectangle(label[2 * n + 1], buff=0.05))
n_board = get_board_with_highlights(n, height=0.7)
n_board.next_to(label, RIGHT)
neighbor_boards.add(n_board)
edges.add(edge)
neighbor_labels.add(label)
vertex_group = Group(
vert_board, vert_label, vert,
edges,
neighbors, neighbor_labels, neighbor_boards
)
vertex_group.to_corner(DL)
# Show coords with states
cl_mover = coin_labels.copy()
cl_mover.generate_target()
for m1, m2 in zip(cl_mover.target, vert_label[1::2]):
m1.replace(m2)
self.play(
MoveToTarget(cl_mover),
)
self.play(
FadeIn(vert_label),
FadeOut(cl_mover)
)
self.play(FadeIn(vert_board))
self.wait()
self.play(
ShowIncreasingSubsets(neighbor_labels),
ShowCreation(edges),
)
self.wait()
self.play(LaggedStartMap(
TransformFromCopy, neighbor_boards,
lambda m, b=vert_board: (b, m)
))
self.wait()
# Show one vertex
self.play(FadeInFromLarge(vert))
self.play(LaggedStartMap(
TransformFromCopy, neighbors,
lambda m, v=vert: (v, m)
))
self.wait()
# Isolate vertex
edges.apply_depth_test()
tree = Group(vert, edges, neighbors)
tree.generate_target()
tree.target[0].scale(0.5)
tree.target[2].scale(0.5)
tree.target[2].arrange(DOWN, buff=0)
tree.target[2].next_to(vert, RIGHT, MED_LARGE_BUFF)
for edge, nv in zip(tree.target[1], tree.target[2]):
new_edge = Line(
vert.get_center(),
nv.get_center(),
)
edge.become(new_edge)
edge.set_stroke(WHITE, 2)
tree.target.rotate(-90 * DEGREES)
tree.target.center()
short_label = vert_label[1::2]
short_label.generate_target()
short_label.target.arrange(RIGHT, buff=SMALL_BUFF)
short_label.target.match_width(tree.target)
short_label.target.next_to(tree.target, UP)
short_label.target.set_fill(GREY_A)
self.play(
MoveToTarget(tree),
MoveToTarget(short_label),
LaggedStartMap(FadeOut, Group(
vert_label[0::2],
vert_board,
*neighbor_labels,
*neighbor_boards,
*board,
*coins,
)),
run_time=2,
)
tree.add(short_label)
# Show all vertices
def get_bit_string(n, template=short_label):
bits = VGroup(*map(Integer, int_to_bit_coords(n, min_dim=6)))
bits.arrange(RIGHT, buff=0.075)
bits.match_height(template)
bits.set_color(GREY_A)
return bits
new_trees = Group()
for n in [0, 1, 62, 63]:
new_tree = tree.copy()
bits = get_bit_string(n)
bits.move_to(new_tree[3])
new_tree.replace_submobject(3, bits)
new_trees.add(new_tree)
for new_tree, color in zip(new_trees, [YELLOW, GREEN, RED, BLUE_D]):
new_tree[0].set_color(color)
new_trees.arrange(RIGHT, buff=MED_LARGE_BUFF)
new_trees.move_to(tree)
new_trees[:2].to_edge(LEFT)
new_trees[2:].to_edge(RIGHT)
dots = VGroup(*[TexMobject("\\dots") for x in range(2)])
dots.scale(2)
dots[0].move_to(Group(new_trees[1], tree))
dots[1].move_to(Group(new_trees[2], tree))
top_brace = Brace(new_trees, UP, buff=MED_LARGE_BUFF)
total_label = top_brace.get_text("$2^n$ total vertices", buff=MED_LARGE_BUFF)
low_brace = Brace(tree, DOWN)
neighbors_label = low_brace.get_text("n neighbors")
self.play(
GrowFromCenter(low_brace),
Write(neighbors_label, run_time=1)
)
self.wait()
self.play(
GrowFromCenter(dots),
GrowFromCenter(top_brace),
LaggedStartMap(
TransformFromCopy, new_trees,
lambda m, t=tree: (t, m)
),
Write(total_label, run_time=1),
run_time=2,
)
self.wait()
# Count red neighbors
middle_tree = tree
frame = self.camera.frame
self.play(frame.move_to, UP)
count = Integer(1)
count.set_color(RED)
count.scale(1.5)
count.next_to(total_label, UP, LARGE_BUFF, aligned_edge=LEFT)
two_to_n_label = TexMobject("2^n")
two_to_n_label.scale(1.5)
two_to_n_label.set_color(RED)
two_to_n_label.move_to(count, LEFT)
n_arrows = VGroup()
for tree in [*new_trees[:2], middle_tree, *new_trees[2:]]:
arrow = Vector(
[-1, -2, 0],
tip_config={"width": 0.2, "length": 0.2}
)
arrow.match_height(tree[1])
arrow.next_to(tree[2][0], UR, buff=0)
arrow.set_color(RED)
n_arrows.add(arrow)
self.add(n_arrows[0], count)
self.wait()
self.add(n_arrows[1])
count.increment_value()
self.wait()
self.play(
ChangeDecimalToValue(count, 63, rate_func=rush_into),
LaggedStartMap(FadeIn, n_arrows[2:], lag_ratio=0.5),
run_time=3
)
self.remove(count)
self.add(two_to_n_label)
self.wait()
rhs = TexMobject("=", "n", "\\cdot", "(\\text{\\# Red vertices})")
rhs.scale(1.5)
rhs.next_to(two_to_n_label, RIGHT)
rhs.shift(0.05 * DOWN)
rhs.set_color_by_tex("Red", RED)
highlighted_edges = VGroup(*middle_tree[1], new_trees[2][1]).copy()
highlighted_edges.set_stroke(YELLOW, 3)
highlighted_edges.shift(0.01 * OUT)
edge_anim = ShowCreationThenFadeOut(
highlighted_edges, lag_ratio=0.3
)
self.play(edge_anim)
self.play(Write(rhs), run_time=1)
self.play(edge_anim)
self.wait(2)
# Conclusion
pairs = VGroup(VGroup(TexMobject("n"), TexMobject("2^n")))
pairs.set_color(YELLOW)
for n in range(1, 10):
pairs.add(VGroup(Integer(n), Integer(2**n)))
for pair in pairs:
pair.arrange(RIGHT, buff=0.75, aligned_edge=DOWN)
line = Line(LEFT, RIGHT)
line.set_stroke(WHITE, 1)
line.set_width(2)
line.next_to(pair, DOWN, aligned_edge=LEFT)
line.shift(SMALL_BUFF * LEFT)
pair.add(line)
pairs.add(pair)
pairs.arrange(DOWN, aligned_edge=LEFT, buff=0.25)
pairs.set_height(7)
pairs.to_edge(LEFT)
pairs.shift(UP)
marks = VGroup()
for n, pair in zip(it.count(1), pairs[1:]):
if sum(int_to_bit_coords(n)) == 1:
mark = Checkmark()
else:
mark = Exmark()
mark.move_to(pair[1], LEFT)
mark.shift(RIGHT)
marks.add(mark)
v_line = Line(UP, DOWN)
v_line.set_height(7)
v_line.set_stroke(WHITE, 1)
v_line.set_x((pairs[0][0].get_right() + pairs[0][1].get_left())[0] / 2)
v_line.match_y(pairs)
pairs.add(v_line)
new_trees.generate_target()
new_trees.target[:2].move_to(middle_tree, RIGHT)
shift_vect = new_trees.target[0].get_center() - new_trees[0].get_center()
self.play(
MoveToTarget(new_trees),
top_brace.match_width, new_trees.target, {"about_edge": RIGHT},
total_label.shift, shift_vect * 0.5,
n_arrows[:2].shift, shift_vect,
FadeOut(middle_tree, RIGHT),
FadeOut(n_arrows[2], RIGHT),
FadeOut(dots[0], 2 * RIGHT),
Write(pairs)
)
self.play(LaggedStartMap(
FadeIn, marks,
lambda m: (m, 0.2 * LEFT),
lag_ratio=0.4,
run_time=5,
))
self.wait()
class SimpleRect(Scene):
def construct(self):
rect = SurroundingRectangle(
VGroup(Integer(4), Integer(16), Integer(0)).arrange(RIGHT, MED_LARGE_BUFF),
)
self.play(ShowCreation(rect))
self.wait(2)
self.play(FadeOut(rect))
class WhenIsItHopeless(Scene):
def construct(self):
boards = Group(
Chessboard(shape=(1, 3)),
Chessboard(shape=(2, 2)),
Chessboard(shape=(2, 3)),
Chessboard(shape=(2, 3)),
Chessboard(shape=(2, 4)),
Chessboard(shape=(2, 4)),
Chessboard(shape=(3, 3)),
Chessboard(shape=(3, 4)),
Chessboard(shape=(3, 4)),
Chessboard(shape=(3, 4)),
)
last_board = None
last_coins = None
last_words = None
for n, board in zip(it.count(3), boards):
board.scale(1 / board[0].get_height())
coins = CoinsOnBoard(board)
coins.flip_at_random()
diff = len(board) - n
if diff > 0:
board[-diff:].set_opacity(0)
coins[-diff:].set_opacity(0)
if sum(int_to_bit_coords(n)) == 1:
words = TextMobject("Maybe possible")
words.set_color(GREEN)
else:
words = TextMobject("Futile!")
words.set_color(RED)
words.scale(1.5)
words.next_to(board, UP, MED_LARGE_BUFF)
if n == 3:
self.play(
FadeIn(board),
FadeIn(coins),
FadeIn(words, DOWN),
)
else:
self.play(
ReplacementTransform(last_board, board),
ReplacementTransform(last_coins, coins),
FadeOut(last_words),
FadeIn(words, DOWN),
)
self.wait()
last_board = board
last_coins = coins
last_words = words
class FourDCubeColoringFromTrees(ThreeDScene):
def construct(self):
# Camera stuffs
frame = self.camera.frame
light = self.camera.light_source
light.move_to([-25, -20, 20])
# Setup cube
colors = [RED, GREEN, BLUE_D, YELLOW]
cube = self.get_hypercube()
for n, vert in enumerate(cube.verts):
code = boolian_linear_combo(int_to_bit_coords(n, 4))
cube.verts[n].set_color(colors[code])
# Create trees
trees = Group()
original_trees = Group()
for vert in cube.verts:
tree = Group(
vert,
vert.edges,
vert.neighbors,
).copy()
original = tree.copy()
original[0].set_color(GREY)
original[0].scale(0)
original_trees.add(original)
trees.add(tree)
for tree in trees:
tree[0].set_color(GREY)
tree[0].rotate(90 * DEGREES, LEFT)
sorted_verts = Group(*tree[2])
sorted_verts.submobjects.sort(key=lambda m: m.get_color().hex)
sorted_verts.arrange(DOWN, buff=SMALL_BUFF)
sorted_verts.next_to(tree[0], RIGHT, buff=0.75)
for edge, neighbor in zip(tree[1], tree[2]):
edge.become(Line3D(
tree[0].get_center(),
neighbor.get_center(),
resolution=edge.resolution,
))
neighbor.rotate(90 * DEGREES, LEFT)
trees.arrange_in_grid(4, 4, buff=MED_LARGE_BUFF)
for i in range(4):
trees[i::4].shift(0.5 * i * RIGHT)
trees.center()
trees.set_height(6)
trees.rotate(PI / 2, RIGHT)
trees.move_to(10 * LEFT, LEFT)
frame.set_phi(90 * DEGREES)
frame.move_to(5 * LEFT)
self.add(trees)
self.wait()
# Show transition
anims = []
for tree, original in zip(trees, original_trees):
anims.append(Transform(tree, original))
self.play(
frame.set_rotation, 20 * DEGREES, 70 * DEGREES,
frame.move_to, ORIGIN,
LaggedStart(*anims, lag_ratio=0.2),
run_time=8,
)
self.remove(trees)
self.add(cube)
frame.add_updater(lambda m, dt: m.increment_theta(2 * dt * DEGREES))
self.wait(30)
def get_hypercube(self, dim=4, width=4):
hc_points = self.get_hypercube_points(dim, width)
cube = Group()
cube.verts = SGroup()
cube.edges = SGroup()
cube.add(cube.verts, cube.edges)
for point in hc_points:
vert = get_vertex_sphere(resolution=(25, 13))
vert.rotate(PI / 2, UP)
vert.move_to(point)
cube.verts.add(vert)
vert.edges = SGroup()
vert.neighbors = SGroup()
for n in range(2**dim):
for power in range(dim):
k = n ^ (1 << power)
edge = Line3D(
hc_points[n],
hc_points[k],
width=0.05,
resolution=(31, 31)
)
cube.edges.add(edge)
cube.verts[n].edges.add(edge)
cube.verts[n].neighbors.add(cube.verts[k])
return cube
def get_hypercube_points(self, dim=4, width=4):
all_coords = [
int_to_bit_coords(n, dim).astype(float)
for n in range(2**dim)
]
vertex_holder = Mobject()
vertex_holder.set_points([
sum([c * v for c, v in zip(reversed(coords), [RIGHT, UP, OUT])])
for coords in all_coords
])
vertex_holder.center()
if dim == 4:
vertex_holder.points[8:] *= 2
vertex_holder.set_width(width)
return vertex_holder.points
class IntroduceHypercube(FourDCubeColoringFromTrees):
def construct(self):
# Camera stuffs
frame = self.camera.frame
light = self.camera.light_source
light.move_to([-25, -20, 20])
# Setup cubes
cubes = [
self.get_hypercube(dim=d)
for d in range(5)
]
def reconnect_edges(cube):
for vert in cube.verts:
for edge, neighbor in zip(vert.edges, vert.neighbors):
edge.become(Line3D(
vert.get_center(),
neighbor.get_center(),
resolution=edge.resolution
))
# Show increasing dimensions
label = VGroup(Integer(0), TexMobject("D"))
label.arrange(RIGHT, buff=SMALL_BUFF)
label.scale(1.5)
label.to_edge(UP)
label.fix_in_frame()
def get_cube_intro_anim(n, cubes=cubes, reconnect_edges=reconnect_edges, label=label):
if n == 0:
return GrowFromCenter(cubes[n])
self.remove(cubes[n - 1])
cubes[n].save_state()
for v1, v2 in zip(cubes[n].verts, it.cycle(cubes[n - 1].verts)):
v1.move_to(v2)
reconnect_edges(cubes[n])
if n == 1:
cubes[n].edges.scale(0)
return AnimationGroup(
Restore(cubes[n]),
ChangeDecimalToValue(label[0], n),
)
self.play(
FadeIn(label, DOWN),
get_cube_intro_anim(0)
)
self.wait()
for n in [1, 2]:
self.play(get_cube_intro_anim(n))
self.wait()
self.play(
get_cube_intro_anim(3),
ApplyMethod(
frame.set_rotation, -20 * DEGREES, 75 * DEGREES,
run_time=3
)
)
frame.add_updater(lambda m, dt: m.increment_theta(dt * DEGREES))
self.wait(4)
# Flatten cube
flat_cube = self.get_hypercube(3)
for n, vert in enumerate(flat_cube.verts):
point = vert.get_center()
if n < 4:
point *= 1.5
else:
point *= 0.75
point[2] = 0
vert.move_to(point)
reconnect_edges(flat_cube)
plane = NumberPlane(x_range=(-10, 10), y_range=(-10, 10), faded_line_ratio=0)
plane.set_opacity(0.25)
plane.apply_depth_test()
plane.axes.shift(0.01 * OUT)
plane.shift(0.02 * IN)
cubes[3].save_state()
self.add(cubes[3], plane)
self.play(
FadeIn(plane, run_time=2),
Transform(cubes[3], flat_cube, run_time=2),
)
self.wait(7)
self.play(
Restore(cubes[3], run_time=2),
FadeOut(plane)
)
self.play(get_cube_intro_anim(4), run_time=3)
self.wait(10)
# Highlight some neighbor groups
colors = [RED, GREEN, BLUE_D, YELLOW]
for x in range(6):
vert = random.choice(cubes[4].verts)
neighbors = vert.neighbors.copy()
neighbors.save_state()
neighbors.generate_target()
new_edges = VGroup()
for neighbor, color in zip(neighbors.target, colors):
neighbor.set_color(color)
edge = Line(
vert.get_center(),
neighbor.get_center(),
buff=vert.get_height() / 2,
)
edge.set_stroke(color, 5)
new_edges.add(edge)
self.remove(vert.neighbors)
self.play(
ShowCreation(new_edges, lag_ratio=0.2),
MoveToTarget(neighbors),
)
self.wait(1)
self.play(
FadeOut(new_edges),
Restore(neighbors),
)
self.remove(neighbors)
self.add(vert.neighbors)
# Show valid coloring
cubes[4].generate_target()
for n, vert in enumerate(cubes[4].target[0]):
code = boolian_linear_combo(int_to_bit_coords(n, 4))
vert.set_color(colors[code])
self.play(MoveToTarget(cubes[4], lag_ratio=0.2, run_time=3))
self.wait(15)
# Animations for Matt
class WantAdditionToBeSubtraction(ThreeDScene):
def construct(self):
# Add sum
coins = CoinsOnBoard(
Chessboard(shape=(1, 4)),
coin_config={"numeric_labels": True},
)
for coin in coins[0], coins[2]:
coin.flip()
coefs = VGroup(*[TexMobject(f"X_{i}") for i in range(len(coins))])
full_sum = Group()
to_fade = VGroup()
for coin, coef in zip(coins, coefs):
coin.set_height(0.7)
coef.set_height(0.5)
summand = Group(coin, TexMobject("\\cdot"), coef, TexMobject("+"))
to_fade.add(*summand[1::2])
summand.arrange(RIGHT, buff=0.2)
full_sum.add(summand)
full_sum.add(TexMobject("\\dots"))
full_sum.arrange(RIGHT, buff=0.2)
to_fade.add(full_sum[-1])
some_label = TextMobject("Some kind of ``numbers''")
some_label.next_to(full_sum, DOWN, buff=2)
arrows = VGroup(*[
Arrow(some_label.get_top(), coef.get_bottom())
for coef in coefs
])
for coin in coins:
coin.save_state()
coin.rotate(90 * DEGREES, UP)
coin.set_opacity(0)
self.play(
LaggedStartMap(Restore, coins, lag_ratio=0.3),
run_time=1
)
self.play(
FadeIn(to_fade),
LaggedStartMap(FadeInFromPoint, coefs, lambda m: (m, some_label.get_top())),
LaggedStartMap(GrowArrow, arrows),
Write(some_label, run_time=1)
)
self.wait()
self.play(FadeOut(some_label), FadeOut(arrows))
# Show a flip
add_label = TexMobject("+X_2", color=GREEN)
sub_label = TexMobject("-X_2", color=RED)
for label in add_label, sub_label:
label.next_to(coins[2], UR)
label.match_height(coefs[2])
self.play(
FlipCoin(coins[2]),
FadeIn(label, 0.5 * DOWN)
)
self.play(FadeOut(label))
# What we want
want_label = TextMobject("Want: ", "$X_i = -X_i$")
eq = TextMobject("$X_i + X_i = 0$")
want_label.next_to(full_sum, DOWN, LARGE_BUFF)
eq.next_to(want_label[1], DOWN, aligned_edge=LEFT)
self.play(FadeIn(want_label))
self.wait()
self.play(FadeIn(eq, UP))
self.wait()
class BitVectorSum(ThreeDScene):
def construct(self):
# Setup
board = Chessboard(shape=(1, 4))
board.set_height(1)
coins = CoinsOnBoard(board, coin_config={"numeric_labels": True})
coins[2].flip()
all_coords = [np.array([b0, b1]) for b0, b1 in it.product(range(2), range(2))]
bit_vectors = VGroup(*[
IntegerMatrix(coords.reshape((2, 1))).set_height(1)
for coords in all_coords
])
bit_vectors.arrange(RIGHT, buff=2)
bit_vectors.to_edge(UP)
bit_vectors.set_stroke(BLACK, 4, background=True)
arrows = VGroup(
Arrow(board[0].get_corner(UL), bit_vectors[0].get_corner(DR)),
Arrow(board[1].get_corner(UP), bit_vectors[1].get_corner(DOWN)),
Arrow(board[2].get_corner(UP), bit_vectors[2].get_corner(DOWN)),
Arrow(board[3].get_corner(UR), bit_vectors[3].get_corner(DL)),
)
# Show vectors
self.add(board)
self.add(coins)
for arrow, vector in zip(arrows, bit_vectors):
self.play(
GrowArrow(arrow),
FadeInFromPoint(vector, arrow.get_start()),
)
self.wait()
# Move coins
coin_copies = coins.copy()
cdots = VGroup()
plusses = VGroup()
for cc, vector in zip(coin_copies, bit_vectors):
dot = TexMobject("\\cdot")
dot.next_to(vector, LEFT, MED_SMALL_BUFF)
cdots.add(dot)
plus = TexMobject("+")
plus.next_to(vector, RIGHT, MED_SMALL_BUFF)
plusses.add(plus)
cc.next_to(dot, LEFT, MED_SMALL_BUFF)
plusses[-1].set_opacity(0)
for coin, cc, dot, plus in zip(coins, coin_copies, cdots, plusses):
self.play(
TransformFromCopy(coin, cc),
Write(dot),
)
self.play(Write(plus))
self.wait()
# Show sum
eq = TexMobject("=")
eq.move_to(plusses[-1])
def get_rhs(coins=coins, bit_vectors=bit_vectors, all_coords=all_coords, eq=eq):
bit_coords = sum([
(b * coords)
for coords, b in zip(all_coords, coins.get_bools())
]) % 2
n = bit_coords_to_int(bit_coords)
result = bit_vectors[n].copy()
result.next_to(eq, RIGHT)
result.n = n
return result
def get_rhs_anim(rhs, bit_vectors=bit_vectors):
bv_copies = bit_vectors.copy()
bv_copies.generate_target()
for bv in bv_copies.target:
bv.move_to(rhs)
bv.set_opacity(0)
bv_copies.target[rhs.n].set_opacity(1)
return AnimationGroup(
MoveToTarget(bv_copies, remover=True),
ShowIncreasingSubsets(Group(rhs), int_func=np.floor)
)
rhs = get_rhs()
mod2_label = TextMobject("(Add mod 2)")
mod2_label.next_to(rhs, DOWN, MED_LARGE_BUFF)
mod2_label.to_edge(RIGHT)
self.play(
Write(eq),
get_rhs_anim(rhs),
FadeIn(mod2_label),
FadeOut(board),
FadeOut(coins),
FadeOut(arrows),
)
self.wait(2)
# Show some flips
for x in range(8):
i = random.randint(0, 3)
rect = SurroundingRectangle(Group(coin_copies[i], bit_vectors[i]))
old_rhs = rhs
coins[i].flip()
rhs = get_rhs()
self.play(
ShowCreation(rect),
FlipCoin(coin_copies[i]),
FadeOut(old_rhs, RIGHT),
FadeIn(rhs, LEFT),
)
self.play(FadeOut(rect))
self.wait(2)
class ExampleSquareAsBinaryNumber(Scene):
def construct(self):
# Setup
board = Chessboard()
nums = VGroup()
bin_nums = VGroup()
for n, square in enumerate(board):
bin_num = VGroup(*[
Integer(int(b))
for b in int_to_bit_coords(n, min_dim=6)
])
bin_num.arrange(RIGHT, buff=SMALL_BUFF)
bin_num.set_width((square.get_width() * 0.8))
num = Integer(n)
num.set_height(square.get_height() * 0.4)
for mob in num, bin_num:
mob.move_to(square, OUT)
mob.set_stroke(BLACK, 4, background=True)
num.generate_target()
num.target.replace(bin_num, stretch=True)
num.target.set_opacity(0)
bin_num.save_state()
bin_num.replace(num, stretch=True)
bin_num.set_opacity(0)
nums.add(num)
bin_nums.add(bin_num)
# Transform to binary
self.add(board, nums)
self.wait()
original_nums = nums.copy()
self.play(LaggedStart(*[
AnimationGroup(MoveToTarget(num), Restore(bin_num))
for num, bin_num in zip(nums, bin_nums)
]), lag_ratio=0.1)
self.remove(nums)
nums = original_nums
self.wait(2)
self.play(
bin_nums.set_stroke, None, 0,
bin_nums.set_opacity, 0.1,
)
self.wait()
# Count
n = 43
self.play(
board[n].set_color, MAROON_E,
Animation(bin_nums[n]),
)
last = VMobject()
shown_nums = VGroup()
for k in [0, 8, 16, 24, 32, 40, 41, 42, 43]:
nums[k].set_fill(YELLOW)
self.add(nums[k])
self.play(last.set_fill, WHITE, run_time=0.5)
last = nums[k]
shown_nums.add(last)
if k == 40:
self.wait()
self.wait()
self.play(LaggedStartMap(FadeOut, shown_nums[:-1]))
self.wait()
self.play(
FadeOut(last),
bin_nums[n].set_opacity, 1,
bin_nums[n].set_fill, YELLOW
)
self.wait()
class SkipSkipYesYes(Scene):
def construct(self):
board = Chessboard()
board.next_to(ORIGIN, DOWN)
words = VGroup(
TextMobject("Skip"),
TextMobject("Skip"),
TextMobject("Yes"),
TextMobject("Yes"),
)
words.add(*words.copy())
words.set_width(board[0].get_width() * 0.8)
for word, square in zip(words, board):
word.move_to(square)
word.set_y(0, UP)
for group in words[:4], words[4:]:
self.play(ShowIncreasingSubsets(group, rate_func=double_smooth, run_time=2))
self.play(FadeOut(group))
self.wait()
class ShowCurrAndTarget(Scene):
CONFIG = {
"bit_strings": [
"011010",
"110001",
"101011",
]
}
def construct(self):
words = VGroup(
TextMobject("Current: "),
TextMobject("Need to\\\\change:"),
TextMobject("Target: "),
)
words.arrange(DOWN, buff=0.75, aligned_edge=RIGHT)
words.to_corner(UL)
def get_bit_aligned_bit_string(bit_coords):
result = VGroup(*[Integer(int(b)) for b in bit_coords])
for i, bit in enumerate(result):
bit.move_to(ORIGIN, LEFT)
bit.shift(i * RIGHT * 0.325)
result.set_stroke(BLACK, 4, background=True)
return result
bit_strings = VGroup(*[
get_bit_aligned_bit_string(bs)
for bs in self.bit_strings
])
for word, bs in zip(words, bit_strings):
bs.next_to(word.family_members_with_points()[-1], RIGHT, aligned_edge=DOWN)
words[1].set_fill(YELLOW)
bit_strings[1].set_fill(YELLOW)
self.add(words[::2])
self.add(bit_strings[::2])
self.wait()
self.play(FadeIn(words[1]))
curr_rect = None
for n in reversed(range(6)):
rect = SurroundingRectangle(Group(
bit_strings[0][n],
bit_strings[2][n],
buff=0.05,
))
rect.stretch(0.9, 0)
rect.set_stroke(WHITE, 1)
if curr_rect is None:
curr_rect = rect
self.play(ShowCreation(curr_rect))
else:
self.play(Transform(curr_rect, rect, run_time=0.25))
self.wait(0.75)
self.play(FadeIn(bit_strings[1][n]))
self.play(FadeOut(curr_rect))
class ShowCurrAndTargetAlt(ShowCurrAndTarget):
CONFIG = {
"bit_strings": [
"110100",
"010101",
"100001",
]
}
class EulerDiagram(Scene):
def construct(self):
colors = [RED, GREEN, BLUE]
vects = compass_directions(3, UP)
circles = VGroup(*[
Circle(
radius=2,
fill_color=color,
stroke_color=color,
fill_opacity=0.5,
stroke_width=3,
).shift(1.2 * vect)
for vect, color in zip(vects, colors)
])
bit_coords = list(map(int_to_bit_coords, range(8)))
bit_strings = VGroup(*map(get_bit_string, bit_coords))
bit_strings.center()
r1 = 2.2
r2 = 1.4
bit_strings[0].next_to(circles[0], LEFT).shift(UP)
bit_strings[1].shift(r1 * vects[0])
bit_strings[2].shift(r1 * vects[1])
bit_strings[3].shift(r2 * (vects[0] + vects[1]))
bit_strings[4].shift(r1 * vects[2])
bit_strings[5].shift(r2 * (vects[0] + vects[2]))
bit_strings[6].shift(r2 * (vects[1] + vects[2]))
self.add(circles)
for circle in circles:
circle.save_state()
for coords, bstring in zip(bit_coords[1:], bit_strings[1:]):
for circ, coord in zip(circles, reversed(coords)):
circ.generate_target()
if coord:
circ.target.become(circ.saved_state)
else:
circ.target.set_opacity(0.1)
self.play(
FadeIn(bstring),
*map(MoveToTarget, circles),
run_time=0.25,
)
self.wait(0.75)
self.wait()
self.play(FadeIn(bit_strings[0], DOWN))
self.wait()
class ShowBoardRegions(ThreeDScene):
def construct(self):
# Setup
board = Chessboard()
nums = VGroup()
pre_bin_nums = VGroup()
bin_nums = VGroup()
for n, square in enumerate(board):
bin_num = VGroup(*[
Integer(int(b), fill_color=GREY_A)
for b in int_to_bit_coords(n, min_dim=6)
])
bin_num.arrange(RIGHT, buff=SMALL_BUFF)
bin_num.set_width((square.get_width() * 0.8))
num = Integer(n)
num.set_height(square.get_height() * 0.4)
for mob in num, bin_num:
mob.move_to(square, OUT)
mob.set_stroke(BLACK, 4, background=True)
bin_num.align_to(square, DOWN)
bin_num.shift(SMALL_BUFF * UP)
pre_bin_num = num.copy()
pre_bin_num.generate_target()
pre_bin_num.target.replace(bin_num, stretch=True)
pre_bin_num.target.set_opacity(0)
num.generate_target()
num.target.scale(0.7)
num.target.align_to(square, UP)
num.target.shift(SMALL_BUFF * DOWN)
bin_num.save_state()
bin_num.replace(num, stretch=True)
bin_num.set_opacity(0)
nums.add(num)
bin_nums.add(bin_num)
pre_bin_nums.add(pre_bin_num)
# Transform to binary
self.add(board)
self.play(
ShowIncreasingSubsets(nums, run_time=4, rate_func=bezier([0, 0, 1, 1]))
)
self.wait()
self.play(
LaggedStart(*[
AnimationGroup(
MoveToTarget(num),
MoveToTarget(pbn),
Restore(bin_num),
)
for num, pbn, bin_num in zip(nums, pre_bin_nums, bin_nums)
], lag_ratio=1.5 / 64),
)
self.remove(pre_bin_nums)
self.wait(2)
# Build groups to highlight
one_groups = VGroup()
highlights = VGroup()
for i in reversed(range(6)):
one_group = VGroup()
highlight = VGroup()
for bin_num, square in zip(bin_nums, board):
boundary_square = Square()
# boundary_square.set_stroke(YELLOW, 4)
boundary_square.set_stroke(BLUE, 4)
boundary_square.set_fill(BLUE, 0.5)
boundary_square.replace(square)
boundary_square.move_to(square, OUT)
bit = bin_num[i]
if bit.get_value() == 1:
one_group.add(bit)
highlight.add(boundary_square)
one_group.save_state()
one_groups.add(one_group)
highlights.add(highlight)
# Highlight hit_groups
curr_highlight = None
for one_group, highlight in zip(one_groups, highlights):
one_group.generate_target()
one_group.target.set_fill(YELLOW)
one_group.target.set_stroke(YELLOW, 2)
if curr_highlight is None:
self.play(MoveToTarget(one_group))
self.wait()
self.play(LaggedStartMap(DrawBorderThenFill, highlight, lag_ratio=0.1, run_time=3))
curr_highlight = highlight
else:
self.add(one_group, curr_highlight)
self.play(
MoveToTarget(one_group),
Transform(curr_highlight, highlight)
)
self.wait()
self.play(Restore(one_group))
self.wait()
self.play(FadeOut(curr_highlight))
class ShowFinalStrategy(Scene):
CONFIG = {
"show_with_lines": False,
}
def construct(self):
# Setup board and such
board = Chessboard()
board.to_edge(RIGHT)
coins = CoinsOnBoard(board, coin_config={"numeric_labels": True})
coins.flip_by_message("3b1b :)")
encoding_lines = VGroup(*[Line(ORIGIN, 0.5 * RIGHT) for x in range(6)])
encoding_lines.arrange(LEFT, buff=SMALL_BUFF)
encoding_lines.next_to(board, LEFT, LARGE_BUFF)
encoding_lines.shift(UP)
code_words = TextMobject("Encoding")
code_words.next_to(encoding_lines, DOWN)
add_words = TextMobject("Check the parity\\\\of these coins")
add_words.next_to(board, LEFT, LARGE_BUFF, aligned_edge=UP)
self.add(board, coins)
self.add(encoding_lines)
self.add(code_words)
# Set up groups
fade_groups = Group()
line_groups = VGroup()
mover_groups = VGroup()
count_mobs = VGroup()
one_groups = VGroup()
bits = VGroup()
for i in range(6):
bit = Integer(0)
bit.next_to(encoding_lines[i], UP, SMALL_BUFF)
bits.add(bit)
count_mob = Integer(0)
count_mob.set_color(RED)
count_mob.next_to(add_words, DOWN, MED_SMALL_BUFF)
count_mobs.add(count_mob)
line_group = VGroup()
fade_group = Group()
mover_group = VGroup()
one_rect_group = VGroup()
count = 0
for n, coin in enumerate(coins):
if bool(n & (1 << i)):
line_group.add(Line(
coin.get_center(),
bit.get_center(),
))
mover_group.add(coin.labels[1 - int(coin.is_heads())].copy())
if coin.is_heads():
one_rect_group.add(SurroundingRectangle(coin))
count += 1
else:
fade_group.add(coin)
bit.set_value(count % 2)
fade_group.save_state()
line_group.set_stroke(BLUE, width=1, opacity=0.5)
fade_groups.add(fade_group)
line_groups.add(line_group)
mover_groups.add(mover_group)
one_groups.add(one_rect_group)
# Animate
for lines, fades, movers, og, cm, bit in zip(line_groups, fade_groups, mover_groups, one_groups, count_mobs, bits):
self.play(
FadeIn(add_words),
fades.set_opacity, 0.1,
)
if self.show_with_lines:
for mover in movers:
mover.generate_target()
mover.target.replace(bit)
mover.target.set_opacity(0)
bit.save_state()
bit.replace(movers[0])
bit.set_opacity(0)
self.play(
LaggedStartMap(ShowCreation, lines, run_time=2),
LaggedStartMap(MoveToTarget, movers, lag_ratio=0.01),
Restore(bit)
)
self.remove(movers)
self.add(bit)
self.play(
FadeOut(lines)
)
else:
self.play(
ShowIncreasingSubsets(og),
UpdateFromFunc(cm, lambda m: m.set_value(len(og)))
)
self.play(FadeInFromPoint(bit, cm.get_center()))
self.play(
FadeOut(og),
FadeOut(cm),
)
self.play(
FadeOut(add_words),
Restore(fades),
)
self.remove(fades)
self.add(coins)
self.wait()
class ShowFinalStrategyWithFadeLines(ShowFinalStrategy):
CONFIG = {
"show_with_lines": True,
}
class Thumbnail(ThreeDScene):
def construct(self):
# Board
board = Chessboard(
shape=(8, 8),
# shape=(6, 6),
square_resolution=(5, 5),
top_square_resolution=(7, 7),
)
board.set_gloss(0.5)
coins = CoinsOnBoard(
board,
coin_config={
"disk_resolution": (8, 51),
}
)
coins.flip_by_message("A colab!")
# bools = np.array(string_to_bools("A colab!"))
# bools = bools.reshape((6, 8))[:, 2:]
# coins.flip_by_bools(bools.flatten())
# board[0].set_opacity(0)
# coins[0].set_opacity(0)
# k = boolian_linear_combo(coins.get_bools())
k = 6
board[k].set_color(YELLOW)
self.add(board)
self.add(coins)
# Move them
Group(board, coins).shift(DOWN + 2 * RIGHT)
frame = self.camera.frame
frame.set_rotation(phi=50 * DEGREES)
# Title
title = TextMobject("Impossible?")
title.fix_in_frame()
title.set_width(8)
title.to_edge(UP)
title.set_stroke(BLACK, 6, background=True)
# self.add(title)
# Instructions
message = TextMobject(
"Flip one coin\\\\to describe a\\\\",
"unique square",
alignment="",
)
message[1].set_color(YELLOW)
message.scale(1.25)
message.to_edge(LEFT)
message.shift(1.25 * DOWN)
message.fix_in_frame()
arrow = Arrow(
message.get_corner(UR),
message.get_corner(UR) + 3 * RIGHT + UP,
path_arc=-90 * DEGREES,
)
arrow.fix_in_frame()
arrow.shift(1.5 * LEFT)
arrow.set_color(YELLOW)
self.add(message)
self.add(arrow)
class ChessEndScreen(PatreonEndScreen):
CONFIG = {
"scroll_time": 25,
}
Reference in a new issue View git blame Copy permalink