Onto as the demand that nothing in the codomain be left unhit

0:00When you look at a diagram of a function, your eye goes to the arrows. This time, look at what the arrows never touch. Here is a diagram with four inputs on the left and six targets on the right, and four arrows leaving the inputs. Follow them across and they land on four different targets. Which leaves two targets, the fifth and the sixth, with nothing pointing at them at all.

0:27Six declared, two unreached. Now a second diagram, four inputs again, but this time only three targets are declared. The arrows land on the first, the first again, the second, and the third. Three declared, and unreached: none. Every target has something arriving at it. And notice what else is true of that second diagram: two of its arrows land together, so it has a collision. Collisions in the two diagrams: none in the first, one in the second.

1:02So the first covers nothing fully and has no collision, and the second covers everything and does have one. Those are two entirely separate questions about a function, and this video is about the second of them. The property has a name. A function is called onto — the other word is surjective — when every element of the declared target set is the output of something in the source.

1:33Read that carefully, because it is an existence claim, and existence claims have a shape. For each target, there is to be an input that reaches it. So proving a function onto is a two-step job, and the two steps never change. Step one: take a target, and take an arbitrary one — not a convenient one, any one at all. Step two: produce an input that lands on it, and check that it does.

2:02Producing usually means solving: you write down the equation saying the output equals your target, and you solve it for the input. And there is a third thing to check, which people forget: the input you produced has to be in the declared source set. An input that solves the equation but does not belong to the domain is no use at all. That is the whole method, and every proof in this video runs it.

2:32Disproving is much shorter. Name one element of the target that nothing reaches, show nothing reaches it, and stop. One unreached element is a complete refutation. There are two sets on the output side of a function, and telling them apart is most of this topic. The declared target set — the co-domain — is something you write down when you announce the function. It is a decision. The range is the set of outputs the function actually produces. It is a consequence.

3:09The range always sits inside the co-domain; that is what makes the thing a function into that set at all. And onto says exactly this: the range has filled the co-domain, with nothing left over. That is not a second fact about being onto. It is the definition said again in one line. Picture two regions, one drawn inside the other. The function is onto exactly when the inner region has swollen out to meet the outer boundary.

3:42Which gives you a strategy: to answer a question about onto, work out the range and compare it with what was declared. And it tells you something the definition alone hides — that the answer can be changed without touching the rule, because one of the two regions was only ever a decision. Every remaining section of this video is a variation on that one sentence. Take the simplest rule in mathematics that is not the identity: doubling.

4:16Declare it from the counting numbers to the counting numbers. x goes to two x. Is it onto? Run the method. Take a target, say one. Which counting number doubles to one? Half of one is a half, and a half is not a counting number. So nothing reaches one, and the function is not onto. That is the entire refutation. But one is not special, and it is worth seeing how unspecial it is.

4:47Read it over a declared target of the first forty counting numbers. Forty targets declared, and twenty of them unreached. The three smallest missed are one, three and five. It is missing every odd number, which is to say half of everything it promised to cover. Now run the builder instead of the search — the two-step proof, done mechanically. For each of the forty targets, build the candidate input by halving, then ask whether the domain admits it.

5:20Forty targets tried. Candidates the domain refused: twenty. Candidates that failed to land back on their target: none. Every single failure was a refusal at the door. The algebra never went wrong; the halves simply were not counting numbers. Now change nothing about the rule and watch the answer flip. Declare doubling from the whole number line to the whole number line. x goes to two x, character for character the same.

5:55Take an arbitrary target y. Which input doubles to y? Half of y. And half of a real number is a real number, so the domain admits it. Check it lands: twice a half of y is y. Done — the function is onto. Read it against a stand-in so the words become numbers. Take forty-one targets, the quarter steps from minus five to five, and a wider grid of eighty-one points holding every half of them.

6:27Forty-one targets tried. Candidates the domain refused: none. Candidates that failed to land: none. The same rule, the same halving builder, handed to two declarations. One reading: forty tried, twenty refused. The other: forty-one tried, nothing refused. The difference is not in the formula. It is in the sentence you wrote around the formula. And here is the thing the range picture makes sharp. On the counting numbers the range of doubling holds forty values — exactly as many as the declared target has.

