Understanding Function Notation as Input-Output Mapping

Hello. In the previous lesson, you translated deterministic workflow descriptions into equations such as a prompt-token total or a context allowance. An equation describes one relationship; a function gives that relationship a name and makes its input-output behavior explicit.

This is a foundational move for reading AI and ML mathematics. Papers and system specifications constantly name transformations: a cost function, a scoring function, a model function, or a routing function. Today you will learn to read that notation as a precise instruction: provide a particular input, apply a rule, and obtain one output.

---

A function is a named rule

A function is a rule that assigns exactly one output to each allowed, complete input.

The word complete matters. A context manager can reliably calculate an allowance only if all quantities that affect it are supplied or held fixed. Likewise, a model can calculate a score only after it has the inputs required by its scoring rule.

Think of the machine in the image as a named workflow component. It has:

• an input, the value or values supplied to it;
• a rule, the operations performed by the component;
• an output, the result produced by that rule.

For the rule “multiply the input by $4$, then add $7$,” we could name the machine $f$:

$$f(x)=4x+7$$

Read this aloud as:

“$f$ of $x$ equals four $x$ plus seven.”

The symbol $f$ is the name of the function. The $x$ inside the parentheses is the input placeholder. The expression $4x+7$ is the rule for producing the output.

Crucially, $f(x)$ does not mean “$f$ multiplied by $x$.” The parentheses indicate that $x$ is being given to the function $f$.

A valid function may send different inputs to the same output. For example, a rule that rounds a token count to the nearest thousand could map both $1,200$ and $1,450$ to $1,000$. That is fine. The forbidden situation is one input producing two conflicting outputs under the same rule.

---

Reading function notation in a workflow model

Return to the context-manager rule from the last lesson. Suppose these deployment settings are fixed:

• model context limit: $16,000$ tokens;
• system prompt: $900$ tokens;
• safety reserve: $2,000$ tokens.

Let $u$ be the number of tokens in the user message. Let $A(u)$ be the retrieved-context allowance produced when the user message has $u$ tokens.

$$A(u)=16,000-\left(900+u+2,000\right)$$

Simplifying the fixed quantities gives:

$$A(u)=13,100-u$$

This says:

The function $A$ takes a user-message token count $u$ as input and returns the remaining number of tokens available for retrieved context.

Here is how to parse each part:

Notation	Meaning
$A$	The name of the allowance function
$u$	An input placeholder: user-message tokens
$A(u)$	The output of the allowance function for input $u$
$13,100-u$	The calculation rule that produces that output

The definition

$$A(u)=13,100-u$$

is general: it describes what the context manager does for any permitted user-message size $u$.

Evaluating the function

To evaluate a function means to calculate its output for a specified input.

Suppose a request has:

$$u=1,100$$

tokens in its user message. Substitute $1,100$ everywhere the placeholder $u$ appears:

$$A(1,100)=13,100-1,100$$ $$A(1,100)=12,000$$

The complete interpretation is:

For a user message of $1,100$ tokens, the workflow allows up to $12,000$ tokens of retrieved context.

Notice the difference between these statements:

$$A(u)=13,100-u$$ $$A(1,100)=12,000$$

The first is the rule. The second is one evaluated result from that rule.

A dependable evaluation procedure is:

1. Identify the requested input inside the function parentheses.
2. Replace every occurrence of the input placeholder in the rule with that value.
3. Perform the arithmetic, respecting parentheses and order of operations.
4. State what the resulting output means, including its units.

In this example, the output is measured in tokens. That unit check is useful: an allowance in dollars or seconds would signal that you had used the wrong rule or quantity.

---

Inputs, fixed settings, and parameters

The function $A(u)$ treated the system-prompt size, model limit, and safety reserve as fixed. That was a deliberate modeling choice. During a particular deployment, those values may indeed remain unchanged while user-message size varies from request to request.

But suppose the safety reserve also changes by task. Then $A(u)$ is no longer a complete description unless you specify which reserve is being used. The more complete function is:

$$A(u,r)=16,000-\left(900+u+r\right)$$

where:

• $u$ is user-message tokens;
• $r$ is safety-reserve tokens.

Now evaluate the function for a $1,100$-token user message and a $2,000$-token reserve:

$$A(1,100,2,000)=16,000-\left(900+1,100+2,000\right)$$ $$A(1,100,2,000)=12,000$$

The comma means the function receives two inputs. Their order and meaning are part of the definition:

$$A(u,r)$$

