What is a Function? Visualizing Input-Output Relationships

Learning Objectives

After this section you will be able to:

1. State what a function is in plain English, then in precise mathematics, and explain why both definitions agree.
2. Read the notation $y = f(x)$ and identify the input, the rule, and the output without confusion.
3. Apply the vertical line test to decide whether any given curve is a function.
4. Find the domain and range of a function from its formula or its graph.
5. Translate between three representations: formula, table of values, and graph.
6. Implement a function in plain Python and in NumPy, and verify the function property in code.

The Problem Functions Were Invented to Solve

How does the position of a thrown ball depend on time? How does the area of a circle depend on its radius? How does my electricity bill depend on the kilowatt-hours I used last month?

Every quantity in science, engineering, economics, and machine learning is tied to other quantities by some rule of dependence. The ball's height depends on time. The circle's area depends on the radius. A neural network's loss depends on its weights. Before we can do calculus on any of these, we need a precise way to write “output depends on input” as mathematics. That precise object is called a function.

Intuition: The Function Machine

Picture a machine with a single slot on the left for the input and a single chute on the right for the output. Drop a number in the slot; the machine grinds for a moment, then spits exactly one number out the chute. Drop the same number in again and the machine returns the same number — every time, forever, without exception. That is what a function is.

The machine's personality is its rule. One machine might square its input. Another might subtract four, then halve. A third might look up a value in a giant table. We do not care how the machine works internally — only that it is deterministic: same input, same output, always.

Interactive — The Function Machine

Pick a rule, then drag the slider. The green dot is your input $x$ sliding along the horizontal axis. The indigo dot rides on the curve, and the amber dot reads off the output $y = f(x)$ on the vertical axis. The green and amber strips show the domain (allowed inputs) and range (reachable outputs).

The Formal Definition

Three words in that sentence are doing all the work. Strike any one of them and the definition collapses.

• each. The rule must produce an answer for every input in the declared domain — no skipped inputs.
• exactly one. The rule must produce one answer per input — never two, never an “either-or.”
• element of Y. The output must live in a declared target set $Y$ (called the codomain). For the calculus we will do this term, the codomain is almost always $\mathbb{R}$ — the real numbers.

Vocabulary you will see again and again:

Three Equivalent Views of a Function

The same function can be described in three completely different languages. A skilled calculus student can flip between them effortlessly — each one makes some questions easy and other questions hard.

View 1 — The formula

The compact, algebraic description:

Tells you the rule in five symbols. Best for computation and for proving things. Useless if you don't know algebra.

View 2 — The table

A finite list of (input, output) pairs:

Tells you the function's behaviour at a handful of points. Best for hand calculations and spotting patterns (notice the symmetry around $x = 0$). Useless if you need information at a point not in the table.

View 3 — The graph

The set of all points $(x, f(x))$ drawn in the plane. For our example this is a parabola opening upward, sliding down to its lowest point at $(0, -4)$ and crossing the x-axis at $(\pm 2, 0)$. The Function Machine visualiser above is one such graph.

The graph is the most visual view — you see the whole shape at a glance. It is also where calculus lives: derivatives are the slopes of tangent lines to graphs, integrals are areas under graphs. The graph is the bridge between algebra and geometry.

The Vertical Line Test

Suppose someone draws a curve in the plane and asks “is this the graph of a function?” The formal check would be: for every input $x_0$, is there exactly one output paired with it? That phrasing is awkward to apply visually.

Here is the geometric reformulation. Fix any vertical line $x = x_0$. The points on the curve that share this x-coordinate are exactly the outputs the curve assigns to $x_0$. The function rule demands at most one output per input. So:

Why “at most” and not “exactly”? Because a vertical line at an $x_0$ outside the domain hits the curve zero times — and zero is fine. The forbidden situation is two or more.

The classic counter-example: the circle

Consider $x^{2} + y^{2} = 1$, the unit circle. At $x = 0$ the equation gives $y^{2} = 1$, so $y = \pm 1$. Two outputs for one input. The circle is not a function of $x$. It is a beautiful curve — it is just not a function.

Interactive — Vertical Line Test

Pick a curve from the gallery, then drag the dashed vertical line. The orange dots are the intersection points. If you ever see two or more orange dots on the same vertical line, the curve fails the test.

Domain and Range

Two halves of a function's identity:

• Domain. The set of inputs the rule is defined on. For $f(x) = \sqrt{x}$ the domain is $[0, \infty)$; negative inputs have no real square root. For $f(x) = 1/x$ the domain is $\mathbb{R} \setminus \{0\}$; zero would require dividing by zero.
• Range. The set of outputs the rule actually produces. For $f(x) = x^{2}$ the range is $[0, \infty)$; squaring can never be negative. For $f(x) = \sin(x)$ the range is $[-1, 1]$; sine is bounded.

Finding the domain is usually a hunt for forbidden moves:

For each constraint you find, exclude the offending inputs. Whatever remains is the domain.

Quick worked drill

Find the domain of $g(x) = \dfrac{\sqrt{x - 1}}{x - 3}$.

1. The square root needs $x - 1 \geq 0$, i.e. $x \geq 1$.
2. The denominator needs $x - 3 \neq 0$, i.e. $x \neq 3$.
3. Combine: $[1, 3) \cup (3, \infty)$. Every input $x \geq 1$ works except $x = 3$.

Worked Example — Tracing a Function by Hand

