Representing Repeated Operations with Summation and Product Notation

Hello. Last lesson treated a workflow component as a function: it receives an input and produces an output according to a named rule. Real AI systems rarely make only one call or one calculation. A harness may score many candidates, make several model calls, accumulate token costs, or expand branches over several stages.

This lesson gives you two compact ways to write those repeated calculations:

• summation notation for repeated addition;
• product notation for repeated multiplication.

They are common in ML papers because they describe an operation over many items without listing every term individually.

---

Two symbols for repeated work

Suppose a workflow makes $N$ calls, and call $i$ uses $t_i$ tokens. The total token use is:

$$T=\sum _{i=1}^N{t}_i$$

Read this aloud as:

“$T$ equals the sum of $t_i$, as $i$ runs from $1$ through $N$.”

The large symbol $\sum$, capital Greek sigma, means “add a collection of terms.” Its parts have precise jobs:

Part	Meaning in the token example
$\sum$	Add the terms
$i$	The index: a counter identifying the current call
$i=1$	Start at call 1
$N$	Stop at call $N$
$t_i$	The token count for the current call
$T$	The resulting total token count

The bounds are inclusive. Therefore,

$$\sum _{i=1}^4{t}_i=t_1+t_2+t_3+t_4$$

There are four terms, including both the first index value $1$ and the final value $4$.

The corresponding notation for repeated multiplication is capital Greek pi:

$$M=\prod _{i=1}^N{b}_i$$

Read it as:

“$M$ equals the product of $b_i$, as $i$ runs from $1$ through $N$.”

Here $\prod$ means multiply rather than add:

$$\prod _{i=1}^4{b}_i=b_1{b}_2{b}_3{b}_4$$

The layout is deliberately parallel: the lower limit, upper limit, and index work the same way in sums and products. Only the operation changes.

---

Summation: totals across calls, candidates, or steps

A sum represents an accumulated total. In system analysis, it is often the right notation whenever each item makes an additive contribution to a whole.

Suppose an agent runs four model calls with token counts:

$$t_1=900,t_2=1300,t_3=750,t_4=1050$$

Instead of writing the full expansion in the system specification, write:

$$T=\sum _{i=1}^4{t}_i$$

To evaluate it, expand the index one value at a time:

$$T=t_1+t_2+t_3+t_4$$ $$T=900+1300+750+1050$$ $$T=4000$$

So the workflow used $4,000$ tokens in total.

This notation scales. Whether a workflow makes four calls or four thousand, the structure remains:

$$T=\sum _{i=1}^N{t}_i$$

The number $N$ does not need to be known when you first write the model. It may be an input, a configuration limit, or an output of routing logic. The expression says: take every call that occurred, identify its token use, and add those values.

A more realistic cost model

Token usage alone is not always the quantity you ultimately care about. Let:

• $x_i$ be input tokens on call $i$;
• $y_i$ be output tokens on call $i$;
• $p_i^{\mathrm{in}}$ be input-token price for call $i$;
• $p_i^{\mathrm{out}}$ be output-token price for call $i$.

Then total cost can be modeled as:

$$C=\sum _{i=1}^N\left(p_i^{\mathrm{in}}{x}_i+p_i^{\mathrm{out}}{y}_i\right)$$

The parentheses matter. For each call $i$, first calculate its input cost plus output cost. Then sum the costs over all calls.

This is a good example of why an index is useful. The index $i$ identifies the call whose quantities belong together:

$$\text{cost of call }i=p_i^{\mathrm{in}}{x}_i+p_i^{\mathrm{out}}{y}_i$$

The summation accumulates those per-call costs.

A unit check confirms the model:

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

Each parenthesized term is measured in dollars, so their sum is also measured in dollars.

The index changes; other quantities do not

The most frequent reading mistake is substituting into every letter in the expression. Only the symbol named below the summation sign changes.

For example:

$$\sum _{i=1}^{N}p{t}_i$$

has index $i$. During the expansion, $p$ remains fixed while $t_i$ changes:

$$p{t}_1+p{t}_2+\cdots +p{t}_N$$

If $p$ is a common fixed price per token, you may factor it outside the sum:

$$\sum _{i=1}^{N}p{t}_i=p\sum _{i=1}^N{t}_i$$

This compactly states a useful system fact: under a fixed price, total cost is price per token times total token count.

If calls use different models or different prices, retain the call-specific price $p_i$:

$$C=\sum _{i=1}^N{p}_i{t}_i$$

Now each call may have its own token price.

