Where the standard functions stay unbroken, and where they jump

0:00Here is a rule written in two cases. Below and at the input one, it adds two. Above one, it takes two away. Away from that input there is nothing to think about: on either side the rule is a single ordinary formula, and the verdict there is one line of work. Everything interesting is at the one input where the rule changes over. Call that input the join. At the join there are three quantities, and they are three different things.

0:33What the function approaches as you come up to the join from below, what it approaches as you come down to it from above, and the value it actually takes there. From below it approaches three. From above it approaches minus one. Three is not minus one, so the two sides never meet, and the join is the only input in the whole line where this function breaks. Draw it and you get two parallel segments with a step between them.

1:05The upper segment carries a filled dot at its end, because that end belongs to it. The lower one carries a hollow circle, because that end does not. The picture is honest, and it is also the wrong thing to reason from. A drawing shows you a step this large. It will not show you a step a thousandth of a unit high, and it will not show you the difference between a step and a single misplaced point.

1:34So the picture goes second. The two numbers go first, and the picture is what you draw once you already know the answer. Now change one thing. Keep both branches exactly as they were, and write a third case that says the value at the join is nought. The function has changed: at that one input it now returns nought instead of three. At every other input it is the same function as before, and here are five of them to check.

2:06So what happens to the verdict? Nothing at all. From below it still approaches three, and from above it still approaches minus one, because neither approach ever looks at the join itself. The two sides had already disagreed, and no number you write at the join can make them agree. That is worth holding on to, because the instinct is to reach for the value first. Set the value last.

2:36It is the third question, not the first. Here are four items of the same shape. Each is one branch below an input and a different branch at and above it, and each looks equally suspicious. The first joins a quadratic to a linear branch at one. Both sides give two, and the value is two, so it breaks nowhere. The second joins a cubic less three to a quadratic plus one at two.

3:06Both sides give five, and it breaks nowhere either. The third joins a tenth power less one to a square at one, and there the sides give nought and one. The fourth adds five below and takes five away above, and the sides give six and minus four. Same shape, four times. Two of them break and two of them do not, and nothing about the way they are written tells you which is which.

3:35That is one comparison, so let us do it properly. Take six ordinary branches, put one on each side of a join, and write one of five things at the join itself -- four numbers, or nothing at all. That is one hundred and eighty functions, and every single one of them is written in two cases. One hundred and forty-four of them are declared at the join. Of those, one hundred and thirty-five really do break there.

4:06And nine do not. Nine of them are two rules whose branches already agree at the boundary, so the case split marks where the writing changes and not where the function does. The remaining thirty-six are not declared at the join at all, which is a third thing again, and we will come to it in a moment. Nine and thirty-six is forty-five functions that a reader who sees two cases and calls it broken gets wrong.

4:38Here is that third thing. Add two below nought, take the input away from two above nought, and at nought write nothing. The rule is simply not declared there. Come up to nought from below and the function approaches two. Come down to it from above and it approaches two as well. The two sides agree perfectly. And there is still no verdict to give at nought, because there is no value there to compare the agreement with.

5:08An input the rule was never declared at is not a place the function fails. It is a place the function is absent. Check every input this rule is actually declared at, and it breaks at none of them. Which produces a sentence that sounds like a contradiction and is not. This function is continuous, and its graph cannot be drawn without lifting the pen. Both are true at once.

5:38The pen has to leave the paper at nought. But it leaves the paper at a place where nothing is drawn, because nothing is defined there. So the one-stroke picture is not the definition. It is a decent picture for a function whose domain is one unbroken stretch, and it is misleading for every function whose domain has a hole in it. Keep it where it works, and drop it everywhere else.

6:08Now a case split that stitches perfectly. Square the input below nought, and return the input itself at and above nought. Split the line into three regions and take them in order. The negatives are a single formula and there is nothing to check. The positives are a single formula and there is nothing to check there either. That leaves the single input nought, which is the whole of the work.

6:36From below the square approaches nought. From above the input itself approaches nought. And the value assigned there is nought. Three quantities, one number, and this function breaks at no input anywhere. There is a shortcut waiting here, and it disposes of an enormous number of exercises. A polynomial is a finite sum of constant multiples of whole-number powers. It has no cases, no joins and no gaps. The polynomials tested here were each checked at six inputs by the definition, thirty checks in all, and not one of them broke anywhere.

7:19So the moment you recognise a polynomial, you are finished. That is why so many items in this topic are one line long, and why the ones that are not are always the ones with a boundary in them. Now the question nobody asks, and it is the one that matters. The working method is: at each join, put the join into the branch on the left, put it into the branch on the right, and compare.