Before we trust any plot or any script, let us trace one function from formula to table to graph using nothing but a pencil.

Python: Building a Function from Scratch

Mathematics and code mean almost the same thing here: a Python def is a function in our sense, and calling it with f(3) is exactly applying the rule. The snippet below defines $f(x) = x^{2} - 4$, evaluates it at four inputs, prints a table, and verifies the function property with assert statements. Click any line to see the actual values flowing through it.

1def f(x):
2    """The rule: square the input, subtract 4. Domain = all real numbers."""
3    return x * x - 4
4
5# Probe the rule at four inputs we picked by hand.
6inputs = [-2, 0, 1.5, 3]
7
8print(f"{'x':>6}  {'f(x)':>8}")
9print("-" * 18)
10for x in inputs:
11    y = f(x)
12    print(f"{x:>6}  {y:>8.3f}")
13
14# Sanity-check the FUNCTION property: same input -> same output, every time.
15assert f(3) == f(3) == f(3)              # determinism
16assert f(-2) == f(2)                     # different inputs MAY share an output
17assert f(2) != 100                       # but the output is determined
18
19# Forbidden? Not for THIS rule -- every real number is allowed.
20print(f"\nf(1e6) = {f(1e6):.0f}  (domain has no walls)")

Running this prints a four-row table that matches our hand trace, and the three asserts pass silently. Silence is the loudest possible confirmation: every property a function is supposed to have, this code has.

NumPy: Vectorised Evaluation

Plain Python needs a for-loop to evaluate $f$ at many points. NumPy lets us apply the same rule to a thousand inputs in a single line — and the speedup is the foundation of every scientific-computing library you will use later (NumPy, PyTorch, JAX, TensorFlow, scikit-learn).

The key insight is that the same source code we wrote above keeps working. We never touch the function definition — only the input becomes a vector. NumPy quietly broadcasts the rule over every element.

1import numpy as np
2
3def f(x):
4    """Same rule as before, but x can now be a NumPy array."""
5    return x * x - 4
6
7# Build 9 evenly-spaced inputs from -3 to 3 in ONE shot.
8xs = np.linspace(-3, 3, 9)
9print("xs =", xs)
10
11# Apply f to ALL 9 inputs at once -- NumPy broadcasts the rule.
12ys = f(xs)
13print("ys =", ys)
14
15# Confirm the function property element-wise: same xs => same ys
16ys_again = f(xs)
17print("deterministic?", np.array_equal(ys, ys_again))
18
19# Find which x's give the SAME y (the parabola is symmetric).
20for i, j in [(0, 8), (1, 7), (2, 6)]:
21    print(f"f({xs[i]:+.2f}) = {ys[i]:.2f}   f({xs[j]:+.2f}) = {ys[j]:.2f}")

Why This Matters for Calculus

Every concept in the chapters ahead is a question about a function:

• Limits (Chapter 2) ask: what value is the output $f(x)$ approaching as the input $x$ approaches some target?
• Continuity (Chapter 3) asks: can the graph of $f$ be drawn without lifting the pencil?
• Derivatives (Chapter 4) ask: how fast is the output changing per unit change in input?
• Integrals (Chapter 8) ask: what is the total accumulation of $f$ over an interval?
• Differential equations (Chapters 19+) ask: which function $f$ satisfies a given equation relating $f$ and its derivatives?

Without a precise notion of function, none of those questions can even be stated. With it, the whole edifice of calculus becomes a careful study of how outputs respond to inputs — sometimes locally (limits, derivatives), sometimes globally (integrals, equations). The same word — function — supports both.

Common Pitfalls

• Confusing $f$ with $f(x)$. $f$ is the rule; $f(x)$ is a specific output. Writing “differentiate $f$” means differentiate the rule; writing “the value $f(3)$” means a single number.
• Allowing two outputs for one input. The expression $y = \pm\sqrt{x}$ is not a function — for $x = 4$ it returns both $+2$ and $-2$. To get an honest function you must pick a sign: $y = +\sqrt{x}$ or $y = -\sqrt{x}$, but not both.
• Forgetting to state the domain. A formula alone is not a function — it is a function once you commit to a domain. Writing “the function $1/x$” quietly means “on $\mathbb{R} \setminus \{0\}$.” Always know what set your inputs live in.
• Treating the graph as the function instead of as a picture of the function. The graph is a visual aid; the rule is the real object. Two functions with different rules can have visually similar graphs (e.g. $x^{2}$ vs. a narrow gaussian near zero) — only the rule disambiguates.
• Confusing range with codomain. The codomain is where outputs are declared to live (often $\mathbb{R}$). The range is which of those values actually appear. For $\sin$, codomain $\mathbb{R}$, range $[-1, 1]$. The distinction matters when we discuss invertibility.

Summary

• A function $f : X \to Y$ is a deterministic rule sending each input $x \in X$ to exactly one output $f(x) \in Y$.
• Functions live in three interchangeable forms: a formula, a table of (input, output) pairs, and a graph in the plane.
• The vertical line test: a curve is a function of $x$ iff every vertical line crosses it in at most one point.
• The domain is the set of allowed inputs; the range is the set of outputs the rule actually produces.
• Two different inputs may share an output (e.g. $f(-2) = f(2) = 0$) — but a single input may not have two outputs.
• A Python def (or a NumPy expression) implements a function literally — and the function property (same input → same output) is automatically true for pure arithmetic code.