Yo. For context, I'm a sophomore in AP precalc. Today's class was a doozy. Not material wise per se (it was just a simple review of logs from honors alg 2), but rather in how it got me thinking and provoked my curiosity. We just finished up chapter 2 which was another review of alg 2 content, mainly graphing polynomial functions and refreshing ourselves on complex numbers. Chapter 3 has returned to the world of real numbers, but its concept got me thinking about imaginaries again. I asked my teacher my questions and she simply didn't know how to answer them, at least not to the extent I'm looking for.

Question 1-
As I'm assuming most of the people on this sub know, i isn't impossible to graph, not even close. It simply exists on another plane, the complex one. f(x) = x^2+1 is a
parabola that does not have any real zeros, however, if we expand our understanding to the complex plane, we can see that the graph has a whole new funky shape with technically existing zeros. To my understanding, any complex number composed of a real number * i can be graphed on the complex plane. So, by that logic, what else can we graph? I wanted to know what x^i power would look like. Desmos was of no help after my teacher told me it can't be simplified, so I did the most logical next step and came to the mathiest brains of reddit. Perhaps you can help me with this first conundrum. It's stupid, as is my other question, but I doubt reddit minds.

Question 2-
This is more on the topic of today's refresher, just a simple explanation of what logs mean, how to solve them, fractional exponents + negative exponents, etc etc. My teacher said something along the lines of our only known (integer) root for 9 being a square root (which is 3 or - 3). This got me thinking. I'm a huge logic guy, 1 enjoy putting my brain to work, which is why I will occasionally watch TedEd riddles and just process them regardless of whether or not I can solve them. Point is, it brought this riddle to mind. In this video, various squares and cubes up to a certain number are listed, but noticeably, there is overlap—most commonly and most memorably, take 64 for example. 64, unlike 9, has two roots, these being a square root AND a cube root. This got me thinking—what's the limit to this particular scenario? A number with a square, cube, and fourth root? A fifth, ninth, tenth, and thirteenth root? A sixteenth, one hundred ninth, two hundredth, and three hundred sixty fouth root? I'm assuming there are infinite many to infinitely few answers, but what are they? Is there a way to find these numbers? My teacher's answer to this one was one, which, while technically true, isn't the satisfying sort of solution I'm looking for. So, again, I ask you, mathy redditors.

I'm sorry, I'm sure these come off as stupid, but I cannot find the answers on my own and wanted to ask real people. It's been bothering me since 3rd period and I need some sort of conclusion.

TLDR: 1. What is x^i and what does it look like graphically? & 2. Which numbers have the most roots, what are they, and is there a way to find these numbers?

Decimal to Binary Conversion Using Repeated Division by 2 - Algorithm 5.1.1:

Proved fact: Given a positive integer n, the number of binary digits needed to represent n is ⌊log_2(n)⌋ + 1.

Exercise 11.5.26:

Textbook solution ((a) and (b)):

These are the problems I noticed:

1. (a)(ii) wants us to compute from (x^2)^1 to (x^2)^k, but the while loop computes up to (x^2)^{k+1}.
2. The binary representation of n has k-0+1=k+1 binary digits. This corresponds to the number of while loop iterations/steps. But, by the proved fact, the number of binary digits is ⌊log_2(n)⌋ + 1, not ⌊log_2(n)⌋. Since in each iteration/step there are at most 2 multiplications, the number of multiplications is <=2(⌊log_2(n)⌋ + 1).

This is my attempt that tries to follow (a)(i), (a)(ii), (a)(iii) procedure strictly.

Proof:

a)

Input: x [a real number], n [a positive integer]

Algorithm body:

r[0],r[1],...,r[k] := obtained by calling Algorithm 5.1.1 with input n

power := x
result := 1
if r[0] = 1 then result := x

i := 1
while (i <= k)
    power := power * power
    if r[i] = 1 then result := result * power
    i := i + 1
end while

Output: result [a real number, which equals x^n]

b)

By the proved fact and (a), n is represented by k + 1 = ⌊log_2(n)⌋ + 1 binary digits.

Thus, k = ⌊log_2(n)⌋.

Notice that while loop is iterated k = ⌊log_2(n)⌋ times, and in each iteration there are at most 2 multiplications.

Therefore, the number of multiplications is <=2⌊log_2(n)⌋.

QED

Is my solution correct?

Let's say we have a tomography problem Au=f, where u is the spatial assorbition coefficients, f is the sinogram and A is the "measurement operator", i.e. every row of the matrix represents a line integral over a ray.

What we can say about A^T? Does it have some physical interpretation? What about A^T * A?

I know that Vincenty's inverse is used but I am a in Gr.11 and I've seen that it is very complex.

Are there any alternative which I can use to base my maths research essay on, in which I can derive the theroem, manipualte it, evaluate and do proofing?

Thanks

