Пример #1
0
    def show_value_at_zero(self):
        arrow, x_equals_0 = ax0_group = self.get_arrow_x_equals_0_group()
        ax0_group.next_to(
            self.cosine_label, RIGHT,
            align_using_submobjects = True
        )
        one = TexMobject("1")
        one.next_to(arrow, RIGHT)
        one.save_state()
        one.move_to(self.cosine_label)
        one.set_fill(opacity = 0)

        v_line = self.get_vertical_line_to_graph(
            0, self.cosine_graph,
            line_class = DashedLine, 
            color = YELLOW
        )

        self.play(ShowCreation(v_line))
        self.play(
            ShowCreation(arrow),
            Write(x_equals_0, run_time = 2)
        )
        self.play(one.restore)
        self.dither()

        self.v_line = v_line
        self.equals_one_group = VGroup(arrow, x_equals_0, one)
Пример #2
0
    def write_bayes_rule(self):
        words = self.bayes_rule_words
        words_rect = SurroundingRectangle(words)
        rule = TexMobject("P(", "S", "|", "+", ")", "=", "P(", "S", ")", "{P(",
                          "+", "|", "S", ")", "\\over", "P(", "+", ")}")
        rule.highlight_by_tex("S", SICKLY_GREEN)
        rule.highlight_by_tex("+", YELLOW)
        rule.to_corner(UP + RIGHT)
        rule_rect = SurroundingRectangle(rule)
        rule_rect.highlight(BLUE)
        rule.save_state()
        rule.replace(words_rect)
        rule.scale_in_place(0.9)
        rule.set_fill(opacity=0)

        self.play(ShowCreation(words_rect))
        self.play(ReplacementTransform(words_rect, rule_rect),
                  rule.restore,
                  run_time=2)
        self.dither(3)
