# Problems of the Week

Contribute a problem

# 2017-09-25 Advanced

If half of the earth is blown away by the impact of a comet, what happens to the orbit of the moon? During impact After impact


Details and Assumptions:

• The mass of the earth $M$ is simply halved by the impact, without the fragments interacting with the moon of mass $m.$
• Before the impact, the moon's orbit is a perfect circle with radius $r_0.$
• $M \gg m,$ so the moon can hardly affect the motion of the earth.
• Both the energy $E = \frac{1}{2} m v^2 + V(r)$ and the angular momentum $L = m r^2 \dot \phi$ of the moon are preserved, where $r$ is an arbitrary distance between the earth and moon after the impact.
• The gravitational potential energy of the earth and moon system reads $V(r) = - G \frac{M m}{r},$ where $G$ is the gravitational constant. To turn a three-story pyramid of coins $($with $1 + 2 + 3 = 6$ coins$)$ upside down, we only need to move 2 coins: moving the bottom left and bottom right coins next to the top coin.

Now, what if there are $1 + 2 + 3 +\cdots+100=5050$ coins instead? What is the minimum number of coins we have to move in order to turn this huge, 100-story pyramid upside down?

Bonus: Generalize this for a pyramid of $1+2+3+\cdots+n$ coins.

Forest fires are a fact of life on a planet covered in trees. Some are minor occurrences, burning over a few acres before being snuffed out without event, while others take hold of hundreds of square miles, rage for months and destroy tremendous swaths of forest and property. Knowing which course a wildfire will take is difficult and involves a number of factors that are hard to model, but there are fundamental questions we might expect to be insensitive to the details such as

• How long will a typical fire burn?
• What fraction of a typical forest will be destroyed?
• Are there any structural features we can exploit to reduce the severity of forest fires?

Here, we're going to build a simple model that we can interrogate in a controlled way.

1. First of all, we're going to model the forest as an $L\times L$ lattice, at each point of which a tree can exist or not.
2. Next, we're going to assume that trees are placed at lattice points with probability $\rho,$ so that the expected number of trees in the forest is $\langle \textrm{Trees}\rangle = \rho L^2.$
3. Finally, any given tree burns for one timestep, and if a tree at point $\left(i, j\right)$ is on fire at time $t,$ all nearest-neighbor trees will be on fire at time $t+1.$

We start the fire by randomly lighting one tree at time zero.

As we increase $\rho,$ the density of trees in the forest increases, as does the likelihood that trees form clusters. Therefore, we might expect that the extent and duration of the average forest fire varies as some function of $\rho.$

When $L=25,$ find $\rho_\textrm{max},$ the tree density at which the expected duration of the forest fire is maximal.


Note: The code environment below has a runtime limit of $\SI{10}{\second},$ so be judicious in how you measure the forest. There are three functions in the imported module available for your use: add_lists() which takes two lists of length two and returns their vector sum, dedupe_list() which takes a list of lists and returns its unique elements, and print_forest() which takes a forest lattice and returns a pretty print representation of the state of the forest. Diagram: At time $t=0,$ the tree at $\left(1,1\right)$ is lit on fire. At time $t=1$ the first tree is burned out and the fire has spread to the trees at $\left(1,0\right)$ and $\left(0,1\right)$.

import random
import numpy as np
import matplotlib.pyplot as plt
from brilliant import forest_fire_module as fire

def simulate(p, L):
# Initializes the lattice with a random placement of trees and a record of their status (burned or not burned)
lattice = [[(["Tree", "NotBurned"] if random.random() < p else ["Empty", None])
for i in range(L)]
for j in range(L)]

# Possible moves for the fire to make.
moves = [[1,0], [0,1], [-1,0], [0,-1]]

# Randomly select a tree from the forest to set on fire.
trees = [np.array([i, j])
for i in range(L)
for j in range(L)
if lattice[i][j] is "Tree"]
initial = random.choice(trees)

# Set its status to burned in the lattice.
lattice[initial][initial] = "Burned"

# Set counters for the number of burned trees and the total
# duration of the forest fire.
(burn_duration, trees_burned) = (1, 1)

# Initialize a list of all trees currently on fire.
burning = [initial]

print("The fire starts at", initial, "\n")
fire.print_forest(lattice)

# Fill this in with your code that propagates the fire across the forest.
# You may find the function print_forest (used above) useful in checking your dynamics.
# You may find the functions add_lists and dedupe_list useful as well.

return [burn_duration, trees_burned, len(trees)]

simulate(0.4, 25)

# # Once your simulation function is working, uncomment this code and use it to measure duration
# # as a function of tree density.
# probabilities = np.arange(0.1, 1., 0.1)
# mean_burned = []
# mean_durations = []
#
# for p in probabilities:
#   tmp_burn_durations = []
#   tmp_fractions_burned = []
#   for measurement in range(100):
#       [burn_duration, trees_burned, trees_total] = simulate(p, 25)
#       tmp_burn_durations.append(burn_duration)
#       tmp_fractions_burned.append(trees_burned / trees_total)
#   mean_burned.append(np.mean(tmp_fractions_burned))
#   mean_durations.append(np.mean(tmp_burn_durations))

# plt.plot(probabilities, mean_durations)
# plt.savefig('myplot.png')
Python 3
You need to be connected to run code

Find the smallest positive integer $k$ for which there exist positive reals $x_1, x_2, x_3, \ldots, x_k$ satisfying both \begin{aligned} x_1^2+x_2^2+ x_3^2 + \cdots+x_k^2 &< \dfrac{x_1+x_2+x_3+\cdots+x_k}{2} \ \ \text{and}\\\\ x_1+x_2+ x_3 + \cdots+x_k &< \dfrac{x_1^3+x_2^3+x_3^3+\cdots+x_k^3}{2}. \end{aligned}

$\Large \lim_{x\to\infty} { \large \dfrac \sum _{ l\le x }^{ }{ l \left\lfloor \frac { x }{ l } \right\rfloor } }{ { x }^{ 2 } } }$

Find the closed form of the above limit to 3 decimal places.


Notation: $\lfloor \cdot \rfloor$ denotes the floor function.

Bonus: Can you find a general formula for $\displaystyle \lim _{ x\to \infty}{ \frac {\sum _{ l\le x }^{ }{ {l}^{n} \left\lfloor \frac { x }{ l } \right\rfloor } }{ { x }^{ n+1 } } }$ for $n\ge 1?$

×

Problem Loading...

Note Loading...

Set Loading...