Skip to content

armgit / manim

Public Imported from GitHub
0

A community-maintained Python framework for creating mathematical animations.

Bayes scenes up to GlimpseOfNextVideo

Grant Sanderson5ea6c0f52518
diff --git a/3b1b_projects/active/bayes.py b/3b1b_projects/active/bayes.py
index 3279a4a50..ff202e18f 100644
--- a/3b1b_projects/active/bayes.py
+++ b/3b1b_projects/active/bayes.py
@@ -1,5 +1,7 @@
from manimlib.imports import *
+import scipy.integrate
+
OUTPUT_DIRECTORY = "bayes"
HYPOTHESIS_COLOR = YELLOW
@@ -220,10 +222,10 @@ class ProbabilityBar(VGroup):
"stroke_color": WHITE,
"fill_opacity": 1,
},
- "include_braces": True,
+ "include_braces": False,
"brace_direction": UP,
"include_percentages": True,
- "percentage_background_stroke_width": 5,
+ "percentage_background_stroke_width": 2,
}
def __init__(self, p=0.5, **kwargs):
@@ -444,6 +446,7 @@ class Test(Scene):
class IntroduceFormula(Scene):
def construct(self):
formula = get_bayes_formula()
+ formula.save_state()
formula.set_width(FRAME_WIDTH - 1)
def get_formula_slice(*indices):
@@ -482,7 +485,6 @@ class IntroduceFormula(Scene):
get_formula_slice(8, 9, 10, 11),
),
)
- self.wait()
# Likelihood
lhs_copy = formula[:6].copy()
@@ -500,7 +502,6 @@ class IntroduceFormula(Scene):
lhs_copy.move_to, likelihood,
run_time=run_time,
)
- self.wait()
# Evidence
self.play(
@@ -512,6 +513,17 @@ class IntroduceFormula(Scene):
)
self.wait()
+ self.clear()
+ self.play(
+ formula.restore,
+ formula.scale, 1.5,
+ formula.to_edge, UP,
+ FadeOut(VGroup(
+ hyp_arrow, hyp_label,
+ evid_arrow, evid_label,
+ ))
+ )
+
class StateGoal(PiCreatureScene):
CONFIG = {
@@ -817,7 +829,11 @@ class DescriptionOfSteve(Scene):
self.wait()
def compare_probabilities(self):
- bar = ProbabilityBar(0.5, width=10)
+ bar = ProbabilityBar(
+ 0.5, width=10,
+ include_braces=True,
+ percentage_background_stroke_width=2,
+ )
icons = VGroup(
LibrarianIcon(),
FarmerIcon(),
@@ -984,8 +1000,7 @@ class IntroduceKahnemanAndTversky(DescriptionOfSteve, MovingCameraScene):
)
bar.scale(0.5)
bar.next_to(randy, RIGHT, buff=0.75)
- bar.UpdateFromAlphaFunc(
- ())
+ bar.update()
self.play(
LaggedStartMap(MoveToTarget, images),
@@ -2831,6 +2846,16 @@ class AskAboutWhenProbabilityIsIntuitive(TeacherStudentsScene):
words = TextMobject("What makes probability\\\\more intuitive?")
words.move_to(self.hold_up_spot, DOWN)
words.shift_onto_screen()
+
+ self.play(
+ self.teacher.change, "speaking",
+ self.get_student_changes(
+ "pondering", "sassy", "happy",
+ look_at_arg=self.screen,
+ )
+ )
+ self.wait(2)
+
self.play(
self.teacher.change, "raise_right_hand",
FadeInFrom(words, DOWN),
@@ -2847,7 +2872,7 @@ class AskAboutWhenProbabilityIsIntuitive(TeacherStudentsScene):
look_at_arg=3 * UP,
)
)
- self.wait(2)
+ self.wait(6)
class IntroduceLinda(DescriptionOfSteve):
@@ -3040,7 +3065,7 @@ class IntroduceLinda(DescriptionOfSteve):
TextMobject("1) Bank tellers? \\underline{\\qquad} of 100", **kw),
TextMobject(
"2) Bank tellers and active in the",
- " feminist movement?? \\underline{\\qquad} of 100",
+ " feminist movement? \\underline{\\qquad} of 100",
**kw
),
)
@@ -3105,6 +3130,650 @@ class IntroduceLinda(DescriptionOfSteve):
return result
-class AlternatePhrasings(Scene):
+class LindaDescription(IntroduceLinda):
def construct(self):
- pass
+ words = self.get_linda_description()
+ words.set_color(WHITE)
+
+ highlighted_part = VGroup(
+ *words.get_part_by_tex("deeply"),
+ *words.get_part_by_tex("discrimination"),
+ )
+
+ self.add(words)
+ self.play(
+ FadeIn(words),
+ run_time=3,
+ lag_ratio=0.01,
+ rate_func=linear,
+ )
+ self.wait(1)
+ self.play(
+ highlighted_part.set_color, YELLOW,
+ lag_ratio=0.1,
+ run_time=2
+ )
+ self.wait()
+
+
+class AlternatePhrasings(PiCreatureScene):
+ CONFIG = {
+ "camera_config": {
+ "background_color": DARKER_GREY,
+ }
+ }
+
+ def construct(self):
+ randy = self.pi_creature
+
+ phrases = VGroup(
+ TextMobject("40 out of 100"),
+ TexMobject("40\\%"),
+ TexMobject("0.4"),
+ TextMobject("What's more likely$\\dots$"),
+ )
+ for phrase in phrases:
+ phrase.scale(1.5)
+ phrase.next_to(randy, RIGHT, buff=LARGE_BUFF)
+ phrase.align_to(randy, UP)
+
+ def push_down(phrase):
+ phrase.scale(0.8, about_edge=LEFT)
+ phrase.shift(1 * DOWN)
+ phrase.set_opacity(0.5)
+ return phrase
+
+ bubble = randy.get_bubble()
+ content_width = 4.5
+
+ people = VGroup(*[Person() for x in range(100)])
+ people.arrange_in_grid(n_cols=20)
+ people.set_width(content_width)
+ people.move_to(bubble.get_bubble_center())
+ people.shift(SMALL_BUFF * UP)
+ people[:40].set_color(YELLOW)
+
+ bar = ProbabilityBar(0.9999)
+ bar.set_width(content_width)
+ bar.move_to(people)
+
+ steve = Steve()
+ steve.set_height(1)
+ steve_words = TextMobject("seems bookish...")
+ steve_words.next_to(steve, RIGHT, MED_LARGE_BUFF)
+ steve.add(steve_words)
+
+ linda = Linda()
+ linda.set_height(1)
+ linda_words = TextMobject("seems activist...")
+ linda_words.next_to(linda, RIGHT, MED_LARGE_BUFF)
+ linda.add(linda_words)
+
+ stereotypes = VGroup(steve, linda)
+ stereotypes.arrange(DOWN, buff=MED_SMALL_BUFF, aligned_edge=LEFT)
+ stereotypes.move_to(people)
+
+ self.play(
+ FadeInFrom(phrases[0], UP),
+ randy.change, "pondering",
+ )
+ self.play(
+ DrawBorderThenFill(bubble, lag_ratio=0.1),
+ FadeIn(people, lag_ratio=0.1),
+ randy.change, "thinking", people,
+ )
+ self.wait()
+ self.play(
+ FadeInFrom(phrases[1], UP),
+ randy.change, "confused", phrases[1],
+ FadeOut(people),
+ ApplyFunction(push_down, phrases[0]),
+ FadeIn(bar),
+ )
+ self.play(bar.p_tracker.set_value, 0.4)
+ bar.clear_updaters()
+ self.play(
+ FadeInFrom(phrases[2], UP),
+ ApplyFunction(push_down, phrases[:2]),
+ FadeOut(bar.percentages),
+ randy.change, "guilty",
+ )
+ self.wait()
+ bar.remove(bar.percentages)
+ self.play(
+ FadeInFrom(phrases[3], UP),
+ ApplyFunction(push_down, phrases[:3]),
+ FadeOut(bar),
+ FadeIn(stereotypes),
+ randy.change, "shruggie", stereotypes,
+ )
+ self.wait(6)
+
+
+class WhenDiscreteChunksArentSoClean(Scene):
+ def construct(self):
+ squares = VGroup(*[Square() for x in range(100)])
+ squares.arrange_in_grid(n_cols=10, buff=0)
+ squares.set_stroke(WHITE, 1)
+ squares.set_fill(DARKER_GREY, 1)
+ squares.set_height(6)
+ squares.to_edge(DOWN)
+
+ target_p = 0.3612
+
+ rain, sun = icon_templates = VGroup(
+ SVGMobject("rain_cloud"),
+ SVGMobject("sunny"),
+ )
+ for icon in icon_templates:
+ icon.set_width(0.6 * squares[0].get_width())
+ icon.set_stroke(width=0)
+ icon.set_sheen(0.5, UL)
+ rain.set_color(BLUE_E)
+ sun.set_color(YELLOW)
+
+ partial_rects = VGroup()
+ icons = VGroup()
+ q_marks = VGroup()
+ for i, square in enumerate(squares):
+ icon = rain.copy() if i < 40 else sun.copy()
+ icon.move_to(square)
+ icons.add(icon)
+
+ partial_rect = square.copy()
+ partial_rect.set_stroke(width=0)
+ partial_rect.scale(0.95)
+ partial_rect.stretch(
+ 0.4,
+ 0,
+ about_edge=RIGHT
+ )
+ partial_rects.add(partial_rect)
+
+ q_mark = TexMobject("?")
+ q_mark.replace(partial_rect, dim_to_match=0)
+ q_mark.scale(0.8)
+ q_marks.add(q_mark)
+
+ p_label = VGroup(
+ TexMobject("P", "(", "\\text{Rain}", ")", "="),
+ DecimalNumber(40, unit="\\%", num_decimal_places=2)
+ )
+ percentage = p_label[1]
+ p_label.arrange(RIGHT)
+ p_label.to_edge(UP)
+ p_label[0].set_color_by_tex("Rain", BLUE)
+ percentage.align_to(p_label[0][0], DOWN)
+
+ alt_percentage = Integer(0, unit="\\%")
+ alt_percentage.move_to(percentage, LEFT)
+
+ self.add(squares)
+ self.add(p_label[0])
+ self.play(
+ ChangeDecimalToValue(alt_percentage, 40),
+ ShowIncreasingSubsets(icons[:40])
+ )
+ self.play(FadeIn(icons[40:]))
+ self.wait()
+ self.remove(alt_percentage)
+ self.add(percentage)
+ self.play(
+ ChangeDecimalToValue(percentage, 100 * target_p),
+ FadeIn(partial_rects[30:40]),
+ FadeIn(q_marks[30:40], lag_ratio=0.3)
+ )
+ self.wait(2)
+
+ l_rect = Rectangle(fill_color=BLUE_D)
+ r_rect = Rectangle(fill_color=LIGHT_GREY)
+ rects = VGroup(l_rect, r_rect)
+ for rect, p in (l_rect, target_p), (r_rect, 1 - target_p):
+ rect.set_height(squares.get_height())
+ rect.set_width(p * squares.get_width(), stretch=True)
+ rect.set_stroke(WHITE, 2)
+ rect.set_fill(opacity=1)
+ rects.arrange(RIGHT, buff=0)
+ rects.move_to(squares)
+
+ brace = Brace(l_rect, UP, buff=SMALL_BUFF)
+
+ sun = icons[40].copy()
+ rain = icons[0].copy()
+ for mob, rect in [(rain, l_rect), (sun, r_rect)]:
+ mob.generate_target()
+ mob.target.set_stroke(BLACK, 3, background=True)
+ mob.target.set_height(1)
+ mob.target.move_to(rect)
+ self.play(
+ FadeIn(rects),
+ MoveToTarget(rain),
+ MoveToTarget(sun),
+ GrowFromCenter(brace),
+ p_label.shift,
+ brace.get_top() + MED_SMALL_BUFF * UP -
+ percentage.get_bottom(),
+ )
+ self.wait()
+
+ # With updaters
+ full_width = rects.get_width()
+ rain.add_updater(lambda m: m.move_to(l_rect))
+ sun.add_updater(lambda m: m.move_to(r_rect))
+ r_rect.add_updater(lambda m: m.set_width(
+ full_width - l_rect.get_width(),
+ about_edge=RIGHT,
+ stretch=True,
+ ))
+ brace.add_updater(lambda m: m.match_width(l_rect, stretch=True))
+ brace.add_updater(lambda m: m.next_to(l_rect, UP, SMALL_BUFF))
+ percentage.add_updater(lambda m: m.set_value(
+ 100 * l_rect.get_width() / full_width,
+ ))
+ percentage.add_updater(lambda m: m.next_to(brace, UP, MED_SMALL_BUFF))
+
+ self.play(
+ MaintainPositionRelativeTo(p_label[0], percentage),
+ l_rect.stretch, 2, 0, {"about_edge": LEFT},
+ run_time=8,
+ rate_func=there_and_back,
+ )
+
+
+class RandomnessVsProportions(Scene):
+ def construct(self):
+ prob_word = TextMobject("Probability")
+ unc_word = TextMobject("Uncertainty")
+ prop_word = TextMobject("Proportions")
+ words = VGroup(prop_word, prob_word, unc_word)
+ words.arrange(RIGHT, buff=LARGE_BUFF)
+ words.set_width(FRAME_WIDTH - 1)
+ words.to_edge(UP)
+ arrows = VGroup()
+ for w1, w2 in zip(words, words[1:]):
+ arrow = TexMobject("\\rightarrow")
+ arrow.move_to(midpoint(w1.get_right(), w2.get_left()))
+ arrows.add(arrow)
+
+ random_dice = self.get_random_dice()
+ random_dice.next_to(unc_word, DOWN, LARGE_BUFF)
+
+ diagram = self.get_dice_diagram()
+ diagram.next_to(prop_word, DOWN, LARGE_BUFF)
+ diagram.shift_onto_screen()
+
+ grid = diagram[0]
+ border = grid[0][0].copy()
+ border.set_stroke(BLACK, 3)
+ border.set_fill(WHITE, opacity=0.2)
+ border.scale(1.02)
+
+ def update_border(border):
+ r1, r2 = random_dice
+ i = len(r1[1]) - 1
+ j = len(r2[1]) - 1
+ border.move_to(diagram[0][i][j])
+ border.add_updater(update_border)
+
+ example = VGroup(
+ TextMobject("P(X = 5)", tex_to_color_map={"5": YELLOW}),
+ Line(LEFT, RIGHT)
+ )
+ example.arrange(RIGHT)
+ example.next_to(grid, RIGHT, LARGE_BUFF)
+ example.align_to(random_dice, RIGHT)
+ example.shift(0.5 * DOWN)
+ grid_copy = grid.copy()
+ five_part = VGroup(*[
+ square
+ for i, row in enumerate(grid_copy)
+ for j, square in enumerate(row)
+ if i + j == 3
+ ])
+
+ self.play(FadeInFromDown(prob_word))
+ self.play(
+ FadeInFrom(unc_word, LEFT),
+ Write(arrows[1]),
+ )
+ self.add(random_dice)
+ self.wait(9)
+ self.play(
+ FadeInFrom(prop_word, RIGHT),
+ Write(arrows[0])
+ )
+ self.play(FadeIn(diagram))
+ self.add(border)
+ self.wait(2)
+
+ self.play(FadeIn(example))
+ self.add(grid_copy, diagram[1])
+ self.play(
+ grid_copy.set_width, 0.8 * example[1].get_width(),
+ grid_copy.next_to, example[1], DOWN,
+ )
+ self.play(five_part.copy().next_to, example[1], UP)
+ self.wait(6)
+
+ def get_die_faces(self):
+ dot = Dot()
+ dot.set_width(0.15)
+ dot.set_color(BLUE_B)
+
+ square = Square()
+ square.round_corners(0.25)
+ square.set_stroke(WHITE, 2)
+ square.set_fill(DARKER_GREY, 1)
+ square.set_width(0.6)
+
+ edge_groups = [
+ (ORIGIN,),
+ (UL, DR),
+ (UL, ORIGIN, DR),
+ (UL, UR, DL, DR),
+ (UL, UR, ORIGIN, DL, DR),
+ (UL, UR, LEFT, RIGHT, DL, DR),
+ ]
+
+ arrangements = VGroup(*[
+ VGroup(*[
+ dot.copy().move_to(square.get_critical_point(ec))
+ for ec in edge_group
+ ])
+ for edge_group in edge_groups
+ ])
+ square.set_width(1)
+
+ faces = VGroup(*[
+ VGroup(square.copy(), arrangement)
+ for arrangement in arrangements
+ ])
+ faces.arrange(RIGHT)
+
+ return faces
+
+ def get_random_dice(self):
+ faces = list(self.get_die_faces())
+
+ def get_random_pair():
+ result = VGroup(*random.sample(faces, 2)).copy()
+ result.arrange(RIGHT)
+ for mob in result:
+ mob.shift(random.random() * RIGHT * MED_SMALL_BUFF)
+ mob.shift(random.random() * UP * MED_SMALL_BUFF)
+ return result
+
+ result = VGroup(*get_random_pair())
+ result.time = 0
+ result.iter_count = 0
+
+ def update_result(group, dt):
+ group.time += dt
+ group.iter_count += 1
+ if int(group.time) % 3 == 2:
+ group.set_stroke(YELLOW)
+ return group
+ elif result.iter_count % 3 != 0:
+ return group
+ else:
+ pair = get_random_pair()
+ pair.move_to(group)
+ group.submobjects = [*pair]
+
+ result.add_updater(update_result)
+ result.update()
+ return result
+
+ def get_dice_diagram(self):
+ grid = VGroup(*[
+ VGroup(*[
+ Square() for x in range(6)
+ ]).arrange(RIGHT, buff=0)
+ for y in range(6)
+ ]).arrange(DOWN, buff=0)
+ grid.set_stroke(WHITE, 1)
+ grid.set_height(5)
+
+ colors = color_gradient([RED, YELLOW, GREEN, BLUE], 11)
+
+ numbers = VGroup()
+ for i, row in enumerate(grid):
+ for j, square in enumerate(row):
+ num = Integer(i + j + 2)
+ num.set_height(square.get_height() - MED_LARGE_BUFF)
+ num.move_to(square)
+ # num.set_stroke(BLACK, 2, background=True)
+ num.set_fill(DARK_GREY)
+ square.set_fill(colors[i + j], 0.9)
+ numbers.add(num)
+
+ faces = VGroup()
+ face_templates = self.get_die_faces()
+ face_templates.scale(0.5)
+ for face, row in zip(face_templates, grid):
+ face.next_to(row, LEFT, MED_SMALL_BUFF)
+ faces.add(face)
+ for face, square in zip(faces.copy(), grid[0]):
+ face.next_to(square, UP, MED_SMALL_BUFF)
+ faces.add(face)
+
+ result = VGroup(grid, numbers, faces)
+ return result
+
+
+class JustRandomDice(RandomnessVsProportions):
+ def construct(self):
+ random_dice = self.get_random_dice()
+ random_dice.center()
+
+ self.add(random_dice)
+ self.wait(60)
+
+
+class BayesTheoremOnProportions(Scene):
+ def construct(self):
+ # Place on top of visuals from "HeartOfBayes"
+ formula = get_bayes_formula()
+ formula.scale(1.5)
+
+ title = TextMobject("Bayes' theorem")
+ title.scale(2)
+ title.next_to(formula, UP, LARGE_BUFF)
+ group = VGroup(formula, title)
+
+ equals = TexMobject("=")
+ equals.next_to(formula, RIGHT)
+ h_line = Line(LEFT, RIGHT)
+ h_line.set_width(4)
+ h_line.next_to(equals, RIGHT)
+ h_line.set_stroke(WHITE, 3)
+
+ self.add(group)
+ self.wait()
+ self.play(
+ group.to_edge, LEFT,
+ MaintainPositionRelativeTo(equals, group),
+ VFadeIn(equals),
+ MaintainPositionRelativeTo(h_line, group),
+ VFadeIn(h_line),
+ )
+
+ # People
+ people = VGroup(*[Person() for x in range(7)])
+ people.arrange(RIGHT)
+ people.match_width(h_line)
+ people.next_to(h_line, DOWN)
+ people.set_color(BLUE_E)
+ people[:3].set_color(GREEN)
+ num_people = people[:3].copy()
+
+ self.play(FadeIn(people, lag_ratio=0.1))
+ self.play(num_people.next_to, h_line, UP)
+ self.wait(0.5)
+
+ # Diagrams
+ diagram = BayesDiagram(0.25, 0.5, 0.2)
+ diagram.set_width(0.7 * h_line.get_width())
+ diagram.next_to(h_line, DOWN)
+ diagram.hne_rect.set_fill(opacity=0.1)
+ diagram.nhne_rect.set_fill(opacity=0.1)
+ num_diagram = diagram.deepcopy()
+ num_diagram.next_to(h_line, UP)
+ num_diagram.nhe_rect.set_fill(opacity=0.1)
+ low_diagram_rects = VGroup(diagram.he_rect, diagram.nhe_rect)
+ top_diagram_rects = VGroup(num_diagram.he_rect)
+
+ self.play(
+ FadeOut(people),
+ FadeOut(num_people),
+ FadeIn(diagram),
+ FadeIn(num_diagram),
+ )
+ self.wait()
+
+ # Circle each part
+ E_part = VGroup(formula[4], *formula[19:]).copy()
+ H_part = VGroup(formula[2], *formula[8:18]).copy()
+
+ E_arrow = Vector(UP, color=BLUE)
+ E_arrow.next_to(E_part[0], DOWN)
+ E_words = TextMobject(
+ "...among cases where\\\\$E$ is True",
+ tex_to_color_map={"$E$": BLUE},
+ )
+ E_words.next_to(E_arrow, DOWN)
+ H_arrow = Vector(DOWN, color=YELLOW)
+ H_arrow.next_to(H_part[0], UP)
+ H_words = TextMobject(
+ "How often is\\\\$H$ True...",
+ tex_to_color_map={"$H$": YELLOW},
+ )
+ H_words.next_to(H_arrow, UP)
+
+ denom_rect = SurroundingRectangle(E_part[1:], color=BLUE)
+ numer_rect = SurroundingRectangle(H_part[1:], color=YELLOW)
+
+ self.play(
+ formula.set_opacity, 0.5,
+ ApplyMethod(
+ E_part.set_stroke, YELLOW, 3, {"background": True},
+ rate_func=there_and_back,
+ ),
+ FadeIn(denom_rect),
+ ShowCreation(E_arrow),
+ FadeInFrom(E_words, UP),
+ low_diagram_rects.set_stroke, TEAL, 3,
+ )
+ self.wait()
+ self.play(
+ FadeOut(E_part),
+ FadeIn(H_part),
+ FadeOut(denom_rect),
+ FadeIn(numer_rect),
+ ShowCreation(H_arrow),
+ FadeInFrom(H_words, DOWN),
+ FadeOutAndShift(title, UP),
+ low_diagram_rects.set_stroke, WHITE, 1,
+ top_diagram_rects.set_stroke, YELLOW, 3,
+ )
+ self.wait()
+
+
+class GlimpseOfNextVideo(GraphScene):
+ CONFIG = {
+ "x_axis_label": "",
+ "y_axis_label": "",
+ "x_min": 0,
+ "x_max": 15,
+ "x_axis_width": 12,
+ "y_min": 0,
+ "y_max": 1.0,
+ "y_axis_height": 6,
+ "y_tick_frequency": 0.125,
+ }
+
+ def construct(self):
+ self.setup_axes()
+ self.y_axis.add_numbers(
+ 0.25, 0.5, 0.75, 1,
+ number_config={
+ "num_decimal_places": 2,
+ },
+ direction=LEFT,
+ )
+ self.x_axis.add_numbers(*range(1, 15),)
+
+ def f1(x):
+ return (x**3 / 6) * np.exp(-x)
+
+ def f2(x):
+ return f1(x) * np.exp(-0.5 * x)
+ # return f1(x) * (x**5 / 120) * np.exp(-x)
+
+ pe = scipy.integrate.quad(f2, 0, 20)[0]
+
+ graph1 = self.get_graph(f1)
+ graph2 = self.get_graph(f2)
+
+ rects1 = self.get_riemann_rectangles(graph1, dx=0.2)
+ rects2 = self.get_riemann_rectangles(graph2, dx=0.2)
+
+ rects1.set_color(YELLOW_D)
+ rects2.set_color(BLUE)
+ for rects in rects1, rects2:
+ rects.set_stroke(WHITE, 1)
+
+ rects1.save_state()
+ rects1.stretch(0, 1, about_edge=DOWN)
+
+ formula = TexMobject(
+ "P(H) P(E|H) \\over P(E)",
+ tex_to_color_map={
+ "H": HYPOTHESIS_COLOR,
+ "E": EVIDENCE_COLOR1,
+ },
+ substrings_to_isolate=list("P(|)")
+ )
+
+ self.play(
+ FadeInFromDown(formula[:4]),
+ Restore(rects1, lag_ratio=0.05, run_time=2)
+ )
+ self.wait()
+ self.add(rects1.copy().set_opacity(0.4))
+ self.play(
+ FadeInFromDown(formula[4:10]),
+ Transform(rects1, rects2),
+ )
+ self.play(
+ rects1.stretch, 1 / pe, 1, {"about_edge": DOWN},
+ Write(formula[10:], run_time=1)
+ )
+ self.wait()
+
+
+class ComingUp(Scene):
+ CONFIG = {
+ "camera_config": {"background_color": DARK_GREY}
+ }
+
+ def construct(self):
+ rect = ScreenRectangle()
+ rect.set_height(6)
+ rect.set_fill(BLACK, 1)
+ rect.set_stroke(WHITE, 2)
+
+ words = TextMobject("Later...")
+ words.scale(2)
+ words.to_edge(UP)
+ rect.next_to(words, DOWN)
+
+ self.add(rect)
+ self.play(FadeIn(words))
+ self.wait()
+
+
+class QuestionSteveConclusion(Scene):
+ def construct(self):
+ steve = Steve()
+ self.add(steve)