7:07And it still misses half of it, because only twenty of those forty values landed inside the target at all; the rest fell out past the end. Same size, wrong place. Counting the range is not the same as covering the co-domain. Before going on, a table, because it makes one point better than any argument. Five functions that differ only in their rule and the sets declared around them.

7:37Squaring on the counting numbers. Squaring on the whole numbers, negatives included. Squaring on a stand-in for the number line. Then cubing on the counting numbers, and cubing on the whole numbers. Ask each of them the collision question, and the answers are nought, twenty, twenty, nought and nought. That column varies. Three of them are one-one and two are not. Now ask each of them the covering question. Unreached targets: thirty-four, thirty-six, thirty-six, thirty-seven, and thirty-six.

8:14That column does not vary at all. Not one of the five is onto. And there is a single target that defeats all five of them: two. Two is not a square in any of those sets, and two is not a cube either. One number, five refutations. A few quick companions to that table, all on the same stand-in. Three minus four x: forty-one targets tried, nothing refused, nothing astray — onto.

8:45Three x: the same, forty-one and nothing missing — onto. One plus x squared: forty-one declared and thirty-six unreached, because every output is at least one, so every one of the twenty-four targets below one is out of reach, nought among them. And the fourth power: forty-one declared, thirty-nine unreached, including all twenty negative targets, for the same reason squaring fails. Here is the cleanest case of a co-domain declared carelessly.

9:22A class of fifty students, and the function sending each student to their student number, declared into the counting numbers. It is one-one — no two students share a number, so there are no collisions among the fifty. Is it onto? Read it against a target of eighty numbers. Eighty declared, thirty unreached, and the smallest of those is fifty-one. Fifty-one is nobody's student number, and neither is anything above it.

9:53The range is the fifty numbers from one to fifty. The declared target goes on for ever. So the function fails, and it fails for a reason that has nothing to do with the students or the numbering. It fails because of a decision somebody made when they wrote the function down. Now make a different decision. Declare the target to be the fifty numbers from one to fifty. Fifty declared, unreached: none.

10:24The rule did not change. Not one character of it changed. The same function object went to both readings. That repair is worth pausing on, because it is the thesis of this whole topic in one move: onto is not a property a rule has. It is a property a rule has with respect to a set somebody chose. By now you may have concluded that surjectivity is about the co-domain and the co-domain alone.

10:57It is not, and here is the case that proves it. Take the reciprocal: x goes to one over x, declared from the non-zero reals to the non-zero reals. Onto? Take a target y, not zero. The input one over y is not zero either, so the domain admits it, and its reciprocal is y. Every target is reached. Read it against a stand-in with twenty-two points, chosen so that the reciprocal of every point is another point of the same set.

11:33Twenty-two targets tried, none refused, none astray. Onto. Now shrink the domain, and leave the co-domain exactly where it is. Four of those twenty-two points are counting numbers. Take just those four as the source. Twenty-two targets declared, and eighteen of them unreached. Take the target two. It would need an input of one half, and one half is not a counting number. Same builder, same rule, same declared target set. Eighteen refusals, and not one thing astray — every failure is the domain turning a candidate away at the door.

12:14So surjectivity died from a change to the domain. Nobody touched the co-domain. It stayed one-one throughout, incidentally: no collisions on the wider domain. Shrinking a source cannot create collisions, but it can absolutely destroy coverage. The second diagram at the start covered its target and had a collision, and on a small finite set that feels like a fluke. It is not. Here is the same thing on an infinite set.

12:48A rule in two cases. Send one to one. Send two to one as well. And send everything above two to one less than itself. So the first five inputs go to one, one, two, three and four. It wastes an input at the very start and then walks along one step behind. Is it onto? Take a target y. If y is bigger than one, the input y plus one is above two, so the rule sends it to y. And one is reached from one itself.

13:21Read it: forty-one inputs, forty targets declared, unreached: none. Every target covered. Is it one-one? Collisions: one, and the colliding pair is one and two. Onto, and not one-one, on the same set. There is room to waste an input and still cover everything, because the set is infinite. On a finite set that is impossible — if you waste one input you must miss one target — which is exactly why this feels wrong at first.

13:55Infinity is where the two properties come apart, and this is the cheapest example of it. Back to squaring, declared from the number line to the number line, because there is a question here worth answering properly. Is minus two the output of anything? The reason it is not takes one line: a real number multiplied by itself is never negative. So no input squares to minus two, and the function is not onto.

