A community-maintained Python framework for creating mathematical animations.
Finished updated borsuk video
Grant Sandersonffb1ee222328
diff --git a/active_projects/borsuk_addition.py b/active_projects/borsuk_addition.pyindex b09dcd625..51509bd4d 100644--- a/active_projects/borsuk_addition.py+++ b/active_projects/borsuk_addition.py@@ -1,6 +1,322 @@from big_ol_pile_of_manim_imports import *from old_projects.lost_lecture import GeometryProofLandfrom old_projects.quaternions import SpecialThreeDScene+from old_projects.uncertainty import Flash+++class Introduction(TeacherStudentsScene):+ CONFIG = {+ "random_seed": 2,+ }++ def construct(self):+ self.play(+ Animation(VectorizedPoint(self.hold_up_spot)),+ self.teacher.change, "raise_right_hand",+ )+ self.change_student_modes(+ "angry", "sassy", "pleading"+ )+ self.wait()++ movements = []+ for student in self.students:+ student.center_tracker = VectorizedPoint()+ student.center_tracker.move_to(student)+ student.center_tracker.save_state()+ student.add_updater(+ lambda m: m.move_to(m.center_tracker)+ )+ movement = ContinualMovement(+ student.center_tracker,+ direction=DOWN + 3 * LEFT,+ rate=1.5 * random.random()+ )+ movements.append(movement)+ self.add(*movements)+ self.change_student_modes(+ "pondering", "sad", "concerned_musician",+ look_at_arg=10 * LEFT + 2 * DOWN+ )+ self.teacher_says(+ "Wait, wait, wait!",+ target_mode="surprised"+ )+ self.remove(*movements)+ self.play(+ self.get_student_changes(*3 * ["hesitant"]),+ *[+ Restore(student.center_tracker)+ for student in self.students+ ]+ )+++class StudentsWatching(TeacherStudentsScene):+ def construct(self):+ self.play(+ self.teacher.change, "raise_right_hand",+ self.get_student_changes(+ *3 * ["thinking"],+ look_at_arg=self.screen+ ),+ VFadeIn(self.pi_creatures, run_time=2)+ )+ self.wait(5)+++class UnexpectedConnection(Scene):+ def construct(self):+ primes = TexMobject(+ "2,", "3,", "5,", "7,", "11,", "13,", "17,", "\\dots"+ )+ primes.move_to(2.5 * UP)++ circle = Circle(+ color=YELLOW,+ stroke_width=1,+ radius=1.5,+ )+ circle.shift(1.5 * DOWN)+ center = circle.get_center()+ center_dot = Dot(center)+ radius = Line(center, circle.get_right())+ radius.set_stroke(WHITE, 3)++ arrow = DoubleArrow(primes, circle)+ arrow.tip[1].shift(SMALL_BUFF * UP)+ arrow.save_state()+ arrow.rotate(90 * DEGREES)+ arrow.scale(1.5)+ arrow.fade(1)++ formula = TexMobject(+ "\\frac{\\pi^2}{6} = \\prod_{p \\text{ prime}}"+ "\\frac{1}{1 - p^{-2}}"+ )+ formula.next_to(arrow.get_center(), RIGHT)++ def get_arc():+ angle = radius.get_angle()+ return Arc(+ start_angle=0,+ angle=angle,+ radius=circle.radius,+ stroke_color=YELLOW,+ stroke_width=5+ ).shift(center)++ arc = updating_mobject_from_func(get_arc)++ decimal = DecimalNumber(0)+ decimal.add_updater(+ lambda d: d.move_to(interpolate(+ radius.get_start(),+ radius.get_end(),+ 1.5,+ )),+ )+ decimal.add_updater(+ lambda d: d.set_value(radius.get_angle())+ )+ pi = TexMobject("\\pi")+ pi.scale(2)+ pi.next_to(circle, LEFT)++ self.add(circle, radius, center_dot, decimal, arc)+ self.play(+ Rotate(radius, PI - 1e-7, about_point=center),+ LaggedStart(FadeInFromDown, primes),+ run_time=4+ )+ self.remove(decimal)+ self.add(pi)+ self.wait()+ self.play(+ Restore(arrow),+ FadeInFrom(formula, LEFT)+ )+ self.wait()+++class MapOfVideo(MovingCameraScene):+ def construct(self):+ images = Group(+ ImageMobject("NecklaceThumbnail"),+ ImageMobject("BorsukUlamThumbnail"),+ ImageMobject("TopologyProofThumbnail"),+ ImageMobject("ContinuousNecklaceThumbnail"),+ ImageMobject("NecklaceSphereAssociationThumbnail")+ )+ for image in images:+ rect = SurroundingRectangle(image, buff=0)+ rect.set_stroke(WHITE, 3)+ image.add(rect)++ image_line = Group(*images[:2], *images[3:])+ image_line.arrange_submobjects(RIGHT, buff=LARGE_BUFF)+ images[2].next_to(image_line, DOWN, buff=1.5)+ images.set_width(FRAME_WIDTH - 1)+ images.to_edge(UP, buff=LARGE_BUFF)++ arrows = VGroup(+ Arrow(images[0], images[1], buff=SMALL_BUFF),+ Arrow(+ images[1].get_corner(DR) + 0.5 * LEFT,+ images[2].get_top() + 0.5 * LEFT,+ ),+ Arrow(+ images[2].get_top() + 0.5 * RIGHT,+ images[3].get_corner(DL) + 0.5 * RIGHT,+ ),+ Arrow(images[3], images[4], buff=SMALL_BUFF),+ )++ self.play(LaggedStart(FadeInFromDown, images, run_time=4))+ self.play(LaggedStart(GrowArrow, arrows))+ self.wait()+ group = Group(images, arrows)+ for image in images:+ group.save_state()+ group.generate_target()+ group.target.shift(-image.get_center())+ group.target.scale(+ FRAME_WIDTH / image.get_width(),+ about_point=ORIGIN,+ )++ self.play(MoveToTarget(group, run_time=3))+ self.wait()+ self.play(Restore(group, run_time=3))++ def get_curved_arrow(self, *points):+ line = VMobject()+ line.set_points(points)+ tip = Arrow(points[-2], points[-1], buff=SMALL_BUFF).tip+ line.pointwise_become_partial(line, 0, 0.9)+ line.add(tip)+ return line+++class MathIsDeep(PiCreatureScene):+ def construct(self):+ words = TextMobject(+ "Math", "is", "deep"+ )+ words.scale(2)+ words.to_edge(UP)+ math = words[0].copy()+ math[1].remove(math[1][1])+ math.set_fill(opacity=0)+ math.set_stroke(width=0, background=True)+ numbers = [13, 1, 20, 8]+ num_mobs = VGroup(*[Integer(d) for d in numbers])+ num_mobs.arrange_submobjects(RIGHT, buff=MED_LARGE_BUFF)+ num_mobs.next_to(math, DOWN, buff=1.5)+ num_mobs.set_color(YELLOW)+ top_arrows = VGroup(*[+ Arrow(c.get_bottom(), n.get_top())+ for c, n in zip(math, num_mobs)+ ])+ n_sum = Integer(sum(numbers))+ n_sum.scale(1.5)+ n_sum.next_to(num_mobs, DOWN, buff=1.5)+ low_arrows = VGroup(*[+ Arrow(n.get_bottom(), n_sum.get_top())+ for n in num_mobs+ ])+ VGroup(top_arrows, low_arrows).set_color(WHITE)++ n_sum_border = n_sum.deepcopy()+ n_sum_border.set_fill(opacity=0)+ n_sum_border.set_stroke(YELLOW, width=1)+ n_sum_border.set_stroke(width=0, background=True)++ # pre_num_mobs = num_mobs.copy()+ # for pn, letter in zip(pre_num_mobs, math):+ # pn.fade(1)+ # pn.set_color(RED)+ # pn.move_to(letter)+ # num_mobs[1].add_subpath(num_mobs[1].points)++ self.play(+ LaggedStart(+ FadeInFromLarge, words,+ scale_factor=1.5,+ run_time=0.6,+ lag_ratio=0.6,+ ),+ self.pi_creature.change, "pondering"+ )+ self.play(+ TransformFromCopy(math, num_mobs),+ *map(GrowArrow, top_arrows),+ )+ self.wait()+ self.play(+ TransformFromCopy(num_mobs, VGroup(n_sum)),+ self.pi_creature.change, "thinking",+ *map(GrowArrow, low_arrows),+ )+ self.play(LaggedStart(ShowCreationThenDestruction, n_sum_border))+ self.play(Blink(self.pi_creature))+ self.wait()+++class MinimizeSharding(Scene):+ def construct(self):+ piece_groups = VGroup(*[+ VGroup(*[+ self.get_piece()+ for x in range(3)+ ]).arrange_submobjects(RIGHT, buff=SMALL_BUFF)+ for y in range(4)+ ]).arrange_submobjects(RIGHT, buff=SMALL_BUFF)++ self.add(piece_groups)+ self.play(*[+ ApplyMethod(mob.space_out_submobjects, 0.7)+ for mob in piece_groups+ ])+ self.wait()+ group1 = piece_groups[:2]+ group2 = piece_groups[2:]+ self.play(+ group1.arrange_submobjects, DOWN,+ group1.next_to, ORIGIN, LEFT, LARGE_BUFF,+ group2.arrange_submobjects, DOWN,+ group2.next_to, ORIGIN, RIGHT, LARGE_BUFF,+ )+ self.wait()++ def get_piece(self):+ jagged_spots = [+ ORIGIN, 2 * UP + RIGHT, 4 * UP + LEFT, 6 * UP,+ ]+ corners = list(it.chain(+ jagged_spots,+ [6 * UP + 10 * RIGHT],+ [+ p + 10 * RIGHT+ for p in reversed(jagged_spots)+ ],+ [ORIGIN]+ ))+ piece = VMobject().set_points_as_corners(corners)+ piece.set_width(1)+ piece.center()+ piece.set_stroke(WHITE, width=0.5)+ piece.set_fill(BLUE, opacity=1)+ return piece+++class Antipodes(Scene):+ def construct(self):+ word = TextMobject("``Antipodes''")+ word.set_width(FRAME_WIDTH - 1)+ word.set_color(MAROON_B)+ self.play(Write(word))+ self.wait()class TopologyWordBreak(Scene):@@ -75,14 +391,27 @@ class Thief(Scene):class FunctionGInSymbols(Scene):def construct(self):p_tex = "\\vec{\\textbf{p}}"- f_of_p = TexMobject("f", "(", p_tex, ")",)+ neg_p_tex = "-\\vec{\\textbf{p}}"++ def color_tex(tex_mob):+ pairs = [+ (p_tex, YELLOW),+ (neg_p_tex, RED),+ ("{g}", GREEN),+ ]+ for tex, color in pairs:+ tex_mob.set_color_by_tex(+ tex, color, substring=False+ )++ f_of_p = TexMobject("f", "(", p_tex, ")")f_of_p.shift(2.5 * LEFT + 2.5 * UP)- f_of_neg_p = TexMobject("f", "(", "-", p_tex, ")")+ f_of_neg_p = TexMobject("f", "(", neg_p_tex, ")")g_of_p = TexMobject("g", "(", p_tex, ")")g_of_p[0].set_color(YELLOW)for mob in f_of_p, f_of_neg_p, g_of_p:- mob.set_color_by_tex(p_tex, BLUE)- dec_rhs = DecimalMatrix([[2.71], [8.28]])+ color_tex(mob)+ dec_rhs = DecimalMatrix([[-0.9], [0.5]])dec_rhs.next_to(f_of_p, RIGHT)minus = TexMobject("-")equals = TexMobject("=")@@ -91,7 +420,7 @@ class FunctionGInSymbols(Scene):for matrix in dec_rhs, zero_zero:matrix.space_out_submobjects(0.8)- matrix.brackets.scale(0.8)+ matrix.brackets.scale(0.9)matrix.next_to(equals, RIGHT)f_of_neg_p.next_to(equals, RIGHT)@@ -149,26 +478,41 @@ class FunctionGInSymbols(Scene):g_of_p.next_to(def_eq, LEFT)rect = SurroundingRectangle(VGroup(g_of_p, f_of_neg_p))rect.set_stroke(width=1)+ seeking_text = TexMobject(+ "\\text{Looking for }", p_tex, "\\text{ where}"+ )+ color_tex(seeking_text)+ seeking_text.next_to(zero_zero, DOWN, MED_LARGE_BUFF)+ seeking_text.to_edge(LEFT)+ g_equals_zero = VGroup(+ g_of_p.copy(), equals, zero_zero+ )+ g_equals_zero.generate_target()+ g_equals_zero.target.arrange_submobjects(RIGHT, SMALL_BUFF)+ g_equals_zero.target.next_to(seeking_text, DOWN)self.play(FadeInFromLarge(g_of_p),FadeInFrom(def_eq, LEFT))+ self.play(+ FadeInFromDown(seeking_text),+ MoveToTarget(g_equals_zero)+ )self.play(ShowCreation(rect))self.wait()self.play(FadeOut(rect))# Show g is odd- g_of_neg_p = TexMobject("g", "(", "-", p_tex, ")")+ g_of_neg_p = TexMobject("{g}", "(", neg_p_tex, ")")eq2 = TexMobject("=")rhs = TexMobject(- "f", "(", "-", p_tex, ")", "-",+ "f", "(", neg_p_tex, ")", "-","f", "(", p_tex, ")", "=",- "-", "g", "(", p_tex, ")",+ "-", "{g}", "(", p_tex, ")",)for mob in g_of_neg_p, rhs:- mob.set_color_by_tex(p_tex, BLUE)- mob.set_color_by_tex("g", YELLOW)+ color_tex(mob)g_of_neg_p.next_to(g_of_p, DOWN, aligned_edge=LEFT, buff=LARGE_BUFF)eq2.next_to(g_of_neg_p, RIGHT, SMALL_BUFF)rhs.next_to(eq2, RIGHT, SMALL_BUFF)@@ -180,9 +524,10 @@ class FunctionGInSymbols(Scene):FadeIn(g_of_neg_p),FadeIn(eq2),FadeIn(neg_g_of_p),+ VGroup(seeking_text, g_equals_zero).shift, 1.5 * DOWN)self.wait()- self.play(CircleThenFadeAround(g_of_neg_p[2:4]))+ self.play(CircleThenFadeAround(g_of_neg_p[2]))self.wait()self.play(CircleThenFadeAround(neg_g_of_p))self.wait()@@ -193,9 +538,9 @@ class FunctionGInSymbols(Scene):lag_ratio=0.8))self.play(- TransformFromCopy(f_of_p, rhs[6:10]),- TransformFromCopy(f_of_neg_p, rhs[:5]),- FadeIn(rhs[5]),+ TransformFromCopy(f_of_p, rhs[5:9]),+ TransformFromCopy(f_of_neg_p, rhs[:4]),+ FadeIn(rhs[4]),FadeIn(rhs[-6]),)self.wait()@@ -203,44 +548,689 @@ class FunctionGInSymbols(Scene):class FunctionGInputSpace(SpecialThreeDScene):def setup(self):- # axes = ThreeDAxes()- # sphere = Sphere(resolution=(24, 48))- sphere = self.get_sphere()- sphere.scale(2)+ self.init_tracked_point()+ sphere = self.get_sphere()sphere.set_fill(BLUE_E, opacity=0.5)+ self.sphere = sphereself.set_camera_orientation(phi=70 * DEGREES,theta=-120 * DEGREES,)self.begin_ambient_camera_rotation(rate=0.02)- # self.add(axes)- self.add(sphere)- self.sphere = sphere+ self.init_dot()++ self.add(ThreeDAxes())def construct(self):self.show_input_dot()+ self.show_start_path()self.show_antipodal_point()self.show_equator()self.deform_towards_north_pole()def show_input_dot(self):- self.play(Write(sphere))+ sphere = self.sphere+ dot = self.dot+ point_mob = self.tracked_point+ start_point = self.get_start_point()++ arrow = Arrow(+ start_point + (LEFT + OUT + UP), start_point,+ color=BLUE,+ buff=MED_LARGE_BUFF,+ )+ arrow.rotate(90 * DEGREES, axis=arrow.get_vector())+ arrow.add_to_back(arrow.copy().set_stroke(BLACK, 5))++ p_label = self.p_label = TexMobject("\\vec{\\textbf{p}}")+ p_label.set_color(YELLOW)+ p_label.next_to(arrow.get_start(), OUT, buff=0.3)+ p_label.set_shade_in_3d(True)++ self.play(Write(sphere, run_time=3))+ self.add(dot)+ self.add_fixed_orientation_mobjects(p_label)+ self.play(+ point_mob.move_to, start_point,+ GrowArrow(arrow),+ FadeInFrom(p_label, IN)+ )+ self.wait()+ self.play(+ arrow.scale, 0, {"about_point": arrow.get_end()},+ p_label.next_to, dot, OUT + LEFT, SMALL_BUFF+ )+ p_label.add_updater(lambda p: p.next_to(dot, OUT + LEFT, SMALL_BUFF))+ self.wait(4)++ def show_start_path(self):+ path = self.get_start_path()+ self.draw_path(path, uncreate=True)+ self.wait()def show_antipodal_point(self):- pass+ path = self.get_antipodal_path()+ end_dot = updating_mobject_from_func(+ lambda: self.get_dot(+ path[-1].point_from_proportion(1)+ ).set_color(RED)+ )++ neg_p = TexMobject("-\\vec{\\textbf{p}}")+ neg_p.add_updater(+ lambda p: p.next_to(end_dot, UP + RIGHT + IN)+ )+ neg_p.set_color(RED)+ neg_p.set_shade_in_3d(True)++ self.move_camera(+ phi=100 * DEGREES,+ theta=30 * DEGREES,+ added_anims=[ShowCreation(path)],+ run_time=4,+ )+ self.wait()+ self.add_fixed_orientation_mobjects(neg_p)+ self.play(+ FadeInFromLarge(end_dot),+ Write(neg_p)+ )+ self.wait(4)+ self.move_camera(+ phi=70 * DEGREES,+ theta=-120 * DEGREES,+ run_time=2+ )+ self.wait(7)+ # Flip+ self.move_camera(+ phi=100 * DEGREES,+ theta=30 * DEGREES,+ run_time=2,+ )+ self.wait(7)+ self.move_camera(+ phi=70 * DEGREES,+ theta=-120 * DEGREES,+ added_anims=[+ FadeOut(end_dot),+ FadeOut(neg_p),+ FadeOut(path),+ ],+ run_time=2,+ )def show_equator(self):- pass+ point_mob = self.tracked_point+ equator = self.get_lat_line()++ self.play(point_mob.move_to, equator[0].point_from_proportion(0))+ self.play(ShowCreation(equator, run_time=4))+ for x in range(2):+ self.play(+ Rotate(point_mob, PI, about_point=ORIGIN, axis=OUT),+ run_time=4+ )+ self.wait(3)+ self.play(+ FadeOut(self.dot),+ FadeOut(self.p_label),+ )++ self.equator = equatordef deform_towards_north_pole(self):- pass+ equator = self.equator++ self.play(UpdateFromAlphaFunc(+ equator,+ lambda m, a: m.become(self.get_lat_line(a * PI / 2)),+ run_time=16+ ))+ self.wait()#+ def init_tracked_point(self):+ self.tracked_point = VectorizedPoint([0, 0, 2])+ self.tracked_point.add_updater(+ lambda p: p.move_to(2 * normalize(p.get_center()))+ )+ self.add(self.tracked_point)++ def init_dot(self):+ self.dot = updating_mobject_from_func(+ lambda: self.get_dot(self.tracked_point.get_center())+ )++ def get_start_path(self):+ path = ParametricFunction(+ lambda t: np.array([+ -np.sin(TAU * t + TAU / 4),+ np.cos(2 * TAU * t + TAU / 4),+ 0+ ]),+ color=RED+ )+ path.scale(0.5)+ path.shift(0.5 * OUT)+ path.rotate(60 * DEGREES, RIGHT, about_point=ORIGIN)+ path.shift(+ self.get_start_point() - path.point_from_proportion(0)+ )+ path.apply_function(lambda p: 2 * normalize(p))+ return path++ def get_antipodal_path(self):+ start = self.get_start_point()+ path = ParametricFunction(+ lambda t: 2.03 * np.array([+ 0,+ np.sin(PI * t),+ np.cos(PI * t),+ ]),+ color=YELLOW+ )+ path.apply_matrix(z_to_vector(start))++ dashed_path = DashedMobject(path)+ dashed_path.set_shade_in_3d(True)++ return dashed_path++ def get_lat_line(self, lat=0):+ equator = ParametricFunction(lambda t: 2.03 * np.array([+ np.cos(lat) * np.sin(TAU * t),+ np.cos(lat) * (-np.cos(TAU * t)),+ np.sin(lat)+ ]))+ equator.rotate(-90 * DEGREES)+ dashed_equator = DashedMobject(+ equator,+ dashes_num=40,+ color=RED,+ )+ dashed_equator.set_shade_in_3d(True)+ return dashed_equator++ def draw_path(self, path,+ run_time=4,+ dot_follow=True,+ uncreate=False,+ added_anims=None+ ):+ added_anims = added_anims or []+ point_mob = self.tracked_point+ anims = [ShowCreation(path)]+ if dot_follow:+ anims.append(UpdateFromFunc(+ point_mob,+ lambda p: p.move_to(path.point_from_proportion(1))+ ))+ self.add(path, self.dot)+ self.play(*anims, run_time=run_time)++ if uncreate:+ self.wait()+ self.play(+ Uncreate(path),+ run_time=run_time+ )++ def modify_path(self, path):+ return path++ def get_start_point(self):+ return 2 * normalize([-1, -1, 1])++ def get_dot(self, point):+ dot = Dot(color=WHITE)+ dot.shift(2.05 * OUT)+ dot.apply_matrix(z_to_vector(normalize(point)))+ dot.set_shade_in_3d(True)+ return dot+++class FunctionGOutputSpace(FunctionGInputSpace):+ def construct(self):+ self.show_input_dot()+ self.show_start_path()+ self.show_antipodal_point()+ self.show_equator()+ self.deform_towards_north_pole()++ def setup(self):+ axes = self.axes = Axes(+ x_min=-2.5,+ x_max=2.5,+ y_min=-2.5,+ y_max=2.5,+ number_line_config={'unit_size': 1.5}+ )+ for axis in axes:+ numbers = list(range(-2, 3))+ numbers.remove(0)+ axis.add_numbers(*numbers)++ self.init_tracked_point()+ self.init_dot()++ def show_input_dot(self):+ axes = self.axes+ dot = self.dot+ point_mob = self.tracked_point++ point_mob.move_to(self.get_start_point())+ self.add(dot)+ self.continual_update(0)+ self.remove(dot)++ p_tex = "\\vec{\\textbf{p}}"+ fp_label = self.fp_label = TexMobject("f(", p_tex, ")")+ fp_label.set_color_by_tex(p_tex, YELLOW)++ self.play(Write(axes, run_time=3))+ self.wait(3)+ dc = dot.copy()+ self.play(+ FadeInFrom(dc, 2 * UP, remover=True),+ UpdateFromFunc(fp_label, lambda fp: fp.next_to(dc, UL, SMALL_BUFF))+ )+ self.add(dot)+ fp_label.add_updater(+ lambda fp: fp.next_to(dot, UL, SMALL_BUFF)+ )+ self.wait(2)++ def draw_path(self, path,+ run_time=4,+ dot_follow=True,+ uncreate=False,+ added_anims=None+ ):+ added_anims = added_anims or []+ point_mob = self.tracked_point+ shadow_path = path.deepcopy().fade(1)+ flat_path = self.modify_path(path)+ anims = [+ ShowCreation(flat_path),+ ShowCreation(shadow_path),+ ]+ if dot_follow:+ anims.append(UpdateFromFunc(+ point_mob,+ lambda p: p.move_to(shadow_path.point_from_proportion(1))+ ))+ self.add(flat_path, self.dot)+ self.play(*anims, run_time=run_time)++ if uncreate:+ self.wait()+ self.remove(shadow_path)+ self.play(+ Uncreate(flat_path),+ run_time=run_time+ )++ def show_antipodal_point(self):+ dot = self.dot+ pre_path = VMobject().set_points_smoothly([+ ORIGIN, DOWN, DOWN + 2 * RIGHT,+ 3 * RIGHT + 0.5 * UP, 0.5 * RIGHT, ORIGIN+ ])+ pre_path.rotate(-45 * DEGREES, about_point=ORIGIN)+ pre_path.shift(dot.get_center())+ path = DashedMobject(pre_path)++ fp_label = self.fp_label+ equals = TexMobject("=")+ equals.next_to(fp_label, RIGHT, SMALL_BUFF)+ f_neg_p = TexMobject("f(", "-\\vec{\\textbf{p}}", ")")+ f_neg_p[1].set_color(RED)+ f_neg_p.next_to(equals, RIGHT)++ gp_label = TexMobject("g", "(", "\\vec{\\textbf{p}}", ")")+ gp_label[0].set_color(GREEN)+ gp_label[2].set_color(YELLOW)+ gp_label.add_updater(lambda m: m.next_to(dot, UL, SMALL_BUFF))+ self.gp_label = gp_label+ # gp_label.next_to(Dot(ORIGIN), UL, SMALL_BUFF)++ self.play(ShowCreation(path, run_time=4))+ self.wait()+ self.play(+ Write(equals),+ Write(f_neg_p),+ )+ self.wait(6)+ self.play(+ FadeOut(VGroup(path, equals, f_neg_p))+ )+ dot.clear_updaters()+ self.add(fp_label, gp_label)+ gp_label.set_background_stroke(width=0)+ self.play(+ dot.move_to, ORIGIN,+ VFadeOut(fp_label),+ VFadeIn(gp_label),+ )+ self.wait(4)+ self.play(+ dot.move_to, self.odd_func(self.get_start_point())+ )+ # Flip, 2 second for flip, 7 seconds after+ path = self.get_antipodal_path()+ path.apply_function(self.odd_func)+ end_dot = Dot(color=RED)+ end_dot.move_to(path[-1].point_from_proportion(1))+ g_neg_p = TexMobject(+ "g", "(", "-\\vec{\\textbf{p}}", ")"+ )+ g_neg_p[0].set_color(GREEN)+ g_neg_p[2].set_color(RED)+ g_neg_p.next_to(end_dot, UR, SMALL_BUFF)+ reflection_line = DashedLine(+ dot.get_center(), end_dot.get_center(),+ stroke_width=0,+ )+ vector = Vector(dot.get_center())++ self.play(ShowCreation(path, run_time=1))+ self.wait()+ self.play(+ ShowCreationThenDestruction(reflection_line, run_time=2),+ TransformFromCopy(dot, end_dot),+ ReplacementTransform(+ gp_label.deepcopy().clear_updaters(), g_neg_p+ ),+ )+ self.wait()+ self.play(FadeIn(vector))+ self.play(Rotate(vector, angle=PI, about_point=ORIGIN))+ self.play(FadeOut(vector))+ self.play(+ FadeOut(end_dot),+ FadeOut(g_neg_p),+ FadeOut(path),+ )++ def show_equator(self):+ dot = self.dot+ point_mob = self.tracked_point+ equator = self.get_lat_line()+ flat_eq = equator.deepcopy().apply_function(self.odd_func)+ equator.fade(1)++ equator_start = equator[0].point_from_proportion(0)++ # To address+ self.play(+ point_mob.move_to, equator_start,+ dot.move_to, self.odd_func(equator_start)+ )+ dot.add_updater(lambda m: m.move_to(+ self.odd_func(point_mob.get_center())+ ))+ self.play(+ ShowCreation(equator),+ ShowCreation(flat_eq),+ run_time=4,+ )+ for x in range(2):+ self.play(+ Rotate(point_mob, PI, about_point=ORIGIN, axis=OUT),+ run_time=4+ )+ self.wait(3)+ self.play(+ FadeOut(self.dot),+ FadeOut(self.gp_label),+ )++ self.equator = equator+ self.flat_eq = flat_eq++ def deform_towards_north_pole(self):+ equator = self.equator+ flat_eq = self.flat_eq++ self.play(+ UpdateFromAlphaFunc(+ equator,+ lambda m, a: m.become(self.get_lat_line(a * PI / 2)).set_stroke(width=0),+ run_time=16+ ),+ UpdateFromFunc(+ flat_eq,+ lambda m: m.become(+ equator.deepcopy().apply_function(self.odd_func).set_stroke(+ color=RED, width=3+ )+ )+ )+ )+ self.wait()+ #+def func(self, point):- pass+ x, y, z = point+ return 0.5 * self.axes.coords_to_point(+ 2 * x + 0.5 * y + z,+ 2 * y - 0.5 * np.sin(PI * x) + z**2 + 1 - x,+ )- def draw_path(self, path):- pass+ def odd_func(self, point):+ return (self.func(point) - self.func(-point)) / 2++ def get_dot(self, point):+ return Dot(self.func(point))++ def modify_path(self, path):+ path.apply_function(self.func)+ return path+++class RotationOfEquatorGraphInOuputSpace(FunctionGOutputSpace):+ def construct(self):+ self.add(self.axes)+ equator = self.get_lat_line(0)+ equator.remove(*equator[len(equator) // 2:])++ flat_eq = equator.copy().apply_function(self.odd_func)+ vector = Vector(flat_eq[0].point_from_proportion(0))+ vector_copy = vector.copy().fade(0.5)++ self.add(flat_eq)+ self.add(flat_eq.copy())+ self.wait()+ self.play(FadeIn(vector))+ self.add(vector_copy)+ self.play(+ Rotate(+ VGroup(flat_eq, vector),+ PI, about_point=ORIGIN, run_time=5+ ))+ self.play(FadeOut(vector), FadeOut(vector_copy))+++class WriteInputSpace(Scene):+ def construct(self):+ self.play(Write(TextMobject("Input space")))+ self.wait()+++class WriteOutputSpace(Scene):+ def construct(self):+ self.play(Write(TextMobject("Output space")))+ self.wait()+++class LineScene(Scene):+ def construct(self):+ self.add(DashedLine(5 * LEFT, 5 * RIGHT, color=WHITE))+++class ShowFlash(Scene):+ def construct(self):+ dot = Dot(ORIGIN, color=YELLOW)+ dot.set_stroke(width=0)+ dot.set_fill(opacity=0)+ self.play(Flash(dot, flash_radius=0.8, line_length=0.6, run_time=2))+ self.wait()+++class WaitForIt(Scene):+ def construct(self):+ words = TextMobject("Wait for it", "$\\dots$", arg_separator="")+ words.scale(2)+ self.add(words[0])+ self.play(Write(words[1], run_time=3))+ self.wait()+++class DrawSphere(SpecialThreeDScene):+ def construct(self):+ sphere = self.get_sphere()+ sphere.shift(IN)+ question = TextMobject("What \\emph{is} a sphere?")+ question.set_width(FRAME_WIDTH - 3)+ question.to_edge(UP)+ self.move_camera(phi=70 * DEGREES, run_time=0)+ self.begin_ambient_camera_rotation()+ self.add_fixed_in_frame_mobjects(question)+ self.play(+ Write(sphere),+ FadeInFromDown(question)+ )+ self.wait(4)+++class DivisionOfUnity(Scene):+ def construct(self):+ factor = 2+ line = Line(factor * LEFT, factor * RIGHT)+ lower_brace = Brace(line, DOWN)+ lower_brace.add(lower_brace.get_text("1"))+ v_lines = VGroup(*[+ DashedLine(0.2 * UP, 0.2 * DOWN).shift(factor * v)+ for v in [LEFT, 0.3 * LEFT, 0.1 * RIGHT, RIGHT]+ ])+ upper_braces = VGroup(*[+ Brace(VGroup(vl1, vl2), UP)+ for vl1, vl2 in zip(v_lines[:-1], v_lines[1:])+ ])+ colors = color_gradient([GREEN, BLUE], 3)+ for i, color, brace in zip(it.count(1), colors, upper_braces):+ label = brace.get_tex("x_%d^2" % i)+ label.set_color(color)+ brace.add(label)++ self.add(line, lower_brace)+ self.play(LaggedStart(+ ShowCreation, v_lines[1:3],+ lag_ratio=0.8,+ run_time=1+ ))+ self.play(LaggedStart(+ GrowFromCenter, upper_braces+ ))+ self.wait()+++class ThreeDSpace(ThreeDScene):+ def construct(self):+ axes = ThreeDAxes()+ self.add(axes)+ self.set_camera_orientation(phi=70 * DEGREES, theta=-130 * DEGREES)+ self.begin_ambient_camera_rotation()++ density = 1+ radius = 3+ lines = VGroup(*[+ VGroup(*[+ Line(+ radius * IN, radius * OUT,+ stroke_color=WHITE,+ stroke_width=1,+ stroke_opacity=0.5,+ ).shift(x * RIGHT + y * UP)+ for x in np.arange(-radius, radius + density, density)+ for y in np.arange(-radius, radius + density, density)+ ]).rotate(n * 120 * DEGREES, axis=[1, 1, 1])+ for n in range(3)+ ])++ self.play(Write(lines))+ self.wait(30)+++class NecklaceSphereConnectionTitle(Scene):+ def construct(self):+ text = TextMobject("Necklace Sphere Association")+ text.set_width(FRAME_WIDTH - 1)+ self.add(text)+++class BorsukEndScreen(PatreonEndScreen):+ CONFIG = {+ "specific_patrons": [+ "Ali Yahya",+ "Meshal Alshammari",+ "Crypticswarm",+ "Ankit Agarwal",+ "Yu Jun",+ "Shelby Doolittle",+ "Dave Nicponski",+ "Damion Kistler",+ "Juan Benet",+ "Othman Alikhan",+ "Justin Helps",+ "Markus Persson",+ "Dan Buchoff",+ "Derek Dai",+ "Joseph John Cox",+ "Luc Ritchie",+ "Guido Gambardella",+ "Jerry Ling",+ "Mark Govea",+ "Vecht ",+ "Jonathan Eppele",+ "Shimin Kuang",+ "Rish Kundalia",+ "Achille Brighton",+ "Kirk Werklund",+ "Ripta Pasay",+ "Felipe Diniz",+ ],+ "n_patron_columns": 2,+ }+++class Thumbnail(SpecialThreeDScene):+ def construct(self):+ sphere = ParametricSurface(+ func=lambda u, v: 2 * np.array([+ np.cos(v) * np.sin(u) + 0.2 * np.cos(3 * u),+ np.sin(v) * np.sin(u),+ np.cos(u) + 0.2 * np.sin(4 * v) - 0.3 * np.cos(3 * u)+ ]),+ resolution=(24, 48),+ u_min=0.001,+ u_max=PI - 0.001,+ v_min=0,+ v_max=TAU,+ )+ sphere.rotate(70 * DEGREES, DOWN)+ self.set_camera_orientation(+ phi=80 * DEGREES,+ theta=-90 * DEGREES,+ )+ # randy = Randolph(mode="telepath")+ # eyes = VGroup(randy.eyes, randy.pupils)+ # eyes.scale(3.5)+ # eyes.rotate(90 * DEGREES, RIGHT)+ # eyes.next_to(sphere, OUT, buff=0)++ self.add(sphere)