Z-score

Doubles and floats are both ways of representing numbers with fractional parts or decimals, but they differ in precision. Doubles are 64 bits while floats are 32 bits (so less precise and so not used as much). If you had 1.5 instead of 1.5F, the compiler makes it a double by default. Adding the F makes it a float.

This is important because the function was carefully written to operate in 32-bit float land only. These lines:

(long *)&y; (float *)&i;

make it so that y is a long type (32-bit integer on old x86 machines) an the variable i is also a 32 bit type.

The IEEE-754 standard for floating point types specifies a different number of exponent and mantissa bits for doubles and floats in its representation. So changing to double changes intermediate values and the final approximation constant (that magic number of 0x5f3759df) is no longer optimal.

Hi other fellow internet stranger!!! Thank you so much for the question!

I suck at probability, but I am really good at simulating this stuff, so here's my results!

I wrote some python code that simulated 100 thousand different possible ways the phannies could be drawn. From my python simulation, it would take on average 49 packs to get 100% of the cards. So your prediction on whether the problem would take a shorter amount of time because there are no repeat cards is spot on!

However, to have 85% certainty (instead of ~50% from the average), you will need to get 62 packs, and for 99% certainty, 91 packs are needed.

Here is some interactable python code to experiment for any given percentage!

(Note: The python code is slow, but it is accurate, so give it a couple of minutes. If you wish to speed it up, feel free to remove a zero or two from the 100000. This will drastically improve speed, but some accuracy might be lost, but I can still get similar results with a small number.)

You are right that this is essentially the coupon collector's problem, but we reduce the number of packs needed since there aren't duplicates in each pack. This would be the coupon collector's problem if we had one card per pack.

Simplifying a bit, since there are 55 different cards and each pack contains 5 different cards, then the probability that a particular card appears in a pack is 5 / 55 = 1 / 11, which means that the probability it does not appear in a pack is 10 / 11.

After n packs, we have

P( a given card never appears ) = ( 10 / 11 ) ^ n

Thus the expected number of missing cards after n packs is

55 ( 10 / 11 ) ^ n (linearity of expectation)

There's a really nice approximation one can use by letting

P ( complete set after n packs ) = P ( X = 0 ) (where X is the number of missing cards)

If you imagine the missing cards behaving "almost independently" when the expected number missing is small, then the distribution of X is approximately Poisson distributed with λ = 55 ( 10 / 11 ) ^ n.

To see why, you can define X_i as 1 if the card is missing, and 0 otherwise. Then X is the sum of the X_i's. Each X_i is Bernoulli.

There's a famous limit theorem that states that if you have many Bernoulli random variables, each has small probability, and the total expected count stays moderate, then the sum behaves exactly like a Poisson random variable. As you get more and more packs (and you will if you are trying to collect all cards, then each X_i's probability p = (10 / 11 ) ^ n will shrink and thus will be a better approximation).

Technically speaking, this requires that the cards are independent, but note that the dependency is weak when missing cards are rare.

Regardless, we can use the approximation.

A Poisson random variable satisfies P ( X = 0 ) = exp(-λ), and thus we get

P ( complete set after n packs ) \approx exp(-55(10/11)^n)

We want this to be at least 85%, so we can just set them equal to each other and solve for the number of packs. Taking logs, we get

-55 ( 10 / 11 ) ^ n >= ln(0.85)

( 10 / 11 ) ^ n <= (-1 / 55) ln(0.85)

n > = ln ( (-1 / 55) ln (0.85) ) / ln ( 10 / 11 ) \approx 61.108

If we round up, we need around 62 packs for an 85% chance of getting a full set.

If we do a similar calculation for 99% accuracy, we get

n > = ln ( (-1 / 55) ln (0.99) ) / ln ( 10 / 11 ) \approx 90.310

If we round up, we need around 91 packs for a 99% chance of getting a full set.

Hope this helps!

If we get 119 elements, just make a table that is 18 x 6.61111111111