14:28Read it against the quarter-step stand-in: forty-one targets declared, thirty-six unreached. And of those forty-one, twenty are negative — and every single one of the twenty is unreached. The whole lower half of the declared target is out of reach, all at once, for one reason. The range is the non-negative numbers, and the co-domain is the whole line, so the range fills only half of what was declared. Now watch out for the trap this example sets.

15:02Students say squaring is onto because every real number has a square. That sentence is true and it answers the wrong question. Every real number having a square is what makes squaring a function at all. Onto asks the other direction — whether every real number is a square — and the negatives are not. Whenever you catch yourself checking that outputs stay inside the target, stop: that is not the demand.

15:33Here is a function that arrives with two exclusions built into its declaration, and almost everyone reads them as fine print. They are not fine print. They are the content. The rule sends x to the quotient of x minus two by x minus three. It is declared from the reals with three removed, to the reals with one removed. Take the first exclusion. Why is three not allowed as an input?

16:03Put three in and the bottom of the fraction is nought. The rule has no value there at all. So three leaves the source because the formula breaks. That is a fact about the rule. Now the second exclusion, and it is a completely different kind of reason. Run the method. Take a target y and solve for the input. You get the quotient of three y minus two by y minus one.

16:31That formula is defined for every y except one — and when y is one, there is no input at all. So one leaves the target set because nothing reaches it. That is a fact about coverage. Two exclusions, two entirely different jobs, and neither is decoration. Read it: forty targets declared once one is removed. Forty tried, none refused by the domain, none astray. And the candidate the builder produces is never three itself — nought of the forty land there — which is why the domain never has to turn one away.

17:11It is one-one as well: no collisions among the forty inputs the builder produced. One more warning, and it is the mirror of a warning about the other property. Take the identity function on the counting numbers — the rule that hands each input straight back. Forty targets declared, unreached: none. It is onto, and about as onto as anything gets. Now add it to itself. Every input goes to itself plus itself, which is doubling — the function from the start of this video.

17:48Forty declared, twenty unreached. Three is one of them: three is odd, so nothing doubles to it. Two functions, each of them covering the whole target, and their sum covering only half. Onto is not preserved by adding. And the reason is worth saying, because it is not an accident of this example. Covering a set is a statement about the whole rule at once, and adding two rules makes a third rule whose outputs are somewhere new.

18:20Nothing carries over. If you want to know whether the sum is onto, you have to ask the sum. Finally, the move that makes everything in this video obvious in hindsight. If a function fails to be onto, you can always repair it — not by changing the rule, but by trimming the declared target down to what the rule actually reaches. Do that and the function is onto by construction, because the range and the co-domain have been made the same set by decree.

18:55Here is a case where somebody has already done the trimming for you. Take the rule sending x to the quotient of x by one plus the size of x, declared from the whole number line to the numbers strictly between minus one and one. That declaration looks fussy. It is doing exactly the job we just described. There are two things to check and students almost always do only the first.

19:24First: do the outputs stay inside? The top of that fraction is always smaller in size than the bottom, so yes. Read it over a grid of forty-one inputs: outputs landing outside the declared interval, none. The largest size any output reaches is five sixths. It never gets to one, and it never will. That much only makes it a function into that set. It does not make it onto.

19:54Second, and this is the real work: is every point of the interval reached? Take a target y strictly between minus one and one, and build the input as y divided by one minus the size of y. Read it over fifteen targets across that interval: fifteen tried, none refused, none astray. So it is onto — and it is onto because the target set was declared to be exactly the range and not one point more.

20:27It is one-one too, incidentally: no collisions across the whole grid. So, what it comes to. Onto means every element of the declared target is reached by something. Proving it is two steps: take an arbitrary target, produce an input, and check both that the domain admits it and that it lands. Disproving it is one step: name one unreached element. The verdict belongs to the rule and both sets declared around it, and never to the rule alone.

21:03Doubling is the proof of that: on the counting numbers, twenty of forty targets unreached; on the number line, nothing unreached — the same characters. Changing the co-domain moves the answer, and so does changing the domain: the reciprocal goes from nothing unreached to eighteen unreached with the target set untouched. Do not confuse the range with the co-domain, and do not check the direction that is easy — outputs staying inside the target is what makes it a function, not what makes it onto.

21:42And do not assume the property survives anything. Add the identity to itself and it is gone.