Bernoulli's method

Bernoulli's method is a special way to solve some math problems. It is named after Daniel Bernoulli. This method helps find the biggest answer, called a "root," of a certain type of math expression known as a univariate polynomial. It works best when there is one answer that is larger than all others.

The method uses a sequence of numbers that follow a pattern, called a linear recurrence. By studying how these numbers relate to each other, we can get closer to the answer we want.

Even though Bernoulli's method is not the quickest because it approaches the answer slowly, it is still very important. It was one of the first ways people used to solve these problems. It shows a nice connection between number patterns and solving equations. Sometimes, it can help give a good starting point for other, more exact methods, like Newton's method.

History

Bernoulli's method was first introduced by the Swiss-French mathematician and physicist Daniel Bernoulli in 1728. He noticed a pattern in numbers that helped find a root of a polynomial, but he did not explain why it worked. Later, the mathematician Leonhard Euler explained why the method works in 1748. Since then, Bernoulli's method has helped create new algorithms.

The method

Bernoulli's method is a way to find a special answer, or "root," of a math expression called a polynomial. This method was named after Daniel Bernoulli. It works when there is one root that is bigger than all the others.

To use this method, you start with some basic numbers and then follow a special rule to make a list of new numbers. By watching how these new numbers change, you can find the biggest root of the polynomial. This works even if the root is a simple number or a more tricky one with imaginary parts.

Derivation of the method

The method looks at special math problems with sequences. These sequences follow rules based on polynomials. Polynomials are made by adding and multiplying numbers and powers of a variable.

When we see how each number in the sequence relates to the next, we find a pattern. If one number is bigger than all the others, the relationship between numbers will match that biggest number. This helps us solve the original problem.

Extensions

Bernoulli's method helps find a special answer in math problems, but it only works in some cases. There are ways to change the method to work better. For example, if you need a different answer, you can use a special version of the problem and then flip the answer around.

Some smart ideas were added to make the method faster or to find all the answers at once. Even though these changes can sometimes be tricky, they help give good starting points for other math tools that find answers.

Example

Bernoulli's method is a way to solve math problems with equations. In this example, we use a simple equation to show how the method works.

The equation looks like this: ( z^2 - z - 1 = 0 ). We start with two numbers, 0 and 1, and follow a special rule to create a new list of numbers. Each new number is the sum of the two numbers before it.

As we keep doing this, the numbers get closer and closer to a special value: ( \frac{1 + \sqrt{5}}{2} ), which is about 1.618. This number is known as the Golden ratio. It is the biggest solution to our equation.

Even if we start with different numbers, we still end up at the same special value. This shows that Bernoulli's method is a good way to find important solutions in math.

Comparison with other methods

Bernoulli's method has some special features compared to other ways of finding the roots of equations.

Advantages

• No initial guess needed: Methods like Newton's method, Secant method, and Halley's method need a starting value to begin. Bernoulli's method only needs the numbers in the equation, so there’s no need to guess where to start.
• No need for special math rules: Some methods need to use rules about how numbers change, but Bernoulli's method does not need this extra step.
• Finds the biggest root naturally: Finding very large roots can be hard, but Bernoulli's method can handle this well.

Limitations

• Works slowly: Some people say Bernoulli's method takes a long time to get the right answer, while others suggest using it along with faster methods to improve the speed.
• Finds one root at a time: Bernoulli's method finds one answer at a time, unlike some other methods that can find many answers together. Special tricks can help with this.
• Can struggle with certain roots: When there are several very similar answers, the method can slow down, but there are ways to make it work better.

Modern applications

Bernoulli's method is still useful today in computing. It helps find starting points for other tools that search for answers and can be changed to work in more advanced math. Some newer versions of Bernoulli's method can find complicated answers and handle multiple answers better.

The method is related to another technique called the Power method when used with special tables of numbers. New technologies have made Bernoulli's method run at the same time in many places, making it faster. It has also been used to find important points in special math functions and to make other calculation methods better. The method is included in some free math tool libraries and was once used on early computers, though other methods like Newton's method are often quicker.

Code

Bernoulli's method can be used in the Python programming language to solve a special kind of math problem called a polynomial.

Here is a simple way to write this method in Python:

def bernoulli_method(c, eps=1e-8, max_iter=60):
    """
    Bernoulli's method for finding the dominant root of a polynomial.

    Parameters
    ----------
    c : list
        List of polynomial coefficients in descending order of powers.
        For example, if p(x) = x^2 - x - 1, c = [1.0, -1.0, -1.0]
    eps : float, optional
        Convergence tolerance. Default is 1e-8.
    max_iter : int, optional
        Maximum number of iterations. Default is 60.

    Returns
    -------
    float or complex
        The dominant root of the polynomial if found, otherwise float('nan').

    Examples
    --------
    >>> bernoulli_method([1.0, -1.0, -1.0])  # Golden ratio example
    1.6180339901755971
    >>> bernoulli_method([1.0, -3.0, 2.0])   # x^2 - 3x + 2 = (x - 2)(x - 1)
    2.0000000074505806
    """
    n = len(c)
    x = [0.0] * (n - 2) + [1.0]  # Initialize with zeros and a 1.0
    q = []

    for i in range(n - 1, max_iter + n):
        # Apply the recurrence relation: x_n = -(a_1*x_{n-1} + ... + a_d*x_{n-d})/a_0
        x.append(-sum(c[k] * x[-k + i] for k in range(1, n)) / c)
        q.append(x[-1] / x[-2])  # Quotient of two successive x terms q_n = x_{n+1} / x_n

        # Check for convergence after two quotient values
        if len(q) >= 2 and abs(q[-1] - q[-2]) <= eps:
            return q[-1]  # Return the last computed quotient

    return float("nan")  # No convergence within max_iter

To make this method work faster, you can change the starting numbers. This small change does not affect how the method finds the answer. For even faster results, you can use a special trick called Aitken's delta-squared process.