When a sum is and is not appropriate

A sum of latencies is valid when calls occur sequentially:

$$L_{\mathrm{seq}}=\sum _{i=1}^N{\ell }_i$$

where ${\ell }_i$ is the latency of call $i$.

But do not automatically sum latency when calls run in parallel. If three retrieval calls launch together, end-to-end waiting time depends primarily on the slowest branch, not on the sum of all three branch times. The notation should follow the system’s actual execution structure, rather than merely count the components. You will model dependency and execution order explicitly in the next lesson.

---

Product notation: repeated scaling or branching

A product represents a quantity built by multiplying successive factors. This appears when each stage scales, filters, or expands what came from the preceding stage.

Suppose a recursive workflow branches by a different fixed factor at each of three depths:

• depth 1: each active task produces $3$ child tasks;
• depth 2: each child produces $2$ more;
• depth 3: each produces $4$ more.

Let the branching factors be:

$$b_1=3,b_2=2,b_3=4$$

The number of tasks at the third depth is:

$$M=\prod _{i=1}^3{b}_i$$

Expand it:

$$M=b_1{b}_2{b}_3$$ $$M=3\cdot 2\cdot 4$$ $$M=24$$

This is not a total of all calls throughout the workflow. It is the number of terminal tasks produced after all three multiplicative expansion stages. A total across depths usually requires a sum as well; later, geometric series will provide a compact way to model that situation.

A workflow retention example

Products also model repeated retention or reduction. Imagine that a pipeline applies three filters to a candidate pool:

• relevance filter retains $80\%$;
• policy filter retains $90\%$;
• deduplication retains $75\%$.

Write the retention fractions as:

$$r_1=0.80,r_2=0.90,r_3=0.75$$

The overall retained fraction is:

$$R=\prod _{i=1}^3{r}_i$$ $$R=0.80\cdot 0.90\cdot 0.75$$ $$R=0.54$$

Thus the pipeline retains $54\%$ of the original candidates. If it begins with $100$ candidates, the simplified model predicts:

$$100(0.54)=54$$

candidates after all filters.

The product expresses an important systems intuition: several seemingly modest reductions can combine into a substantial overall reduction. Conversely, repeated branching factors can produce rapid growth.

---

Choosing the notation from the workflow meaning

The notation is compact, but it should never hide what is being calculated. Before writing a sigma or product sign, state the per-item quantity in a sentence.

If the workflow asks…	Typical notation	Meaning
“What is the total across calls?”	${\sum }_{i=1}^N{c}_i$	Add each call’s contribution
“How many tokens were used?”	${\sum }_{i=1}^N{t}_i$	Add token counts
“What is total cost with varying prices?”	${\sum }_{i=1}^N{p}_i{t}_i$	Add per-call costs
“How much does each stage multiply the count?”	${\prod }_{i=1}^D{b}_i$	Multiply scaling factors
“What fraction survives every filter?”	${\prod }_{i=1}^D{r}_i$	Multiply retention fractions

There is one further distinction worth keeping clear: multiplying outputs is not the same as executing functions in sequence.

If a workflow stage transforms a state, a sequential pipeline might be described by:

$$z_1=f_1(x)$$ $$z_2=f_2(z_1)$$ $$z_3=f_3(z_2)$$

These equations mean that the output of one function becomes the input to the next. By contrast,

$$\prod _{i=1}^3{b}_i$$

means multiply the numerical factors $b_1$, $b_2$, and $b_3$. Product notation is appropriate only when multiplication is the meaningful operation.

A reliable reading procedure for either notation is:

1. Identify the operation: does the large symbol mean add or multiply?
2. Find the index and bounds: which values does the index take, including both endpoints?
3. Write the first two terms and the last term: this checks that the pattern and limits are understood.
4. Keep all non-index symbols fixed while expanding.
5. Interpret the final unit: tokens, dollars, candidates, or a unitless fraction.

---

Wrap-up

Summation and product notation are compact descriptions of repeated work:

• $\sum$ means add a term for every index value in an inclusive range.
• $\prod$ means multiply a factor for every index value in an inclusive range.
• The index changes; other symbols remain fixed unless they also carry that index.
• Sums naturally model totals such as tokens, costs, and sequential work.
• Products naturally model repeated scaling, branching, and retention.
• The notation must match the workflow’s actual structure, particularly when parallel work is involved.

Next, you will turn a group of workflow equations into a dependency graph, then use that graph to determine which values can be computed first and which outputs depend on them.