A lot of times it's usually more akin to when, back when you were learning arithmetic, you might come up with tricks to do things faster, and different people come up with different tricks. It begins by noticing patterns and asking questions about these patterns, and using existing math to learn more about them. It comes also of trying to solve new questions.

Let's pick a very primitive and familiar example, because the process has not changed that much, and I think it is a good example. If you already knew, for example, arithmetic addition, and you kept on having to do repeated additions (it comes up a lot, I am sure you know). The natural thing is to develop multiplication.

I feel like writing a mini-story.

Let's say you're an accountant in some ancient civilisation and have... packs of six items.

You do a lot of addition to keep track of how many things there are. And perhaps you already know the multiples of six because you've done it so much. And then when someone says they have thirty packs, you immediately count by sixes to know there are 180 items, and you recognise you're hardly doing explicit addition anymore, and start wondering if there's a faster way to do it.

And you make a table of how many packs are how many items and now you don't have to even do counting, except when this one guy starts coming in with packs of eight.

But you end up making a table of eights to help you. And then you consider that with this new free time you can start making tables of other numbers instead. And by the time you've made the multiplication tables you've noticed a plethora of patterns. And if you're mathematically inclined, (even if you don't know what mathematical inclination is) you start coming up with explanations for these patterns, and developing ways to predict these patterns and leverage them for repeated addition. And you start realising you've stumbled into something rather interesting. And you make a notation for it in your tables instead of writing it as repeated addition.

And perhaps you have already come up with the distributive property. After all, if one merchant comes in with five packs, and another with thirty, it is necessarily the same one merchant bringing thirty-five packs. And you start realising you've stumbled into can break it down into easier multiplications. Perhaps even discovering long multiplication. Pretty soon you have a whole new bunch of math around it.

And maybe a bit later you or someone else starts wondering about the behaviour with half-items. Or half-packs. Or some other weird situations and you start expanding what you've done. And someone notices some similarities with those "ratios" that other guy was doing. And someone else starts wondering if repeated multiplication has interesting properties.

There are a number of examples, but in some sense I don't think it has changed from that pattern. You do a thing, notice patterns and ask questions, and discover new things. It becomes more abstract and curious in higher math, and interesting, but the process is the same. What mathematics have you seen where? I wish to come up with relevant ones to you.

This is an excellent question, and I think that it highlights something that I think goes wrong in a lot of math teaching and yet is really difficult to fix. (Or, at least, I am not fully sure on the solution.) math is often taught without the underlying motivation. Teaching students multiplication without having them first, for example, make a multiplication table under the idea of repeated addition. It's not a huge problem in arithmetic, but still.

There was an era I wanted to find the minimum Number of new elements added to Rock Paper Scissors to keep the game playable for 3 people and so forth.

The problem is that you need win/loss/draw to all be equally likely for any two given players - because n player rock paper scissors is basically ⁿC₂ simultaneous games, right?

So if you model each element as being connected to every other element, then you only need to look at if the number of lines emerging from a point is divisible by 3, right? ³C₂ is conveniently the same as 3

1st rule: You have two binary operators.

2nd rule: YOU HAVE TWO BINARY OPERATORS.

3rd rule: Fight Group + Abel rules for the add.

4th rule: Closure and Associativity for multiplication.

5th rule: You HAVE be able to distribute.”

5th rule: The two fights must distribute over each other.

setup:

the volume of a sphere is 4/3 * pi * r^3

the derivative of the volume is 4*pi*r^2, which is equal to the surface area.

likewise, the area of a circle is pi * r^2, and its derivative, 2*pi*r, is equal to its perimeter.

the volume of a cube is a^3 (where a is the length of an edge), and its derivative, 3*a^2, is half of its surface area, 6*a^2

likewise, the area of a square, a^2, has a derivative of 2a, which is half the perimeter, 4a.

the actual question: lets say we have a regular n-gon, where the derivative of the area is equal to x times the perimeter.

