I’ve just derived this formula for π. is there any way to make this look a bit nicer?

[uneven bramble]

Im not acquainted with transforming goniometric functions.

[uneven bramble]

I should note that the “times” symbol should actually be a minus, whoops!

[fading steppe]

we're doing calculus so it's usually better to do anything wiht trig using radians and not degrees

wait but your finding pi

and radians include pi

hmmmmmmmmmm

You can use the cosine double angle theorem

cos(a-b) = cos(a)cos(b)+sin(a)sin(b)

[uneven bramble]

I suppose I could split the fraction and do that and see where it gets me

I want to either see if I can solve the limit or make it easier to calculate with arbitrary precision

Is it readable?

[frigid citrus]

Bro better

Use Wolfram alpha

[uneven bramble]

Apparantly wolfram thinks it’s minus infinity

[fading steppe]

Yeah because it assumes cos is in radians

[soft trench]

@uneven bramble do you still need help?

[uneven bramble]

Yes

[soft trench]

This is actually a well-known calculation for pi. One of the slowest ones, if we're being honest, but still well-known

The modern way to do the calculation is iteratively using half angle formula

you're starting with the a triangle inscribed in a unit circle. If you find the triangle's perimeter, that's a (bad) approximation for pi

And you can find an algebraic approximation because you know the exact trig values for 120 degrees

The limit you wrote "works" for any N, yes, but it's a hard process to iterate from N=3 to N=4. Or even worse from N=6 to N=7. There's no neat way to iterate this without having to use actual trig formulas (which will rely on pi already, so you've made your life hard)

But you can easily iterate from N=3 to N=6 to N=12 to N=24 and so on.

You can do this by doubling the number of sides each time. And you can find the exact trig values using half angle formula

I actually wrote a quick python program to do this, and you can see it goes near pi

(except after about 20 iterations. This is because the number of sides is growing exponentially, and python is limited to 64-bit math)

Does that help at all?

[uneven bramble]

I suppose I could redo the starting process so it converges faster and easier