Пример #3
0
    def construct(self):

        num = 5
        ordinals_cnt_base = OrdinalFiniteProd(OrdinalOmega,
                                              num,
                                              x1=-4 + num * 2.5)

        ordinals_cnt = VGroup(
            [VGroup(ordinals_cnt_base[:i]).copy() for i in range(1, num + 1)])
        ordinals_cnt.save_state()
        ordinals_cnt.arrange_submobjects(DOWN, center=False, coor_mask=Y_MASK)
        ordinals_cnt.to_edge(UP)

        self.play(ShowCreation(ordinals_cnt))

        #self.wait_to(7)
        self.dither()
        self.play(ordinals_cnt.restore)

        self.remove(ordinals_cnt)
        self.add(ordinals_cnt_base)

        omega1 = Omega1()
        brace = BraceDesc(omega1, "\\omega_1", DOWN)

        omega1.line.save_state()
        omega1.line.behind_edge(RIGHT)

        omega1_bars_src = make_ordinal_power(2)
        omega1_bars_src.next_to(ordinals_cnt_base)
        omega1_bars_src.add_to_back(*ordinals_cnt_base)

        brace.desc.highlight(BLUE)
        brace.save_state()
        brace.shift_brace(omega1_bars_src)
        brace.highlight(BLACK)

        self.play(
            brace.restore,
            omega1.line.restore,
            ReplacementTransform(omega1_bars_src, omega1.bars),
        )

        #self.wait_to(11)
        self.dither()

        aleph1 = TexMobject("\\aleph_1", "=|", "\omega_1", "|")
        aleph1[2].highlight(BLUE)
        aleph1[0].highlight(RED)
        aleph1.shift(brace.desc.get_center() - aleph1[2].get_center())
        aleph1.remove(aleph1[2])

        self.play(Write(aleph1))
        #self.wait_to(15)
        self.dither()

        ordinals_a1 = VGroup([omega1.copy() for _ in range(num)])

        aleph1[0].save_state()
        aleph1[0].next_to(omega1, LEFT, coor_mask=X_MASK)
        self.play(
            omega1.to_edge,
            UP,
            FadeOut(VGroup(brace, aleph1[1:])),
            MoveFromSaved(aleph1[0]),
        )
        #self.wait_to(18.5)
        self.dither()
        aleph1 = aleph1[0]

        scale_center = np.array(ordinals_a1[0].line.get_start())
        for i, o in enumerate(ordinals_a1):
            o.line.scale(1 + i * 0.2, about_point=scale_center)

        ordinals_a1_lines_dest = VGroup([o.line for o in ordinals_a1]).copy()
        ordinals_a1_bars_dest = VGroup([o.bars for o in ordinals_a1]).copy()
        ordinals_a1.arrange_submobjects(DOWN, False, coor_mask=Y_MASK)
        ordinals_a1.to_edge(UP)
        ordinals_a1_lines = VGroup([o.line for o in ordinals_a1])
        ordinals_a1_bars = VGroup([o.bars for o in ordinals_a1])

        self.remove(omega1)
        self.add(ordinals_a1[0])
        self.play(FadeIn(VGroup(ordinals_a1[1:])))
        self.play(
            Transform(ordinals_a1_lines, ordinals_a1_lines_dest),
            Transform(ordinals_a1_bars, ordinals_a1_bars_dest),
        )
        self.remove(*ordinals_a1[:-1])
        omega2_src = ordinals_a1[-1]
        omega2 = LongOrdinal(ordinal_end=0.3, line_start=0.2)

        brace = BraceDesc(omega2, "\\omega_2", DOWN)
        brace.desc.highlight(BLUE)
        brace.save_state()
        brace.shift_brace(omega2_src)
        brace.highlight(BLACK)

        self.play(
            brace.restore,
            ReplacementTransform(omega2_src, omega2),
        )

        #self.wait_to(24.5)
        self.dither()

        aleph2 = TexMobject("\\aleph_2", "=|", "\omega_2", "|")
        aleph2[2].highlight(BLUE)
        aleph2[0].highlight(RED)
        aleph2.shift(brace.desc.get_center() - aleph2[2].get_center())
        aleph2.remove(aleph2[2])

        self.play(Write(aleph2))
        #self.wait_to(28)
        self.dither()

        ordinal_fin = OrdinalFinite(7, x1=SPACE_WIDTH + 1).highlight(BLUE)
        ord_labels = VGroup([
            TexMobject("\\omega_{}".format(i + 1)).highlight(BLUE).next_to(
                bar, UP) for i, bar in enumerate(ordinal_fin[:4])
        ])
        card_labels = VGroup([
            TexMobject("\\aleph_{}".format(i + 1)).highlight(RED).next_to(
                bar, DOWN) for i, bar in enumerate(ordinal_fin[:4])
        ])

        self.play(
            FadeOut(VGroup(aleph2[1:], brace, omega2)),
            ReplacementTransform(aleph1, card_labels[0]),
            ReplacementTransform(aleph2[0], card_labels[1]),
        )

        for i, t in enumerate((29, 31, 35.5, 38)):
            #self.wait_to(t)
            self.play(FadeIn(ord_labels[i]), ShowCreation(ordinal_fin[i]))
            if i >= 2: self.play(FadeIn(card_labels[i]))

        #self.wait_to(41)
        self.play(ShowCreation(VGroup(ordinal_fin[4:], rate_func=rush_into)))

        omega = OrdinalOmega().highlight(BLUE)
        omega_src = omega.copy()
        omega_src.next_to(ordinal_fin, buff=1)
        omega_src.add_to_back(*ordinal_fin)

        label1 = VGroup(ord_labels[0], card_labels[0])
        labels_to_fade = VGroup(list(zip(ord_labels[1:], card_labels[1:])))
        labels_to_fade.save_state()
        for l, bar in zip(labels_to_fade, omega[1:4]):
            l.move_to(bar, coor_mask=X_MASK)
            l.highlight(BLACK)

        limit_bar = omega[0].copy().next_to(omega)
        limit_lord = TexMobject("\\omega_\\omega").highlight(BLUE).next_to(
            limit_bar, UP)
        limit_lcard = TexMobject("\\aleph_\\omega").highlight(RED).next_to(
            limit_bar, DOWN)
        limit_g = VGroup(limit_bar, limit_lord, limit_lcard)

        limit_g.next_to(omega, coor_mask=X_MASK)
        limit_g.save_state()
        limit_g.next_to(omega_src, coor_mask=X_MASK)

        self.play(
            MoveFromSaved(labels_to_fade),
            ReplacementTransform(omega_src, omega),
            Animation(label1),
            limit_g.restore,
        )
        self.remove(labels_to_fade)
        #self.wait_to(52)

        plus1_bar = limit_bar.copy()
        plus1_label = TexMobject("\\omega_{\\omega+1}").highlight(
            BLUE).next_to(plus1_bar, UP)
        plus1_g = VGroup(plus1_bar, plus1_label)
        plus1_g.next_to(limit_g, coor_mask=X_MASK, buff=0.5)

        self.play(FadeIn(plus1_label), ShowCreation(plus1_bar))
        #self.wait_to(55)

        omega_pow = make_ordinal_power(2, q=(0.8, 0.9, 0.9)).highlight(BLUE)
        omega_pow_src = omega_pow.copy()
        omega_pow_src.behind_edge(RIGHT)
        omega_pow_src[0].add_to_back(limit_bar, plus1_bar)
        omega_pow_src.add_to_back(omega)

        limit_g.remove(limit_bar)
        limit_g.save_state()
        plus1_label.save_state()

        limit_g.move_to(omega_pow[1][0], coor_mask=X_MASK)
        plus1_label.move_to(omega_pow[1][1], coor_mask=X_MASK).highlight(BLACK)

        pow_bar = limit_bar.copy()
        pow_label = TexMobject("\\omega_{\\omega\\cdot\\omega}").highlight(
            BLUE).next_to(pow_bar, UP)
        pow_g = VGroup(pow_bar, pow_label)
        pow_g.next_to(omega_pow, coor_mask=X_MASK, buff=-.2)
        pow_g.save_state()
        pow_g.next_to(omega_pow_src, coor_mask=X_MASK)

        self.play(
            MoveFromSaved(plus1_label),
            ReplacementTransform(omega_pow_src, omega_pow),
            MoveFromSaved(limit_g),
            pow_g.restore,
        )
        self.remove(plus1_label)

        #self.wait_to(59)
        self.dither()

        labels_to_fade = VGroup(label1, limit_g, pow_label)
        labels_to_fade.save_state()
        labels_to_fade.highlight(BLACK)

        omega1 = Omega1(color=BLUE)
        omega1_bar = pow_bar.copy()
        omega1_label = TexMobject("\\omega_{\\omega_1}").highlight(
            BLUE).next_to(omega1_bar, UP)
        omega1_g = VGroup(omega1_bar, omega1_label)
        omega1_g.shift(omega1.line.get_end() - omega1_bar.get_center())
        omega1_g.add(omega1.line)
        omega1_g.save_state()
        omega1_g.behind_edge(RIGHT)

        limit_g.move_to(omega1.bars[1][0], coor_mask=X_MASK)
        pow_label.move_to(omega1.bars[-1], coor_mask=X_MASK)
        pow_bar.save_state()
        pow_bar.scale(0)
        pow_bar.set_stroke(width=0)
        pow_bar.move_to(omega1.bars[-1])

        self.play(
            MoveFromSaved(labels_to_fade, remover=True),
            omega1_g.restore,
            MoveFromSaved(pow_bar, remover=True),
            ReplacementTransform(omega_pow, omega1.bars),
        )
        #self.wait_to(60+7.5)
        self.dither()

        ordinal_fin = OrdinalFinite(6, x1=SPACE_WIDTH + 1).highlight(BLUE)
        omega1.save_state()
        omega1.stretch_about_point(0, 0, ordinal_fin[0].get_center())

        labels = VGroup([
            TexMobject((i + 1) * "\\omega_{" + "\\omega_1" +
                       (i + 1) * "}").next_to(bar, UP)
            for i, bar in enumerate(ordinal_fin[:3])
        ])
        labels.highlight(BLUE)

        next_bar = VGroup(labels[1], ordinal_fin[1])
        next_bar.save_state()
        next_bar.shift(8 * RIGHT)

        self.play(
            MoveFromSaved(omega1, remover=True),
            next_bar.restore,
            ReplacementTransform(omega1_label, labels[0]),
            ReplacementTransform(omega1_bar, ordinal_fin[0]),
        )
        #self.wait_to(60+11)
        self.play(FadeIn(labels[2]), ShowCreation(ordinal_fin[2]))
        #self.wait_to(60+13)
        self.play(ShowCreation(VGroup(ordinal_fin[3:]), rate_func=rush_into))
        #self.wait_to(60+21.5)
        self.dither(2)

        conversation = Conversation(self)
        conversation.add_bubble("What about the union of all the ordinals?")

        self.play(FadeOut(VGroup(labels, ordinal_fin)),
                  Animation(conversation.dialog))