can we always create a closed 3D surface where the derivative of the enclosed volume is equal to x times the surface area?

what does this method look like for a given x?

what does the series of 3D surfaces corresponding to the series of n-gons look like?

can we make our method of creating a 3D objects "naturally" contain a cube for a square and a sphere for the limit as n -> infinity?

other interesting questions:

are there any limititations on what x can be for a 3D object? what about for a 2D object?

can we make our 3D object only have straight edges? (excluding the limit of infinity which would be a sphere)

So I'm going to clarify the general idea behind your questions. What I see you asking is that if you have a family of shapes that grow in size, how are:

area vs perimeter (in 2D)

volume vs surface area (in 3D)

related through differentiation. More specifically, can you always find a way to measure the "size" of a shape such that

rate of change of area = (constant) * perimeter

rate of change of volume = (same constant) * surface area

Anyways, let me now answer your questions. If I'm misinterpreting what you are asking, let me know.

Clarification

I'm going to straighten one thing out first. The hidden issue is that you need to ask what variable you are differentiating with respect to.

For the circle and sphere, you use the radius r.

Circle: A = πr^2 -> A'(r) = 2πr = perimeter

Sphere: V = 4/3πr^3 -> V'(r) = 4πr^2 = surface area.

For the square and cube, you are using the edge length a:

Square: A = a^2 -> A'(a) = 2a = 1/2 * perimeter

Cube: V = a^3 -> V'(a) = 3a^2 = 1/2 * surface area.

So the mismatch (what x is) is coming purely from the choice of parameter. You can define the square and cube using a "radius" from the center (the inradius), as such:

Square: If the square is centered at the origin, let r be the distance from the center to a side. So the square goes from x = -r to x = r, and the same for y. Thus the side length is 2r. Then the area = (2r)^2 = 4r^2. And the perimeter is 4(2r) = 8r. You'll notice that if you differentiate area, you get dA / dr = 8r = perimeter. This matches the circle perfectly (x = 1).

Cube: This uses the same idea. Let r be the distance from the center to a face. So the side length is 2r. Then the volume is (2r)^3 = 8r^3. The surface area is 6(2r)^2 = 24r^2. If you differentiate volume, you get: dV / dr = 24r^2 = surface area. Again, this is a perfect match (x = 1).

For some reason, people think defining these shapes using the side length is easier (and I guess it is), but this should showcase my point about this mismatch coming from parameterization.

The General Principle

The general principle, which should answer most of your question, is that if you scale any shape uniformly by a factor t, the

Area scales like t^2

Volume scales like t^3

To see why intuitively, let's look at 2D. Suppose you scale a shape by t. Then every length becomes t * bigger. Area is made of length x length, so

area -> t * t = t^2.

For example, if you have a square with side 1, then the area is 1. If you scale by 3, then the side is 3, and the area becomes 9 = 3^2.

In 2D, volume is length * length * length, so we get volume -> t^3.

Again, we can do an example. If you have a cube with side 1, then the volume is 1. If you scale by 3, then the side is 3, and the volume = 27 = 3^3.

This always works. To see why intuitively, note that any shape can be approximated by tiny boxes. Each box scales in all directions. So the total area / volume picks up these powers.

Formalizing This

More formally, take a given shape, and scale it up or down uniformly. What I am essentially saying is that if you have a parameter t, where t = 1 is the original shape, t = 2 is twice as big, t = 0.5 is half as big, and so on, then

A(t) = C_2 * t^2

V(t) = C_3 * t^3

where C_2 is the original area (for a 2D shape), and C_3 is the original volume (for a 3D shape).

Note that everything scales proportionally. This works regardless of the shape. If you start with a square of side length 1, then the area = 1. If you scale by t, then the side length is t and the area is t^2, so here, C_2 = 1. If you start with a circle of radius 1, then the area is π. If you scale by t, then the radius is t, and the area is πt^2. So C_2 = π.

If you then differentiate:

A'(t) = 2 * C_2 * t = 2 * A(t) / t

