In AP Computer Science Principles, equivalence is the property of two or more algorithms, expressions, or statements producing the same result or side effect even though they're written differently (EK AAP-2.L.1), like a for loop and recursion both correctly computing a factorial.
Equivalence is the idea that there's more than one correct way to write code. Two algorithms are equivalent if they produce the same result or the same side effect for every input, no matter how different they look on the page. A loop-based factorial and a recursive factorial are equivalent. So are val = val + val and val = val * 2. Different code, same outcome.
The CED makes two points you have to hold at the same time. First, algorithms can be written in different ways and still accomplish the same task (EK AAP-2.L.1). Second, algorithms that appear similar can yield different results or side effects (EK AAP-2.L.2). So you can't judge equivalence by eyeballing the code. You have to trace it. Equivalence also applies to logic, not just full algorithms. Some conditional statements can be rewritten as equivalent Boolean expressions and vice versa (EK AAP-2.L.3 and AAP-2.L.4). For example, (age ≥ 18) AND (hasID = true) is equivalent to NOT ((age < 18) OR (hasID = false)). That's De Morgan's Law in action, and the exam loves it.
Equivalence lives in Topic 3.9 (Developing Algorithms) in Unit 3: Algorithms and Programming, and it directly supports learning objective 3.9.A: compare multiple algorithms to determine if they yield the same side effect or result. It also feeds 3.9.B, because building new algorithms by combining or modifying existing ones (EK AAP-2.M.1) only works if you can verify the modified version still does the same job. Unit 3 is the biggest chunk of the AP CSP exam, and equivalence questions are a favorite because they test whether you actually trace code instead of pattern-matching on how it looks. The skill also carries straight into your Create Performance Task, where you'll often refactor code and need to confirm your cleaner version behaves identically.
Keep studying AP® Computer Science Principles Unit 3
Side effect (Unit 3)
Equivalence isn't just about return values. Two algorithms are only truly equivalent if they produce the same side effects too, like what gets displayed or which variables get changed. The CED's own wording of 3.9.A says 'same side effect or result' for exactly this reason.
Student-developed algorithm (Unit 3)
When you build your own algorithm by modifying an existing one (EK AAP-2.M.1), checking equivalence is how you confirm your changes didn't break anything. Existing algorithms like finding a max or computing an average are reliable building blocks precisely because you can swap in equivalent versions.
Boolean expressions and conditionals (Unit 3)
Equivalence shows up at the logic level, not just the algorithm level. EK AAP-2.L.3 and AAP-2.L.4 say conditionals can be rewritten as equivalent Boolean expressions and vice versa. De Morgan's Law, where NOT (A OR B) equals (NOT A) AND (NOT B), is the classic exam version of this.
Equivalence is almost always tested as a multiple-choice 'compare these two code segments' question. You'll see pairs like a for-loop factorial versus a recursive factorial, or val + val versus val * 2, and you have to decide whether they produce the same result for all inputs. The trickiest versions use Boolean logic. A question might give you (age ≥ 18) AND (hasID = true) in one algorithm and NOT ((age < 18) OR (hasID = false)) in another, and the right answer requires applying De Morgan's Law to see they're equivalent. The trap answers play on EK AAP-2.L.2, offering code that looks similar but behaves differently on edge cases. Your move is always the same. Trace both versions with concrete inputs, including boundary values, instead of trusting visual similarity. Equivalence also matters on the Create PT, since you may need to explain or revise an algorithm without changing what it does.
Looking alike and being equivalent are completely different things, and the CED splits them into two separate essential knowledge statements. Equivalent algorithms produce the same result for every input even if the code looks nothing alike (EK AAP-2.L.1), like iteration versus recursion for factorial. Similar-looking algorithms can produce different results (EK AAP-2.L.2), like swapping < for ≤ in a loop condition, which changes behavior at the boundary. The exam exploits this confusion constantly. Judge algorithms by tracing their behavior, never by how the code looks.
Two algorithms are equivalent if they produce the same result or side effect for every input, even when the code is written completely differently (EK AAP-2.L.1).
Algorithms that look almost identical can behave differently, so always trace code with actual values instead of judging by appearance (EK AAP-2.L.2).
Conditional statements and Boolean expressions can be rewritten as equivalent versions of each other, and De Morgan's Law is the most common exam example (EK AAP-2.L.3 and AAP-2.L.4).
A for loop and a recursive function can be equivalent. For example, both can correctly compute the factorial of n.
Equivalence must cover side effects too, so two algorithms that return the same value but display or modify different things are not fully equivalent.
When modifying an existing algorithm to build a new one (3.9.B), checking equivalence is how you verify the new version still solves the original problem.
Equivalence is the property of two or more algorithms, expressions, or statements producing the same result or side effect despite being written differently. It's covered in Topic 3.9 (Developing Algorithms) under learning objective 3.9.A.
No. An iterative for loop and a recursive function can be fully equivalent if they produce the same result for every input, like two factorial algorithms. Equivalence is about behavior, not structure (EK AAP-2.L.1).
Not necessarily. EK AAP-2.L.2 specifically warns that similar-looking algorithms can yield different results or side effects, often at boundary cases like swapping < for ≤. This is the most common trap in equivalence MCQs.
Yes. Adding a number to itself always equals multiplying it by 2, so both statements produce the same result for every value of val. This is a classic exam example of equivalence with different-looking code.
A side effect is something an algorithm does beyond returning a value, like displaying output or changing a variable. Equivalence is a comparison between algorithms, and the comparison has to include side effects. Two algorithms with the same return value but different side effects are not equivalent.
Connect this key term to the AP exam workflow: review the course, practice questions, and check related study tools.
Review units, study guides, and course resources.
Check this vocabulary in multiple-choice context.
Apply key concepts in written AP responses.
Estimate the exam score you are working toward.
Review the highest-yield facts before practice.
Put the full course together before test day.