7:49But putting the join into a branch is substitution, and the whole point of a limit is that you never substitute. So why is the method allowed? Because for these branches the two things happen to give the same answer, and that is a fact you can check rather than a rule you obey. Every function in that sweep of one hundred and eighty was asked both ways, on both sides.

8:16Three hundred and sixty comparisons. The shortcut and the definition disagreed nought times. That is the licence for the method, and it is worth having in writing, because the licence has limits. Here is a rule written in exactly one case. It sends every input to the largest whole number that does not exceed it. One rule, no branches, no joins written anywhere. Draw it and you get a staircase: a flat step across each unit stretch, and a jump up of one at every whole number.

8:55Take any input that is not a whole number, and nearby the rule is simply constant, so the verdict there is immediate. Six such inputs were checked and every one of them is fine. Take a whole number, and the two sides give values exactly one apart, every time. Seven whole numbers were checked and the gap was exactly one at all seven. One apart can never be nought apart, so this function breaks at every whole number there is.

9:28And here is where the licence runs out. Try the working method on the staircase at the input two. The branch in force to the left of two is the same rule, because there is only one rule. Put two into it and you get two. But the limit from the left is one. The shortcut returned a number, the number was wrong, and nothing about the calculation looked wrong while you were doing it.

9:56From the right it agrees, which is exactly why the mistake is easy to miss. So the method is not a law. It works because the branches in these exercises are the kind of formula whose limit is its value, and a rule that steps is not that kind of formula. Look at one step of that staircase closely. Each step carries a filled dot at its left end and a hollow circle at its right end.

10:26The filled dot says this end belongs to the step. The hollow circle says it does not. That is not decoration. Read both ends of a step as included and you have claimed the function returns two different numbers at the same input, which no function does. At a whole number, the rule returns that number. Just below it, the rule returns the number one less. The dot and the circle are the picture of those two sentences.

10:59This function fails at every whole number, and there are infinitely many of them. That sounds like a worse kind of failure. It is not a different kind of failure at all. The verdict at each whole number is reached by the same two-line comparison you used at a single join. Counting the bad inputs tells you how many places to check, not how badly the function behaves at any of them.

11:27Take the input minus its own largest whole number below, and you get the fractional part, which is another single rule. It breaks at exactly the same seven whole numbers. Just below a whole number it is close to one, and at the whole number itself it drops to nought. So let us ask what a reader actually uses to decide. Seven readings, run side by side over the same one hundred and eighty functions, at the same join.

12:00The real one: the input is in the domain, both sides exist and agree, and that agreement is the value. It declares one hundred and thirty-five breaks and is wrong about none of them. Then: it is written in more than one case, so it must break where the cases meet. That declares all one hundred and eighty and is wrong forty-five times. Then: an input missing from the domain is a break.

12:29One hundred and seventy-one declared, thirty-six of them wrong -- every single function that has nothing written at the join. Then: the pen has to leave the paper here. One hundred and forty declared, thirty-six wrong, and thirty-one real breaks missed entirely. Those thirty-one are the interesting ones. They are the functions whose two sides agree perfectly and whose value at the join is some other number entirely. The pen never leaves the paper in any visible way, and the function is still broken there.

13:08Which retires the last two readings as well. Compare the value against one branch and you miss the twenty-one where the other branch is the one that disagrees. Stop as soon as the two sides agree, and you are wrong about twenty-six absences and blind to the same thirty-one. Every one of these readings is a real thing people do. Every one of them is right most of the time.

13:36And each one is wrong in its own particular direction, which is why the three demands are worth doing in full rather than replaced by any single glance. Finally, four definitions that look alarming and are perfectly clean. The input over its own modulus below nought, and minus one at and above nought. Below nought that quotient is already minus one, so the two cases describe one constant rule and there is nothing to break.

14:11A three-branch rule that is minus two, then twice the input, then two. At its lower join all three quantities are minus two, and at its upper join all three are two. A sine over the input below nought, and one more than the input at and above. That left branch is not declared at nought at all, so the working method has nothing to put in -- the second way the shortcut fails, and a different way from the staircase.

14:41The limit is one all the same, and the value is one, so it breaks nowhere. And a modulus minus a shifted modulus, which looks certain to break somewhere and breaks nowhere. So here is the method, and here is what it costs. Split the line wherever the rule changes over. Do the easy regions in a line each. Spend the whole argument on the boundaries, because a boundary is the only place the verdict can surprise you.

15:13At each boundary take three quantities and never two: the side below, the side above, and the value. Set the value last. Ask whether the input is in the domain before you ask anything else, because an absence is not a failure. And remember that putting the join into the branch is a shortcut you are borrowing, not a definition -- it is exact for the branches in these exercises, and it is wrong on a rule that steps.