V'(t) = 3 * C_3 * t^2 = 3 * V(t) / t

So A'(t) is proportional to A(t) by a factor of 2 / t, and V'(t) is proportional to V(t) by a factor of 3 / t.

The Inradius is Awesome

There's an important fact we can use here:

If t is the inradius (distance from center to side length), then

A = 1/2 * perimeter * t

V = 1/3 * surface area * t

To see why this is true (for 2D) think of a polygon. Break it into triangles from the center. Each triangle has a height of t (the inradius), and the base is the side of the polygon. So:

Area of one triangle = 1/2 * side * t

Add them all up: A = 1/2 * perimeter * t

So plugging in A'(t) = perimeter and V'(t) = surface area.

For 3D, it's the same idea. Break the solid into pyramids from the center. Each has a height of t, and a base is the face. So

Volume of a pyramid = 1/3 * face * t

Add them up: V = 1/3 * surface area * t

This works for shapes that admit a common inradius decomposition (e.g., regular polygons, spheres, and certain symmetric convex solids).

Now plug this into the derivative formula. We had

A'(t) = 2 A / t

Now substitute A = 1/2 * perimeter * t

A'(t) = perimeter

It's the same idea in 3D. We had:

V'(t) = 3 V / t

Substitute V = 1/3 * surface area * t

V'(t) = surface area.

So using the inradius makes your x = 1.

What x is

I just showed that if t = inradius, then x = 1. If we instead used something like side length, then we would get something different.

We'll use a square as an example.

Let t = a (side length). Then area = a^2, derivative of area with respect to side length is 2a, and the perimeter is 4a. So x = 1/2.

What happened was that you changed how you measure size. That rescales the derivative, which changes x.

If t = inradius -> x = 1

If t = side length (square case) -> x = 1/2

If t = circumradius -> another constant depending on n

For a fixed geometric parameter, x is determined by the shape. But by reparameterizing the scaling variable, you can make x any positive constant.

So to answer your main question about always creating a 3D surface where dV / dt = x * (surface area), yes you can.

For any family of similar shapes, dV / dt = 3 / t V = (constant depending on parameter) * surface area. And if you choose inradius, dV / dt = surface area.

You did ask explicitly about what parameter you should use for an n-gon. There's three natural choices that I see. If you use the side length, it's simple, but it'll give weird constants for x.

You could also use the circumradius (like the inradius, but goes from the center to the corner), which matches circle nicely as n -> ∞, but I would recommend the inradius since that makes everything unify cleanly, namely:

A = 1/2 * (perimeter) * (inradius)

which gives

dA / dr = perimeter

directly and again makes x = 1.

Building a 3D Analogue of Regular N-gons

Now your more interesting structural question, namely "What does the series of 3D surfaces corresponding to the series of n-gons look like?"

In 2D, a regular n-gon approaches a circle as n -> ∞.

However, in 3D, there is no infinite family of "regular polyhedra" (there are only 5 platonic solids). In other words, there isn't a clear analogue. However, you can use prisms, pyramids, or surfaces of revolutions to make a series of 3D shapes where they contain at least 1 n-gon (just not every face being an n-gon).

So one sequence could be a triangular prism, then rectangular prism, then pentagonal prism, and so on.

Another sequence could be a tetrahedron, a square-based pyramid, a pentagon-based pyramid, a hexagon-based pyramid, and so on.

But you want a sequence that includes a cube and converges to a sphere. This is possible, but you need to be careful with how you construct it.

One clean method is to start with a cube, then repeatedly subdivide each square face into smaller squares. Then "push" the new vertices outward so they lie on a sphere. This will give a cube, then a refined cube, then a more refined cube, and so on, and then it will converge to a sphere.

Now for your question about everything having straight edges. You can (I just did with the refined square example above), but with an important caveat.

You can build polyhedra with only flat faces and approximate a sphere arbitrarily well. However, exact equality V'(t) = surface area still depends on your parameter choice. Smoothness is not required for the scaling law to work.