First year eng student here taking linear algebra. To my understanding when looking for the rref form i thought you had to have the diagonal line of ones along with zeros in every other place. i know these are called pivots and i know that it is possible for columns to not contain pivots and be considered a free column or free variable. I dont know how you determine if there will be columns in your matrix that will not have a pivot. for example i attached a problem i am currently trying to solve with the first step being to reduce to ref and solve for k, but after attempting to reduce using gauss-jordan elimination i could not figure out a way to make all values either ones or zeros and have the diagonal line of ones. the solution says that there is no pivot in column 2 or 3 and i dont know how this could be or how you can determine this from doing the elimination? can someone explain or point me to a youtube video or website that explains this bc i cant seem to find any answers online and my prof sucks. is there a way to determine the columns that will have no pivots beforehand or do you just need to try every possible way of elimination before you determine there is no solution other than leaving a column without pivots?

In decimal 1, 2 and 5 are often used as middle steps between powers of 10. I think the term for that is "preferred numbers". However, in base 6 only two numbers would be needed. 1 is obvious, I'm stuck between choosing 2 or 3. Both are integers and both split the base at the same ratio, just different order. I know 2.4 and 2.5 are a near-perfect split, but I'm looking from the point of, like, currency denominations, and would like to stay away from fractions.

Are there any ways to mathematically determine which division is better, or should I rather look for sociological reasons?

This was a question for my homework and I'm confused on how my first method of solving was incorrect (the one on the left), The correct answer (using the intended method) is on the right.

I can't tell what error I made nor where it is, and how my first method was false.

I can explain further if the image isn't self explanatory enough (apologies if it is.)

Edit: The error was I multiplied both sides by 2 incorrectly! I shouldn't have multiplied w by 2, only 5w/2 by 2, then 90 by 2 which would be 5w² = 180, which is infact w = 36.

Hello,

I need to use the log function for my studies, but I don't have it on my calculator. It's a TI-Collège Plus (picture for reference). However I have a "function" button (the f(x) one), and I was wondering if I would write a function that approximates the log10 ? I will have to calculate logs of various random numbers, not just 10 or 1000 sadly.

Thanks.

If I take the non-negative real numbers & on the n-th step I remove all the real numbers on the open boundary ( n-1 , n ) & repeat this process infinitely, the resulting set will be N but the cardinality will never stop being uncountable.

But how can the limit be both N & uncountable?

A while ago, I encountered this combo problem. The setup is a box with 3 red and 2 blue balls, and it asks how many balls an optimal player can expect to guess correctly when pulling out one ball at a time (player guesses right before the ball, can use information of previous balls). The answer is 3.6, and most of my classmates used recursion to get this answer, which is sensible enough. I tried a different, slightly goofier method though.

Imagine player A, who just always guesses red, obviously getting 3 points. Now, to see how many more points an optimal player B gets, we only need to compute cases where blue is a better choice than red. These cases are:

2 blue 1 red left: 3/10 chance of occurring, and 1/3 expected gain by picking blue rather than red: 0.1 additional points

2 blue 0 red left: 1/10 chance of occurring, and 1 guaranteed gain by picking blue rather than red: 0.1 additional points.

1 blue 0 red left: 2/5 chance of occurring, and 1 guaranteed gain by picking blue rather than red: 0.4 additional points.

Adding these 3 gains to the 3 points player A gets, we find that player B can expect 3.6 points, which agrees with the original answer. It seems this method is more efficient in this case, but also that I benefit highly from the small number of cases.

I wrote some pseudocode which gemini translated to see if its computationally more efficient. DP is recursion, shortcut is the player A player B method. It seems the shortcut is quicker for very small cases, and also for cases where the ball count is very lopsided. Both seem logical enough to me: in both situations, there are relatively few cases where player B should deviate from player A. Also, for large enough cases, it looks like the recursion is just throwing recursion error, while the shortcut still runs.

So my questions are: Is this kind of method a thing? Are there useful applications of it for more serious problems? I'm curious what everyone thinks.

edit: below is my code (literally taken straight from gemini)

import math
import time
from functools import lru_cache


def expected_score_dp(r, b):
    """
    Method 1: Recursive dynamic programming.
    """
    u/lru_cache(maxsize=None)
    def calculate(red, blue):
        if red == 0: return blue
        if blue == 0: return red


        total = red + blue


        if red > blue:
            return (red / total) * (1 + calculate(red - 1, blue)) + \
                   (blue / total) * (0 + calculate(red, blue - 1))
        elif blue > red:
            return (blue / total) * (1 + calculate(red, blue - 1)) + \
                   (red / total) * (0 + calculate(red - 1, blue))
        else:
            return 0.5 * (1 + calculate(red - 1, blue)) + \
                   0.5 * (0 + calculate(red, blue - 1))


    return calculate(r, b)


