Skip to content

armgit / manim

Public Imported from GitHub
0

A community-maintained Python framework for creating mathematical animations.

Lemma1 and Lemma2 animations

Grant Sanderson16fe9209e876
diff --git a/active_projects/wallis_g.py b/active_projects/wallis_g.py
index cf90cefaa..b825000f6 100644
--- a/active_projects/wallis_g.py
+++ b/active_projects/wallis_g.py
@@ -4,23 +4,238 @@ from once_useful_constructs.light import Lighthouse
from once_useful_constructs.light import SwitchOn
# from once_useful_constructs.light import LightSource
+PRODUCT_COLOR = BLUE
+CHEAP_AMBIENT_LIGHT_CONFIG = {
+ "num_levels": 5,
+ "radius": 1,
+}
-class IntroduceDistanceProduct(MovingCameraScene):
+
+class DistanceProductScene(MovingCameraScene):
CONFIG = {
"ambient_light_config": {
- "opacity_function": inverse_quadratic(1, 1.1, 1),
+ "opacity_function": inverse_power_law(1, 1.5, 1, 4),
"num_levels": 100,
+ "light_radius": 5,
+ "max_opacity": 0.8,
+ "color": PRODUCT_COLOR,
+ },
+ "circle_color": BLUE,
+ "circle_radius": 3,
+ "num_lighthouses": 6,
+ "lighthouse_height": 0.5,
+ "ignored_lighthouse_indices": [],
+ "observer_config": {
+ "color": MAROON_B,
+ "mode": "pondering",
+ "height": 0.25,
+ "flip_at_start": True,
+ },
+ "observer_fraction": 1.0 / 3,
+ "d_label_height": 0.35,
+ "numeric_distance_label_height": 0.25,
+ "default_product_column_top": FRAME_WIDTH * RIGHT / 4 + 1.5 * UP,
+ }
+
+ def setup(self):
+ super(DistanceProductScene, self).setup()
+ self.circle = Circle(
+ color=self.circle_color,
+ radius=self.circle_radius,
+ )
+
+ def get_circle_point_at_proportion(self, alpha):
+ radius = self.get_radius()
+ center = self.circle.get_center()
+ angle = alpha * TAU
+ unit_circle_point = np.cos(angle) * RIGHT + np.sin(angle) * UP
+ return radius * unit_circle_point + center
+
+ def get_lh_points(self):
+ return np.array([
+ self.get_circle_point_at_proportion(fdiv(i, self.num_lighthouses))
+ for i in range(self.num_lighthouses)
+ if i not in self.ignored_lighthouse_indices
+ ])
+
+ def get_observer_point(self, fraction=None):
+ if fraction is None:
+ fraction = self.observer_fraction
+ return self.get_circle_point_at_proportion(fraction / self.num_lighthouses)
+
+ def get_observer(self):
+ observer = self.observer = PiCreature(**self.observer_config)
+ observer.next_to(self.get_observer_point(), RIGHT, buff=SMALL_BUFF)
+ return observer
+
+ def get_observer_dot(self):
+ self.observer_dot = Dot(
+ self.get_observer_point(),
+ color=self.observer_config["color"]
+ )
+ return self.observer_dot
+
+ def get_lighthouses(self):
+ self.lighthouses = VGroup()
+ for point in self.get_lh_points():
+ lighthouse = Lighthouse()
+ lighthouse.scale_to_fit_height(self.lighthouse_height)
+ lighthouse.move_to(point)
+ self.lighthouses.add(lighthouse)
+ return self.lighthouses
+
+ def get_lights(self):
+ self.lights = VGroup()
+ for point in self.get_lh_points():
+ light = AmbientLight(
+ source_point=VectorizedPoint(point),
+ **self.ambient_light_config
+ )
+ self.lights.add(light)
+ return self.lights
+
+ def get_distance_lines(self):
+ self.distance_lines = VGroup(*[
+ Line(self.get_observer_point(), point)
+ for point in self.get_lh_points()
+ ])
+ return self.distance_lines
+
+ def get_symbolic_distance_labels(self):
+ if not hasattr(self, "distance_lines"):
+ self.get_distance_lines()
+ self.d_labels = VGroup()
+ for i, line in enumerate(self.distance_lines):
+ d_label = TexMobject("d_%d" % i)
+ d_label.scale_to_fit_height(self.d_label_height)
+ vect = rotate_vector(line.get_vector(), 90 * DEGREES)
+ vect *= 2.5 * SMALL_BUFF / np.linalg.norm(vect)
+ d_label.move_to(line.get_center() + vect)
+ self.d_labels.add(d_label)
+ return self.d_labels
+
+ def get_numeric_distance_labels(self, num_decimal_points=3, show_ellipsis=True):
+ radius = self.circle.get_width() / 2
+ if not hasattr(self, "distance_lines"):
+ self.get_distance_lines()
+ labels = self.numeric_distance_labels = VGroup()
+ for line in self.distance_lines:
+ label = DecimalNumber(
+ line.get_length() / radius,
+ num_decimal_points=num_decimal_points,
+ show_ellipsis=show_ellipsis,
+ )
+ label.scale_to_fit_height(self.numeric_distance_label_height)
+ max_width = 0.5 * line.get_length()
+ if label.get_width() > max_width:
+ label.scale_to_fit_width(max_width)
+ angle = (line.get_angle() % TAU) - TAU / 2
+ if np.abs(angle) > TAU / 4:
+ angle += np.sign(angle) * np.pi
+ label.angle = angle
+ label.next_to(line.get_center(), UP, SMALL_BUFF)
+ label.rotate(angle, about_point=line.get_center())
+ labels.add(label)
+ return labels
+
+ def get_circle_group(self):
+ group = VGroup(self.circle)
+ if not hasattr(self, "observer_dot"):
+ self.get_observer_dot()
+ if not hasattr(self, "observer"):
+ self.get_observer()
+ if not hasattr(self, "lighthouses"):
+ self.get_lighthouses()
+ if not hasattr(self, "lights"):
+ self.get_lights()
+ group.add(
+ self.observer_dot,
+ self.observer,
+ self.lighthouses,
+ self.lights,
+ )
+ return group
+
+ def setup_lighthouses_and_observer(self):
+ self.add(*self.get_circle_group())
+
+ # Numerical results
+
+ def get_radius(self):
+ return self.circle.get_width() / 2.0
+
+ def get_distance_product(self, fraction=None):
+ radius = self.get_radius()
+ observer_point = self.get_observer_point(fraction)
+ distances = [
+ np.linalg.norm(point - observer_point) / radius
+ for point in self.get_lh_points()
+ ]
+ return reduce(op.mul, distances, 1.0)
+
+ # Animating methods
+
+ def add_numeric_distance_labels(self, show_line_creation=True):
+ anims = []
+ if not hasattr(self, "distance_lines"):
+ self.get_distance_lines()
+ if not hasattr(self, "numeric_distance_labels"):
+ self.get_numeric_distance_labels()
+ if show_line_creation:
+ anims.append(LaggedStart(ShowCreation, self.distance_lines))
+ anims.append(LaggedStart(FadeIn, self.numeric_distance_labels))
+
+ self.play(*anims)
+
+ def show_distance_product_in_column(self, column_top=None):
+ if not hasattr(self, "numeric_distance_labels"):
+ self.get_numeric_distance_labels()
+ if column_top is None:
+ column_top = self.default_product_column_top
+ labels = self.numeric_distance_labels
+ stacked_labels = labels.copy()
+ for label in stacked_labels:
+ label.rotate(-label.angle)
+ label.scale_to_fit_height(self.numeric_distance_label_height)
+ stacked_labels.arrange_submobjects(DOWN)
+ stacked_labels.move_to(column_top, UP)
+
+ h_line = Line(LEFT, RIGHT)
+ h_line.scale_to_fit_width(1.5 * stacked_labels.get_width())
+ h_line.next_to(stacked_labels, DOWN, aligned_edge=RIGHT)
+ times = TexMobject("\\times")
+ times.next_to(h_line, UP, SMALL_BUFF, aligned_edge=LEFT)
+
+ product_decimal = DecimalNumber(
+ self.get_distance_product(),
+ num_decimal_points=3,
+ show_ellipsis=True
+ )
+ product_decimal.scale_to_fit_height(self.numeric_distance_label_height)
+ product_decimal.next_to(h_line, DOWN)
+ product_decimal.align_to(stacked_labels, RIGHT)
+ product_decimal.set_color(BLUE)
+
+ self.play(ReplacementTransform(labels.copy(), stacked_labels))
+ self.play(
+ ShowCreation(h_line),
+ Write(times)
+ )
+ self.play(
+ ReplacementTransform(
+ stacked_labels.copy(),
+ VGroup(product_decimal)
+ )
+ )
+
+
+class IntroduceDistanceProduct(DistanceProductScene):
+ CONFIG = {
+ "ambient_light_config": {
# "num_levels": 10,
- "light_radius": 10,
# "radius": 1,
- "max_opacity": 0.4,
"color": YELLOW,
},
- "num_lighthouses": 6,
- "circle_radius": 3,
- "observer_color": MAROON_B,
- "lighthouse_height": 0.5,
- "camera_class": MovingCamera,
}
def construct(self):
@@ -29,12 +244,10 @@ class IntroduceDistanceProduct(MovingCameraScene):
self.show_sum_of_inverse_squares()
def draw_circle_with_points(self):
- circle = Circle(color=BLUE)
- circle.scale(self.circle_radius)
+ circle = self.circle
lh_dots = self.lh_dots = VGroup(*[
- Dot().move_to(circle.point_from_proportion(alpha))
- for alpha in np.arange(0, 1, 1.0 / self.num_lighthouses)
+ Dot(point) for point in self.get_lh_points()
])
lh_dot_arrows = VGroup(*[
Arrow(*[
@@ -47,8 +260,7 @@ class IntroduceDistanceProduct(MovingCameraScene):
evenly_space_dots_label.scale_to_fit_width(0.5 * circle.get_width())
evenly_space_dots_label.move_to(circle)
- special_dot = self.special_dot = Dot(color=self.observer_color)
- special_dot.move_to(circle.point_from_proportion(0.04))
+ special_dot = self.special_dot = self.get_observer_dot()
special_dot_arrow = Vector(DL)
special_dot_arrow.next_to(special_dot, UR, SMALL_BUFF)
special_dot_arrow.match_color(special_dot)
@@ -77,24 +289,13 @@ class IntroduceDistanceProduct(MovingCameraScene):
self.play(FadeOut(VGroup(special_dot_arrow, special_dot_label)))
def turn_into_lighthouses_and_observer(self):
- lighthouses = self.lighthouses = VGroup()
- lights = self.lights = VGroup()
- for dot in self.lh_dots:
- point = dot.get_center()
- lighthouse = Lighthouse()
- lighthouse.scale_to_fit_height(self.lighthouse_height)
- lighthouse.move_to(point)
- lighthouses.add(lighthouse)
+ lighthouses = self.get_lighthouses()
+ lights = self.get_lights()
- light = AmbientLight(
- source_point=VectorizedPoint(point),
- **self.ambient_light_config
- )
- lights.add(light)
-
- observer = self.observer = PiCreature(color=self.observer_color)
- observer.flip()
- observer.move_to(self.special_dot)
+ observer = self.get_observer()
+ observer.save_state()
+ observer.scale_to_fit_height(2)
+ observer.change_mode("happy")
observer.to_edge(RIGHT)
self.play(
@@ -104,23 +305,12 @@ class IntroduceDistanceProduct(MovingCameraScene):
)
self.wait()
self.play(FadeIn(observer))
- self.play(
- observer.scale_to_fit_height, 0.25,
- observer.next_to, self.special_dot, RIGHT, 0.5 * SMALL_BUFF,
- )
+ self.play(observer.restore)
self.wait()
def show_sum_of_inverse_squares(self):
- lines = VGroup(*[
- Line(self.special_dot.get_center(), dot.get_center())
- for dot in self.lh_dots
- ])
- labels = VGroup(*[TexMobject("d_%d" % i) for i in range(len(lines))])
- for label, line in zip(labels, lines):
- label.scale(0.75)
- vect = rotate_vector(line.get_vector(), TAU / 4)
- vect *= 2 * SMALL_BUFF / np.linalg.norm(vect)
- label.move_to(line.get_center() + vect)
+ lines = self.get_distance_lines()
+ labels = self.get_symbolic_distance_labels()
sum_of_inverse_squares = TexMobject(*it.chain(*[
["{1", "\\over", "(", "d_%d" % i, ")", "^2}", "+"]
@@ -182,7 +372,7 @@ class IntroduceDistanceProduct(MovingCameraScene):
labels[:-1].copy(),
d_terms[:-1],
),
- circle_group.scale, 0.8, {"about_edge": DOWN}
+ circle_group.scale, 0.8, {"about_point": FRAME_Y_RADIUS * DOWN}
)
self.wait()
self.play(LaggedStart(
@@ -195,9 +385,10 @@ class IntroduceDistanceProduct(MovingCameraScene):
# Mention useful just to basel problem
circle_group.save_state()
+ v_point = VectorizedPoint(FRAME_X_RADIUS * LEFT + FRAME_Y_RADIUS * DOWN)
self.play(
- circle_group.scale, 0.5,
- circle_group.to_corner, DL,
+ circle_group.next_to, v_point, UR, {"submobject_to_align": self.circle},
+ circle_group.scale, 0.5, {"about_point": v_point.get_center()},
)
self.play(
GrowFromCenter(brace),
@@ -230,7 +421,9 @@ class IntroduceDistanceProduct(MovingCameraScene):
wallis_product.next_to, basel_sum, UP, {"aligned_edge": RIGHT},
)
self.play(
- d_terms.shift, d_terms.get_height() * UP / 2,
+ d_terms.shift, 0.75 * d_terms.get_height() * UP,
+ d_terms.set_color, PRODUCT_COLOR,
+ light_rings.set_fill, PRODUCT_COLOR,
*[
FadeOut(mob)
for mob in sum_of_inverse_squares
@@ -240,7 +433,7 @@ class IntroduceDistanceProduct(MovingCameraScene):
self.wait()
self.play(
FadeOut(plusses),
- d_terms.arrange_submobjects, RIGHT, 0.5 * SMALL_BUFF,
+ d_terms.arrange_submobjects, RIGHT, 0.25 * SMALL_BUFF,
d_terms.move_to, sum_of_inverse_squares, DOWN,
)
self.wait()
@@ -268,6 +461,182 @@ class IntroduceDistanceProduct(MovingCameraScene):
self.wait()
+class Lemma1(DistanceProductScene):
+ CONFIG = {
+ "circle_radius": 2.5,
+ "observer_fraction": 0.5,
+ # "ambient_light_config": {
+ # "num_levels": 5,
+ # "radius": 1,
+ # },
+ "lighthouse_height": 0.25,
+ "lemma_text": "distance product = 2",
+ }
+
+ def construct(self):
+ self.add_title()
+ self.add_circle_group()
+ self.state_lemma_premise()
+ self.show_product()
+
+ def add_title(self):
+ title = self.title = TextMobject("Two lemmas:")
+ title.set_color(YELLOW)
+ title.to_edge(UP, buff=MED_SMALL_BUFF)
+ self.add(title)
+
+ def add_circle_group(self):
+ self.circle.to_corner(DL)
+ circle_group = self.get_circle_group()
+ self.play(LaggedStart(FadeIn, VGroup(*circle_group.family_members_with_points())))
+
+ def state_lemma_premise(self):
+ premise = TextMobject("Lemma 1: If observer is halfway between lighthouses,")
+ self.premise = premise
+ premise.next_to(self.title, DOWN)
+
+ frac = 1.0 / self.num_lighthouses
+ arc1, arc2 = arcs = VGroup(VMobject(), VMobject())
+ arc1.pointwise_become_partial(self.circle, 0, frac / 2)
+ arc2.pointwise_become_partial(self.circle, frac / 2, frac)
+ arc1.reverse_points()
+ arcs.set_stroke(YELLOW, 5)
+ show_arcs = ShowCreationThenDestruction(
+ arcs,
+ submobject_mode="all_at_once",
+ run_time=2,
+ )
+
+ self.play(Write(premise), show_arcs, run_time=2)
+ self.wait()
+ self.play(show_arcs)
+ self.wait()
+
+ def show_product(self):
+ lemma = TextMobject(self.lemma_text)
+ lemma.set_color(BLUE)
+ lemma.next_to(self.premise, DOWN)
+ self.add_numeric_distance_labels()
+ self.play(Write(lemma, run_time=1))
+ self.show_distance_product_in_column()
+ self.wait()
+
+
+class Lemma1With7Lighthouses(Lemma1):
+ CONFIG = {
+ "num_lighthouses": 7,
+ }
+
+
+class Lemma1With8Lighthouses(Lemma1):
+ CONFIG = {
+ "num_lighthouses": 8,
+ }
+
+
+class Lemma1With9Lighthouses(Lemma1):
+ CONFIG = {
+ "num_lighthouses": 9,
+ }
+
+
+class Lemma2(Lemma1):
+ CONFIG = {
+ # "ambient_light_config": CHEAP_AMBIENT_LIGHT_CONFIG,
+ "lemma_text": "distance product = \\# Initial lighthouses"
+ }
+
+ def construct(self):
+ self.add_title()
+ self.add_circle_group()
+ self.state_lemma_premise()
+ self.replace_first_lighthouse()
+ self.show_product()
+
+ def state_lemma_premise(self):
+ premise = self.premise = TextMobject(
+ "If the observer replaces a lighthouse,"
+ )
+ premise.next_to(self.title, DOWN)
+
+ self.play(Write(premise, run_time=1))
+
+ def replace_first_lighthouse(self):
+ dot = self.observer_dot
+ observer_anim = MaintainPositionRelativeTo(self.observer, dot)
+ lighthouse_group = VGroup(self.lighthouses[0], self.lights[0])
+ point = self.get_lh_points()[0]
+
+ self.play(
+ lighthouse_group.shift, 5 * RIGHT,
+ lighthouse_group.fade, 1,
+ run_time=1.5,
+ rate_func=running_start,
+ remover=True,
+ )
+ self.play(
+ dot.move_to, point,
+ observer_anim,
+ path_arc=(-120 * DEGREES),
+ )
+ self.wait()
+
+ self.ignored_lighthouse_indices = [0]
+ self.observer_fraction = 0
+ for group in self.lighthouses, self.lights:
+ self.lighthouses.submobjects.pop(0)
+
+
+class Lemma2With7Lighthouses(Lemma2):
+ CONFIG = {
+ "num_lighthouses": 7,
+ }
+
+
+class Lemma2With8Lighthouses(Lemma2):
+ CONFIG = {
+ "num_lighthouses": 8,
+ }
+
+
+class Lemma2With9Lighthouses(Lemma2):
+ CONFIG = {
+ "num_lighthouses": 9,
+ }
+
+
+class FromGeometryToAlgebra(DistanceProductScene):
+ CONFIG = {
+ "num_lighthouses": 7,
+ "ambient_light_config": CHEAP_AMBIENT_LIGHT_CONFIG,
+ }
+
+ def construct(self):
+ self.setup_lights()
+ self.point_out_evenly_spaced()
+ self.transition_to_complex_plane()
+ self.name_roots_of_unity()
+
+ def setup_lights(self):
+ lights = self.get_lights()
+ circle = self.circle
+
+ self.add(circle, lights)
+
+ def point_out_evenly_spaced(self):
+ pass
+
+ def transition_to_complex_plane(self):
+ pass
+
+ def name_roots_of_unity(self):
+ pass
+
+
+
+
+
+