Hope this helps!

They found the NAND gate for mathematics! Now we need a no-holds-barred bare-knuckle drag-out fight between this and Binary Lambda Calculus

if you’re anything like me, you were probably a little mystified when you first started reading about groups. groups are quite possibly the nicest algebraic objects; they're simple enough that their axioms fit on a postcard, but they're rich enough to have interesting structure theorems (cfsg, for instance). but there's an important question that never seems to get answered in intro resources:

why those axioms over anything else? why is it that a(bc) is equal to (ab)c, and not something like (ba)c?

when you start to develop some mathematical maturity, the answer starts to come into clearer focus. but i don't think you should need to wait! the underlying idea is actually fairly simple, and it teaches some great lessons about how modern mathematics is organised. so that's the point of this post: to explain the point of the group axioms in the purest sense possible.

Groups as symmetries — but not really

alright, so the textbook motivation for groups is that they model the concept of symmetry. but what does this mean, really? the problem is that mathematicians mean something much broader than what we usually mean by symmetry in this context. here are some examples:

the textbook example is a polygon of some kind. the symmetries of an equilateral triangle are 120° rotations and flips, for instance. when we say symmetry, we are really talking about a function which takes the polygon to itself, and preserves lengths and angles.

now take a line of dots (not necessarily evenly spaced), extending infinitely in either direction. the relevant "symmetries" here are the functions taking dots to dots which preserve the order of the dots.

take a finite collection of objects of any kind whatsoever; i'll call it X. i can define a "symmetry" of this collection to be a function f: X -> X which doesn't take any two objects to the same object. in this situation, the "symmetries" aren't preserving anything but the size of X: by this i mean that f(X) is the same size as X.

for a more complicated example, take a vector space V and consider all the bijective linear maps from V to V. the "symmetries" are preserving not just the size of V, but the sum and product operations in V as well.

with these examples in mind, i'll define the word "symmetry" in the way it's meant here. given some object X, a symmetry of X is a function f: X -> X which "keeps X the same" in a way we don't care to specify. in each of the examples above, the meaning of "keeps X the same" changed to "preserves lengths and angles", "preserves order", "preserves size", and "preserves operations".

so, this is the point of groups! groups model the things you can do to something while "keeping it the same" in some sense. and from this perspective, it might make sense why we'd want to codify and systematically understand this idea; sameness appears a lot in maths, so if we can prove something about sameness that's always true then that should be really useful.

Defining groups (the nonstandard way)

now that we have a proper motivation, a definition of groups is not too far away. however, it turns out to be different to the usual one. it basically follows from these 3 observations:

in all of the examples above, the symmetries took the form of functions from a set to itself. (in the case of polygons, the function took the points of the polygon to itself.) in addition, if a function keeps any set X the same, it should at the very least preserve the size of the set. therefore, a group should be a collection of bijections from a set to itself. the collection of all such bijections is usually denoted Sym(X), so a group G is a subset of Sym(X).

if you have two functions which keep X the same, then obviously doing one after the other should also keep X the same. this means a group should be closed under composition: if f and g are in G, then f o g should also be in G.

finally, whenever you do something that keeps X the same, you should always be able to undo it. this means a group should contain all its inverses: if f is in G, then f^-1 should also be in G.

so that leads us immediately to a definition of a group!

A group is a subset G of Sym(X) for some set X, which is closed under composition and contains its inverses.

...how is that a group?

if you know anything about groups, you'll know that this doesn't really look like the textbook definition at all. in fact, the group definition doesn't even make mention of a set X in the first place, just the set G! it turns out that we can massage this definition and show that it's equivalent to the usual one; but first, let’s talk a bit about why you might want a different definition.

put simply, this definition has too much baggage due to the set X. to elaborate, consider the symmetries of a square and of a square pyramid: these correspond to different sets X, so functions will look very different on them, but the underlying geometric operations are the same! eliminating the set X from the definition would "purify" things: symmetries which were genuinely the same could be treated on equal footing.

