Bernoulli's method

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

The method uses a sequence of numbers that follow a pattern, called a linear recurrence. By looking at the relationship between these numbers, we can get closer and closer to the answer we are looking for.

Although Bernoulli's method is not the fastest because it gets closer to the answer slowly, it is still important. It was one of the first ways people used to solve these kinds of problems, and it shows a nice link between patterns of numbers and solving equations. Sometimes, it can help give a good starting point for even better methods, like Newton's method, to find the exact answer.

History

Bernoulli's method was first introduced by the Swiss-French mathematician and physicist Daniel Bernoulli in 1728. He noticed a pattern in series created from polynomial coefficients that related to a root of the polynomial, though 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 influenced the development of newer algorithms.

The method

Bernoulli's method is a way to find a special solution, 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 larger than all the others in size.

To use this method, you start with some basic numbers and then follow a special rule to create a list of new numbers. By looking at how these new numbers change from one to the next, you can find the largest root of the polynomial. This works whether the root is a simple number or a more complicated one with imaginary parts.

Derivation of the method

The method looks at a special kind of math problem involving sequences. These sequences follow rules based on polynomials, which are expressions made from adding and multiplying numbers and powers of a variable.

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

Extensions

Bernoulli's method helps find a special answer in math problems, but it only works in certain cases. There are ways to change the method to work better. For example, if you want to find 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 are useful for getting good starting points for other math tools that find answers.

Example

Bernoulli's method is a way to find important solutions to 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 sequence 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 reliable way to find important solutions in math.

Comparison with other methods

Bernoulli's method has some unique features when 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 that make up 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: Usually finding very large roots can be tricky, 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 root-finding tools and can be adjusted to work in more advanced math areas. Some improved versions of Bernoulli's method can find complex roots and handle multiple roots better.

The method is related to another technique called the Power method when used with special matrices. New technologies have allowed Bernoulli's method to run in parallel, making it faster. It has also been expanded to find important points in special math functions and to improve other calculation methods. 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 faster.

Code

Bernoulli's method can be used in the Python programming language to find a special solution of a 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 adjust the starting numbers at the beginning. This small change does not change how the method finds the answer. For even faster results, you can use a special trick called Aitken's delta-squared process.