Functions

Why we care

In both math and programming, we constantly model a situation where one thing depends on another:

• •Your total cost depends on how many items you buy.
• •A password checker returns “accept” or “reject” based on the password.
• •A conversion rule turns Celsius into Fahrenheit.

A function is the cleanest way to describe that dependency.

Core idea (informal)

A function is a rule that takes an input and returns an output.

But math is picky about one key property:

A function must give exactly one output for each input in its domain.

That means:

• •If the input is allowed, the output is determined (no ambiguity).
• •The same input cannot map to two different outputs.

First examples

1) Doubling: input a number, output twice that number.

• •Input: 3 → Output: 6
• •Input: 0 → Output: 0

2) Square: input a number, output its square.

• •Input: −2 → Output: 4
• •Input: 5 → Output: 25

A non-example (not a function)

Suppose we claim a “rule” that maps 1 to both 2 and 3.

• •Input: 1 → Output: 2
• •Input: 1 → Output: 3

This violates the “exactly one output” requirement. So it is not a function.

Function notation

We often name a function with a letter like $f$.

• •$f(x)$ means “the output of function $f$ when the input is $x$.”

Example:

Let $f(x) = 2x$.

• •$f(3) = 2·3 = 6$
• •$f(0) = 0$

Notice the pattern: the parentheses are not multiplication. $f(3)$ is “evaluate $f$ at 3.”

A gentle checkpoint (before formalism)

To decide if something is a function, ask:

1) What are the allowed inputs?

2) For each allowed input, is there exactly one output?

If yes, it’s a function.

Why these sets matter

A big source of confusion is that a “rule” is not complete until you know what inputs it is willing to accept.

Example: $f(x) = \frac{1}{x}$.

• •If we try $x = 0$, we get division by zero, which is not allowed in ordinary arithmetic.

So we need vocabulary for “what inputs are allowed” and “what outputs come out.”

Domain

The domain of a function is the set of inputs you are allowed to plug in.

Examples:

• •For $f(x)=2x$ over real numbers, the domain can be all real numbers (ℝ).
• •For $f(x)=\frac{1}{x}$ over real numbers, the domain is all real numbers except 0.
• •In set notation: domain = {x ∈ ℝ : x ≠ 0}

In discrete math and CS, the domain is often a finite or countable set:

• •domain = {0,1} (bits)
• •domain = strings over an alphabet
• •domain = set of usernames in a database

Range (also called image)

The range is the set of outputs the function actually produces when you feed it every input in the domain.

Example 1:

Let $f(x)=x^2$ with domain ℝ.

• •Outputs are never negative.
• •Range = {y ∈ ℝ : y ≥ 0}

Example 2:

Let the domain be {−1, 0, 2} and define $g(x)=x+1$.

• •g(−1)=0
• •g(0)=1
• •g(2)=3
• •Range = {0,1,3}

Breathing room: domain vs range in one sentence

• •Domain: what you can put in.
• •Range: what you can get out.

A common subtlety (kept light): range vs “all possible outputs”

Sometimes people informally say “range” when they mean “all outputs we intend the function to land in.” In more formal math, there is also the codomain (the target set). To keep difficulty at 1/5, we’ll focus on:

• •Domain (allowed inputs)
• •Range/image (outputs actually produced)

If you later see notation like $f: A \to B$, the set $B$ is often the codomain, while the range is the subset of $B$ that $f$ actually hits. You don’t need that distinction yet to use functions correctly day-to-day.

Function tables and mappings (discrete viewpoint)

In discrete math, a function from a small set can be shown as a table.

Example:

Let domain A = {a,b,c}. Define $f$ by:

This is a valid function because each input appears once and has exactly one output.

Note: multiple inputs are allowed to share the same output (a and b both map to 2). That is still a function.

Why notation matters

Function notation is like a tiny language. If you can read and write it, you can:

• •compute outputs,
• •specify rules precisely,
• •describe algorithms and transformations clearly.

Defining a function with a formula

A common way to define a function is with an equation like:

• •$f(x)=2x+1$

This means: take input $x$, multiply by 2, then add 1.

Evaluate at a specific input:

• •$f(4)=2·4+1=9$

Defining a function with a description

You can also define a function in words, especially in CS.

Example:

• •Input: a string s
• •Output: the length of s

In math, we might call it $\ell(s)$ and write $\ell(\text{"cat"})=3$.

Defining a function by cases (piecewise)

Sometimes a single formula doesn’t cover the rule cleanly. Then we use a piecewise definition.

Example:

Evaluate:

• •|5| = 5 (because 5 ≥ 0)
• •|−5| = −(−5) = 5 (because −5 < 0)

A quick checkpoint: “exactly one output” with piecewise rules

A piecewise rule is still a function if:

• •every input in the domain matches at least one case, and
• •no input matches two conflicting cases.

Example of a problem:

If x = 2, which output should it give—0 or 1? Not a function (as written).

Inputs don’t have to be numbers

In discrete math, inputs and outputs are often objects.

Examples:

• •$f$ maps people → their birthdays
• •$g$ maps files → their sizes (in bytes)
• •$h$ maps web pages → their URLs

The function idea is the same: each input has one associated output.

(Optional mental model) Functions as machines

Imagine a machine labeled $f$:

• •You feed in x.
• •The machine returns f(x).

If you feed in the same x again, you must get the same output again (for a deterministic function).

Why this node unlocks so much

Once you understand “input → output with a rule,” many topics become simple variations:

• •calculus: what happens as inputs approach a point
• •probability: mapping outcomes to numbers
• •recursion: defining outputs in terms of smaller inputs
• •data structures: mapping keys to values

Below are a few concrete connections.

Limits (preview)

In calculus, you study what value a function approaches as the input approaches a point.

Even stating a limit requires function language:

• •“As x approaches 0, what does f(x) approach?”

You can’t talk about that without knowing what $f(x)$ means and what inputs are allowed.

Random variables (preview)

A random variable is literally a function in the math sense:

• •It maps each outcome of an experiment to a number.

Example:

• •Flip two coins.
• •Outcomes: {HH, HT, TH, TT}
• •Define $X$ = number of heads.
• •X(HH)=2, X(HT)=1, X(TH)=1, X(TT)=0

That’s a function from outcomes → {0,1,2}.

Recursion (preview)

A recursive definition defines a function using itself on smaller inputs.

Example idea:

• •factorial: n! = n·(n−1)! with base case 0! = 1

To read that, you must be comfortable with function evaluation and domain restrictions (e.g., nonnegative integers).

Relations vs functions (preview)

A relation can connect an input to many outputs.

A function is a special kind of relation that connects each input to exactly one output.

This is why functions are often introduced early in discrete math: they’re “well-behaved” relations.

Hash tables (preview)

A hash function maps a key (like a string) to a bucket index (like an integer).

• •input: key
• •output: integer index

Even though collisions exist (different keys can map to the same output), it is still a function because:

• •each key maps to exactly one index.

Summary table: how to recognize the “function pattern”

Notice the repeating theme: define the domain, ensure one output per input, then use the notation to compute and reason.