ideally, then, we'd like to define a group as something independent of a set on which it acts. but how could we do this? well, it comes down to the 3 observations we made when defining them the first time:

"a group is a set of bijections G from a set X to itself." if we want to forget the set X, we can just take G to be a set.

"if two functions in G are composed, then that should also be in G." if G is just a set, then its elements aren't necessarily functions and composition might not make sense. how to fix this? the answer is basically inventing our way out of the solution: we just give G an operation which takes two elements and returns another element (which is exactly what conjugation does for functions). such an operation is called a binary operation.

"if a function is in G then so is its inverse." again, if G is just a set, inverses don't make sense. so we fix this in the exact same way as before: we just give G an operation which takes an element and outputs another element (like inversion does). this is called a unary operation.

so there we go! a group is just a set G equipped with a binary operation (which is composition) and a unary operation (which is inversion). done!

That's still not a group!

...except not quite. the problem with our definition is that not all binary operations behave like composition, and not all unary operations behave like inversion. let's think through some examples to show how this might be the case:

consider a rock-paper-scissors binary operation: the set is {r, p, s}, and the binary operation is defined to take in two elements and return the winner element. for example, r*p = p because paper beats rock, p*s = s because scissors beats paper, r*r = r because that's a tie, and so on. now imagine that r, p, s could be interpreted as functions from some set to itself, and that * could be interpreted as composition. if that were true, then r(p(s(x))) would need to be equal to both (r*p)(s(x)) and r((p*s)(x)), meaning (r*p)*s would need to equal r*(p*s). but this isn't the case: the former is equal to s, while the latter is equal to r! this means the rock-paper-scissors operation * can never be interpreted as composition.

consider another three-element set {0, 120, 240} corresponding to rotations by a given angle, and give it the usual operation of composition (so 0 o 120 = 120, 120 o 120 = 240, and so on). now, give this set a unary operation which takes each element and gives back the same element: 0^-1 = 0, 120^-1 = 120, 240^-1 = 240. this doesn't properly represent the "inverse" concept, because it's meant to be the same as undoing; however, doing 120 and then 120^-1 is the same as doing 240, which isn't doing nothing!

luckily, these examples give us ideas on what we should add to our definition to make it work.

the problem with the rps-operation is that function composition is always associative, meaning the bracketing doesn't matter, while the rps-operation isn't. so we'll add to our definition that the binary operation needs to be associative.

the problem with the {0, 120, 240} inversion was that it didn't correspond to undoing. we can make this precise by saying that x composed with x^-1 should be the same as doing nothing. of course, since G is just a set, it's not clear what "doing nothing" is supposed to mean; we can fix this by choosing a particular element of G, say e, to be the symmetry which does nothing. we codify its "doing nothing" property by saying that x composed with e is the same as just x.

and that's it! finally, we have arrived at the textbook definition:

A group is a set G equipped with an associative binary operation *, an identity element e for which x*e = x, and a unary operation ^-1 for which x*x^-1 = e.

all well and good! well, except...

How do we know that's enough axioms?

after all, we just looked at two examples and said "huh, functions do this but they don't do that, so we'll just add it to the definition". how do we know there aren't any examples which fit our new definition, but don't correspond to functions?

the answer is in the form of a beautiful result:

Cayley's theorem: Every group G can be viewed as a subset of Sym(X) with the usual composition and inversion operations, for some set X.

the proof? just take the set X to be G itself! then interpret each element g of G as a function from G to itself by taking any other element h to g*h. these functions have inverses given by g^-1*h, meaning they are bijections. also no two elements are represented by the same function, since e gets taken to a different element by each g. (it is an instructive exercise to figure out where exactly this argument breaks if you relax associativity!)

in any case, this theorem tells us that our search is done. we have removed the set X from our definition, but we can always put it back and still get nice functions if we like. we've shown that this can be done when X is taken to be G, but the general concept is so important that it has been formalised:

Let X be a set and G a group. A G-action on X is a function φ: G -> Sym(X) such that φ(g*h) is the same as φ(g) o φ(h) in the output.

in other words, a G-action on a set is just an interpretation of the elements of G as bijections on X, in such a way that composition looks the same as the binary operation. in essence, this is why my initial definition is never presented anymore: we don't want to deal with the extra baggage of X, and we don't even need to because it can be encapsulated as a G-action instead, which we know is always possible by cayley's theorem!

What was the point of all that?

now that that's done, the natural question is this: why present a worse definition first to just arrive on the usual one anyway? and here's the answer: because this kind of thing happens all the time in maths, it only becomes clear to you when you've been dealing with it for years.

rings? they're just collections of endomorphisms of abelian groups, and their abstract definition allows them to be thought of that way.

banach algebras? they're just collections of bounded linear operators, and their abstract definition allows them to be thought of that way.

lattices can be defined completely algebraically, but once again, this definition essentially serves to abstract away the concrete notion of a lattice in terms of a partial order.

even categories themselves fall on this list! the definition of a category is bluntly abstract, but it's essentially an abstraction of a place where functions from one thing to another can be chained together.

if you are a beginner then you might not understand a whole lot of that list, and that's okay because you'll get to it eventually. but if you're not quite a beginner then i'm sure you'll see what i mean! all of this can be viewed through the lens of the yoneda lemma from category theory if you're interested in that kind of thing.

Your logic appears to be correct if we assume it's an i in the numerator. Looking at the denominator, recall that i^4=1. Thus, the denominator is z^4-1 = 0. But the numerator gives i^2+i=-1+i not equal to 0. So we have nonzero/0, which means that there is a pole at z = i. This also means that your algebraic manipulation of multiplying the numerator and denominator by z^4+1 is not needed. You can already tell it's a pole by the fact you get nonzero/0.

Thus, in the extended complex plane, the function blows up and the limit is infinity.

However, infinity is not the answer if we assume it's a typo and the limit is actually lim_{z -> i} of (z^2+1)/(z^4-1)

Then the numerator becomes i^2+1=-1+1=0 and the denominator becomes i^4-1=1-1=0. We then get 0/0.

You can factor the denominator as z^4-1=(z^2-1)(z^2+1). Then cancel z^2+1 with the numerator, which leaves the limit as 1/(z^2-1)

Plugging in z=i now, you get 1(-1-1)=-1/2

Your professor was pointing out that the original version creates a pole, which likely wasn't the intended exercise.

Second, since you mentioned this was physics homework, I'll assume that z > 0 since that's the general convention in physics. Third, note that if you ever have a radical of a squared variable plus or minus a constant, think trig substitution. In particular, you may use this general guide. Let a and b be constants, and let x be the variable you are integrating with respect to. Then:

If the form is sqrt(b²x² - a²), then note this looks like sec²(θ) - 1 = tan²(θ). Thus you can make the substitution x = a/b sec(θ).

If the form is sqrt(a² - b²x²), then note this looks like 1 - sin²(θ) = cos²(θ). Thus you can make the substitution x = a/b sin(θ).

If the form is sqrt(a² + b²x²), then note this looks like 1 + tan²(θ) = sec²(θ). Thus you can make the substitution x = a/b tan(θ).

Your integral takes the third form, namely with sqrt(x² + z²), which means we can make the substitution x = z tan(θ). Then dx = z sec²(θ) dθ Plugging this into the integral, our integral becomes:

∫ 1/sqrt(z²tan²(θ) + z²) z sec²(θ) dθ

= ∫ 1/sqrt(z²(tan²(θ) + 1)) z sec²(θ) dθ

= ∫ 1/sqrt(z²sec²(θ)) z sec²(θ) dθ = ∫ 1/(|z| sec(θ)) z sec²(θ) dθ