means “first supply user-message tokens, then supply reserve tokens.”

This connects directly to the distinctions from the first lessons:

• An input varies across evaluations of a function.
• A parameter is a setting that controls the rule. It may be held fixed for a while, then changed to define a different configured behavior.
• A constant is a value treated as fixed within the current model.
• An output is what the function returns after the calculation.

For an input-cost function, both token count and price might vary:

$$C(n,p)=pn$$

where $n$ is the number of input tokens and $p$ is the price in dollars per token. If:

$$n=1,500,p=0.000003$$

then:

$$C(1,500,0.000003)=1,500(0.000003)=0.0045$$

The output is $0.0045$ dollars. The units validate the calculation:

$$(\text{tokens})\left(\frac{\text{dollars}}{\text{token}}\right)=\text{dollars}$$

A system specification that writes only $C(n)$ is usually assuming that the price has been fixed as a configuration parameter. That assumption may be perfectly reasonable, but function notation makes it worth asking: which quantities are actual inputs, and which ones have been held constant?

---

Functions need not be algebraic formulas

A function is not necessarily an equation. It can also be a lookup table, a configuration rule, or a program procedure, as long as every allowed input has one unambiguous output.

Suppose a harness has three approved retrieval tiers. Let $d(q)$ return the number of documents selected for tier $q$.

Retrieval tier $q$	Documents selected $d(q)$
low	2
standard	5
high	8

From this table:

$$d(\mathrm{standard})=5$$

This is a function because the input “standard” has exactly one output: $5$ documents. The inputs do not need to be numbers. They can be labels, categories, prompts, files, or structured system states.

The key question is always:

Once the complete input is specified, does this rule determine one output?

For AI workflows, this question exposes incomplete specifications. If a routing rule says that the same score can send a request to either a cheap model or an expensive model, the rule is not yet deterministic. Perhaps it is missing a tie-break condition, a latency measurement, or a random selection step. You would either add the missing input or explicitly model the randomness later in the course.

---

Function notation in ML papers

You will often see a compact expression such as:

$$\hat{y}=f_{\theta }(x)$$

Read it in layers:

• $x$ is the input data, perhaps features, an embedding, or a prompt representation.
• $f$ is the model’s transformation rule.
• $\theta$ is a collection of model parameters.
• $\hat{y}$ is the model’s predicted output.

The subscript in $f_{\theta }$ says that the function is governed by a particular parameter setting $\theta$. With those parameters held fixed, giving the model input $x$ produces the output $\hat{y}$.

At this stage, do not treat this notation as mysterious ML-specific machinery. Structurally, it is the same idea as:

$$A(u)=13,100-u$$

Both describe a named transformation applied to an input. The ML expression simply represents a much more complicated rule, whose parameters will eventually be trained or tuned.

One more distinction is useful:

$$f(x)=49-x^2$$

is a function definition. To evaluate it at $x=5$, replace $x$ with $5$:

$$f(5)=49-5^2$$ $$f(5)=24$$

Evaluation asks for the output produced by a known input. The reverse task—starting with an output and searching for possible inputs—is called solving, and it can have more than one answer. For now, keep the direction clear: evaluation starts from an input and computes an output.

---

A compact reading habit

When encountering a function in a paper, notebook, or harness specification, pause and translate it into a sentence.

For example, for

$$C(n,p)=pn$$

say:

“The cost function takes token count $n$ and price per token $p$, then returns total cost.”

For

$$\hat{y}=f_{\theta }(x)$$

say:

“The model with parameters $\theta$ takes input $x$ and returns prediction $\hat{y}$.”

This verbal translation prevents two common errors:

1. treating the parentheses in $f(x)$ as multiplication;
2. overlooking an input or parameter that the output actually depends on.

---

Wrap-up

A function is a named input-output rule. Its central requirement is precise: each complete allowed input must produce one output.

You can now:

• read $f(x)$ as “the output of function $f$ when given input $x$”;
• distinguish a general rule, such as $A(u)=13,100-u$, from a specific evaluation, such as $A(1,100)=12,000$;
• evaluate a function by substituting the given input everywhere the placeholder appears;
• recognize when a changing quantity should be an additional input rather than an unstated assumption;
• interpret compact ML notation such as $\hat{y}=f_{\theta }(x)$ as a parameterized input-output mapping.

Next, you will use summation and product notation to express repeated calculations compactly—for example, total cost across many calls or the combined contribution of many workflow steps.