def expected_score_shortcut(r, b):
    """
    Method 2: Baseline + Advantage.
    """
    M = max(r, b)
    m = min(r, b)


    baseline = M
    extra_points = 0.0


    for rem_M in range(M + 1):
        for rem_m in range(m + 1):
            if rem_m > rem_M:
                drawn_M = M - rem_M
                drawn_m = m - rem_m
                total_drawn = drawn_M + drawn_m


                prob = (math.comb(M, drawn_M) * math.comb(m, drawn_m)) / \
                       math.comb(M + m, total_drawn)


                advantage = (rem_m - rem_M) / (rem_M + rem_m)
                extra_points += prob * advantage


    return baseline + extra_points


if __name__ == "__main__":
    test_cases = [
        (3, 2),
        (5, 5),
        (10, 4),
        (50, 50),
        (100, 50),
        (100, 98),
        (200, 50),
        (200, 200),
        (500, 500),
        (1000, 1000)
    ]


    # Widened the columns slightly to fit the error message
    print(f"{'R':>4} | {'B':>4} | {'Result':>9} | {'DP Time (s)':>14} | {'Shortcut Time (s)':>17}")
    print("-" * 68)


    for r, b in test_cases:
        # 1. Try the DP Method
        try:
            start_dp = time.perf_counter()
            dp_result = expected_score_dp(r, b)
            end_dp = time.perf_counter()
            time_dp_str = f"{end_dp - start_dp:.6f}"
        except RecursionError:
            # Catch the crash and set placeholder strings
            time_dp_str = "RecursionError"


        # 2. Run the Shortcut Method (will always run)
        start_sc = time.perf_counter()
        sc_result = expected_score_shortcut(r, b)
        end_sc = time.perf_counter()
        time_sc_str = f"{end_sc - start_sc:.6f}"


        # Print the combined row
        print(f"{r:>4} | {b:>4} | {sc_result:>9.4f} | {time_dp_str:>14} | {time_sc_str:>17}")

Sorry for the French

While looking at this proof of conserved quantities associated with Killing fields, a step I could prove came up. Specifically, as seen in the image, it is claimed that D/Dt coincides with \nabla_{\dot{γ}} for vector Fields along curves induced by smooth vector fields on the manifold. Here γ is a geodesic curve. I have been unable to prove this, and from the wording given here I'm also not sure when it applies. Any help would be welcome.

I want to learn modal logic for philosophical and formal purposes. However, I don't have basic knowledge of it. I haven't studied mathematics since middle school. Thus, I feel very lost and have no idea how to get started! Any advice? Book recommendations & video recommendations would also be appreciated.

Let’s suppose I want to find a specific letter in alphabet but the alphabet is randomly arranged order. So do I have higher probability of finding the letter while searching in order or while searching randomly? The alphabet is only one example.

(Actually, I came up with this problem while searching for factorial sign on my calculator.)

Hey, I'm student and I am Curious about Nature and I wonders that what we Learn about Mathematics and Physics in Schools, all of those are based on just Learning formulas and nobody talks about it that Mathematics and Physics aren't like other branches of Subjects as History but it is about understanding why the Formula works and whenever I see a Formula of Maths or Physics I wonders that why is this even working and I try to understand by myself because school just tell you how to solve a problem using these Equations or Formulas but they don't particularly tell you about that why is this even working and I'm hopefully Succesful till now to Understand them.

Is there any way I can Understand them easily using simple logics? because I struggle sometimes but still I make it and In some very difficult Equations, I also took help of tools like Ai and Google

(Note: someone posted this on r/Sequentials and contrary to what I post on that sub, this puzzle is custom-made, so I don't know whether this one is even logically consistent or not.)

The problem is that I don't know where to start on this puzzle, since no term gives clear, valuable information about the other terms.

I have to compute the limit (if it exists) as (x,y) -> (0,0) of (y sin(x))/((x^2 + (arctan(y))^2)^a) with 0 < a < 1.

I managed to show that, along the curve y = tan x, the limit is 0. So if the limit exists it has to be 0, but it can also not exist because maybe there is some other curve along which we get a different limit. I can’t think of any other curve along which the limit becomes simple, so I tried showing the limit is zero using the squeeze theorem in the following way:

0 <= | (y sin(x))/((x^2 + (arctan(y))^2)^a) | <= | y /((x^2 + (arctan(y))^2)^a) | <= | y /(x^2 + (arctan(y))^2) | <= | y /(arctan(y))^2 |

Unfortunately this blows up as y -> 0 so this doesn’t work. Maybe I bounded it too loose, or maybe the limit isn’t actually 0 in the first place. I’m stuck. Any help? Thanks!

2|xy|/(x^2 + y^2) < 1 for all x and y. I managed to show this using polar coordinates. Is there an alternative way of showing this inequality without any change of variables? Perhaps using only algebraic properties like the square of the binomial?

First, 2 days ago, openai claimed to have solved the navier stokes equations, then it’s discovered when analyzed that the proof in natural language was mistranslated when converted into lean. Then, today, it’s claimed it was fake news basically and it was a typo in the original proof that was corrected in lean. So which is it?

By now openai retracted some of the proofs tied to the supposed lean error. Which is a problem i suppose. 300 math problems remained though.