Note that we are able to drop the absolute value bars around sec(θ) since we are evaluating with x = z tan(θ). On the domain [0, L] (recall that that this is an even function and thus we were able to write the bounds as 0 to L) with z > 0, we have tan(θ) > 0. Therefore, θ is in the domain [0, π/2). On this interval, sec(θ) > 0.

Recall that I assumed z > 0 and thus I'll drop the absolute value bars around that as well. Thus, we can cancel out a secant and the z constant and be left with:

∫ sec(θ) dθ

Multiply this integral by (sec(θ) + tan(θ)) / (sec(θ) + tan(θ)) (this is equal to 1 since the numerator and denominator are the same. This gives:

∫ sec(θ) (sec(θ) + tan(θ)) / (sec(θ) + tan(θ)) dθ

= ∫ (sec²(θ) + sec(θ) tan(θ)) / (sec(θ) + tan(θ)) dθ

You'll notice that the numerator is the sum of the derivatives of sec(θ) and tan(θ). Thus, we can make the u substitution of u = sec(θ) + tan(θ), which means du = sec²(θ) + sec(θ) tan(θ) dθ.

Therefore, we can rewrite the integral as:

∫ 1 / u du = ln | u |

Recall that x = z tan(θ) -> θ = arctan(x/z).

Now substituting back for θ, then x, we get: ln | u | = ln | sec(θ) + tan(θ) |

= ln | sec(arctan(x/z)) + tan(arctan(x/z)) |

= ln | sec(arctan(x/z)) + x/z |

Recall that sec(θ) = sqrt(1 + tan²(θ)). Thus:

ln | sec(arctan(x/z)) + x/z | = ln | sqrt(1 + tan²(arctan(x/z))) + x/z |

= ln | sqrt(1 + (x/z)²) + x/z |

Multiply the square root term by z / z to simplify:

= ln | sqrt(z² + x²)/z + x/z | = ln | (sqrt(z² + x²) + x)/z |

You can then use the log rule ln(a/b) = ln(a) - ln(b) to get rid of the denominator and write it as a constant:

ln | (sqrt(z² + x²) + x)/z | = ln | (sqrt(z² + x²) + x) | - ln | z |

Since square roots are always positive and I made the assumption that z > 0, we can get rid of the absolute value bars in the logarithm:

ln((sqrt(z² + x²) + x)) - ln(z)

Now we plug in our bounds: If x = L, then

ln((sqrt(z² + x²) + x)) - ln(z) = ln((sqrt(z² + L²) + L)) - ln(z)

If x = 0, then

ln((sqrt(z² + 0²) + 0)) - ln(z) = ln(z) - ln(z) = 0

Thus, we are left with only the L term:

ln((sqrt(z² + L²) + L)) - ln(z)

Next, multiply by the 2 we got by noticing that this function is even: 2ln((sqrt(z² + L²) + L)) - ln(z²)

I may have made a mistake somewhere, but this should be correct.

I should also note that you can get a general antiderivative by not using the fact that the bounds are even. This will get you the form:

ln |x + sqrt(z² + x²)| + C. If you then plug in L and -L as the bounds, you'll get:

ln |L + sqrt(z² + L²)| - ln |-L + sqrt(z² + L²)|

= ln |L + sqrt(z² + L²) / (-L + sqrt(z² + L²))|

Multiply the numerator and denominator by sqrt(L² + z²) + L:

ln |L + sqrt(z² + L²) / (-L + sqrt(z² + L²))|

= ln |(L + sqrt(z² + L²))² / (sqrt(z² + L²) - L)(sqrt(L² + z²) + L)|

= ln |(L + sqrt(z² + L²))² / z²|

= 2ln((sqrt(z² + L²) + L)) - ln(z²)

which is the same answer as above.

Hopefully this helps!

Partly Cloudy

z_(n+1) = sec(sec(z_n)) + c

50,000,000 random values of c, with maximum iterations 31 for red, 41 for green, and 59 for blue. The resulting image is rotated 90° counterclockwise.