If math is going to make sense to kids we can't resort to explanations that sound like "and then a miracle occurs".

BTW, I am not being critical of your answer. What I am saying is that there are these corners in seemingly simple math that have me scratching my head when it comes to explaining the concepts to a kid in a manner that makes sense and isn't circular. I have yet to find good answers to these questions.

Kid: What does the 10th. root of n mean?

Dad: It's the number, let's call it x, that, when raise to the 10th power is equal to n

Kid: So: n = x * x * x * x * x * x * x * x * x * x?

Dad: Yes! You got it!

Kid: How do you calculate it?

Dad: Well...

Kid: What if it is the 10.1 root of n?

Dad: Well, that's a little different...

Kid: How?

Dad: It's the number than when raised to the p-1 power times the base raised to the fractional portion of the power is equal to n

Kid: What's the fractional portion?

Dad: For the case of p = 10.1, it's 0.1

Kid: x * x * x * x * x * x * x * x * x * x^(p - int(p)) then?

Dad: Yeah.

Kid: How do I calculate x to the 0.1 power?

Dad: Well, you could use your calculator...(now starting to sweat)

Kid: How does the calculator do the math. You know, like when the math teacher says "Show your work"

Dad: Well, you could use logarithms...

Kid: What are logarithms?

Dad: A better method could be to use Newton's method. Here:

https://en.wikipedia.org/wiki/Newton%27s_method

Kid: It says: "start with an initial guess which is reasonably close to the true root, then to approximate the function by its tangent line using calculus, and finally to compute the x-intercept of this tangent line by elementary algebra"

Dad: Yes...

Kid: I don't know calculus. Is that the only way? I just wanted to understand how to calculate the 10th root of a number?

Dad: OK, let's try this. I just threw it together:

    # Calculate the exp root of n using a binary search
    #
    def root_binary_search(n, exp):
        # Return b, which is the exp root of n
        # b**exp should be equal to n
        #
        min = 0
        
        # For exponents < 1 the max needs to be sufficiently large
        max = n
        if exp < 1:
            while max**exp < n:
                max *= 2

        max_error = 0.00001

        while True:
            b = (max + min) / 2
            b_exp = b**exp
            error = abs(n - b_exp)
            # print(f"min: {min:15.4f}   max: {max:15.4f}   b: {b:15.4f}   b_exp: {b_exp:15.4f}   n: {n:15.4f}   error: {error:5.8f}")
            
            if error <= max_error:
                return b
            else:
                if b_exp > n:
                    max = b
                else:
                    min = b


    # Tests
    print(root_binary_search(4, 2), f"  result should be: {4**(1/2)}")
    print(root_binary_search(16, 2), f"  result should be: {16**(1/2)}")
    print(root_binary_search(5, 0.1), f"  result should be: {5**(1/0.1)}")
    print(root_binary_search(2, 10), f"  result should be: {2**(1/10)}")
    print(root_binary_search(4, 0.25), f"  result should be: {4**(1/0.25)}")

Dad: Yeah...? (looking embarrassed)

Kid: And to accept an error? 4-squared is 256, not 255.998046875?

Dad: Well, you have to understand that with a binary search...

Kid: And, did you see what happens if I run this case?

    print(root_binary_search(4, 1), f"  result should be: {4**1}")

Dad: I have to get back to work. Why don't you ask your math teacher tomorrow?