Common Mistakes in Sets & Logic
260 common pitfalls across 65 concepts, including 65 recurring stuck points
These are the pitfalls students hit across all 65 sets & logic concepts, from Set, Element and Subset onward. Each entry names the concept it comes from, so you can tell a slip from a genuine gap and go straight to the explanation.
The procedure for set is the easy part; the trap is counting a repeated entry twice, like calling a 3-element set. Asking "If I rearrange the items or drop a repeat, is it still the exact same object?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Counting a repeated entry twice, like calling a 3-element set — distinct objects collapse, so it has 2 elements.
Thinking and are different sets — order never matters in a set.
Calling a vague group like 'big numbers' a set — a set must be well-defined so membership has a clear yes or no.
The procedure for element is the easy part; the trap is mixing up and . Asking "Am I asking about one single object being inside a set, with only a yes or no answer?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Mixing up and — use for one object in a set, for a set inside a set.
Thinking membership can be partial — an element is fully in or fully out, never halfway.
Writing as — the element is the bare object , not the one-element set .
The procedure for subset is the easy part; the trap is declaring after finding just one common element. Asking "Is every single member of the first set also a member of the second?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Declaring after finding just one common element — every element of must be in .
Forgetting for every set — the empty set is a subset of everything, vacuously.
Confusing with — subset relates two sets; membership relates an object to a set.
The procedure for union is the easy part; the trap is writing a shared element twice in the union. Asking "Does an item belong as long as it is in at least one of the sets?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Writing a shared element twice in the union — the union, being a set, lists each element once.
Confusing (or, combine) with (and, overlap) — union grows or stays the same, intersection shrinks or stays the same.
Sizing a union as when the sets overlap — subtract to avoid double-counting.
The procedure for intersection is the easy part; the trap is including an element found in only one set. Asking "Does an item qualify only if it is in both sets at the same time?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Including an element found in only one set — the intersection holds only members common to both.
Mixing up (both, AND) with (either, OR) — an intersection is never larger than either set, and a union is never smaller than either set.
Writing as 'no answer' when sets share nothing — disjoint sets have intersection , a valid set.
The procedure for complement is the easy part; the trap is computing a complement without naming the universe . Asking "Am I collecting everything in the fixed universe that is NOT in this set?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Computing a complement without naming the universe — fix first, since 'everything else' depends on it.
Confusing with — the complement removes from all of ; set difference removes it from a specific .
Including elements of in — the complement holds only elements NOT in .
The procedure for empty set is the easy part; the trap is writing 'no answer' when a solution set is empty. Asking "Does this collection genuinely contain zero elements?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Writing 'no answer' when a solution set is empty — report , which is a legitimate set.
Treating and as equal — one has 0 elements, the other has 1.
Forgetting that for every set — it is vacuously a subset of everything.
The procedure for cardinality is the easy part; the trap is counting a repeated listing twice, like . Asking "Am I counting how many distinct elements a set has, each once?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Counting a repeated listing twice, like — distinct elements only, so it is .
Using for the union when sets overlap — subtract via inclusion-exclusion.
Confusing cardinality with the number of subsets — elements count linearly, subsets count as .
The procedure for venn diagram is the easy part; the trap is writing each circle's full total in its 'only' region. Asking "Are there overlapping categories whose regions I need to picture and count separately?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Writing each circle's full total in its 'only' region — subtract the overlap first so the both-count is not double-listed.
Forgetting the 'neither' region outside both circles — the universe includes items in no set.
Drawing separate circles when groups can share members — overlapping groups need overlapping circles.
The procedure for logical statement is the easy part; the trap is treating a question or command as a statement. Asking "Can this sentence, in principle, be labeled either true or false (and only one)?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Treating a question or command as a statement — only declarative sentences with a truth value qualify.
Calling an open sentence like '' a statement — it needs a value or quantifier to have a fixed truth value.
Assuming 'true for me' counts — a statement must be objectively true or false, not a matter of opinion.
The procedure for negation is the easy part; the trap is negating 'all are' as 'none are'. Asking "Is this new statement true in exactly the cases where the original is false?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Negating 'all are' as 'none are' — the negation of is , 'at least one is not.'
Treating an extreme opposite as a negation — is 'not tall', not 'short.'
Mishandling double negation — returns to , not something stronger.
The procedure for conjunction is the easy part; the trap is declaring true when only one part is true. Asking "Does the whole claim require every part to be true at the same time?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Declaring true when only one part is true — both parts must be true.
Swapping (and, all required) with (or, one suffices) — conjunction is the strict one.
Reading 'and' in everyday loose ways — in logic, even one false part makes the conjunction false.
The procedure for disjunction is the easy part; the trap is reading logical 'or' as exclusive. Asking "Is the claim true as soon as at least one part is true?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Reading logical 'or' as exclusive — is true even when both parts are true.
Declaring false because only one part is true — one true part is enough.
Swapping (one suffices) with (all required) — disjunction is the permissive one.
The procedure for conditional statement is the easy part; the trap is calling false when is false. Asking "Is the claim broken only when the hypothesis is true yet the conclusion is false?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Calling false when is false — a false hypothesis makes the conditional vacuously true.
Confusing with its converse — they are not logically equivalent.
Reading 'P only if Q' as 'if Q then P' — 'P only if Q' is , not .
The procedure for contrapositive is the easy part; the trap is negating without reversing, giving the inverse . Asking "Did I negate BOTH parts AND reverse their order, keeping the same truth value?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Negating without reversing, giving the inverse — the contrapositive must reverse too.
Reversing without negating, giving the converse — neither is equivalent to the original.
Forgetting the equivalence — the contrapositive always shares the original's truth value, so proving it proves the original.
The procedure for biconditional is the easy part; the trap is proving one direction and calling it 'iff'. Asking "Are both statements true together and false together, in every case?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Proving one direction and calling it 'iff' — a biconditional needs AND .
Confusing with — the biconditional is symmetric; the conditional is not.
Thinking true means both are true — it is true when both are false too, as long as they match.
The procedure for truth table is the easy part; the trap is listing fewer than rows. Asking "Am I listing every possible T/F combination of the inputs and the output for each?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Listing fewer than rows — every combination of the inputs must appear exactly once.
Confirming an equivalence from a few favorable rows — you must check all rows for a counterexample.
Mis-ordering or repeating input combinations — use a systematic count so no case is missed or doubled.
The procedure for quantifiers is the easy part; the trap is negating 'for all' as 'for none'. Asking "Am I claiming a property for every element or for at least one element?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Negating 'for all' as 'for none' — is , 'at least one fails.'
Thinking one example proves a claim — a universal needs every case; one example only proves .
Swapping mixed quantifier order — and can mean different things.
The procedure for abstraction is the easy part; the trap is discarding a detail that was actually essential. Asking "Am I keeping only the features common to many cases and discarding the rest?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Discarding a detail that was actually essential — keep features that change the answer; drop only the irrelevant ones.
Confusing abstraction with vagueness — abstraction is precise about what is shared, not just hand-waving.
Abstracting too early before seeing enough cases — gather examples first, then extract the shared structure.
The procedure for representation is the easy part; the trap is treating a graph, table, and equation of the same rule as different ideas. Asking "Am I encoding the same idea in a chosen format, knowing other formats encode it too?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Treating a graph, table, and equation of the same rule as different ideas — they encode one relationship.
Sticking to one representation when another makes the structure obvious — switch formats to expose features.
Confusing the representation with the idea itself — the map is not the territory; many maps fit one idea.
The procedure for mathematical modeling is the easy part; the trap is picking the model that is easiest to compute instead of the one matching the situation. Asking "Am I being asked to invent the relationship between real-world quantities, not just compute with one already given?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Picking the model that is easiest to compute instead of the one matching the situation - match constant-amount change to linear and constant-percent change to exponential.
Forgetting to state assumptions, so the model silently ignores real effects - write down what you are treating as constant or negligible before trusting the output.
Trusting a fitted model far outside the data range - extrapolation magnifies the wrong structure choice.
The procedure for assumptions is the easy part; the trap is leaving assumptions unstated so the reader cannot see when the result breaks. Asking "Is this a statement I am accepting as true to start, rather than something I must prove or a rule the answer must satisfy?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Leaving assumptions unstated so the reader cannot see when the result breaks - write each granted condition out loud before proceeding.
Treating an assumption as a proven fact - an assumption can be false, which is why conclusions are conditional on it.
Confusing an assumption with a constraint the answer must obey - assumptions feed the reasoning; constraints filter the result.
The procedure for constraints (meta) is the easy part; the trap is solving freely and ignoring a stated limit. Asking "Is this a rule that disqualifies otherwise-valid answers, leaving only the ones that satisfy it?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Solving freely and ignoring a stated limit - check every candidate answer against all constraints, not just one.
Treating a constraint as the thing to optimize - constraints fence the region; the objective picks the best point in it.
Forgetting implicit constraints like 'a count must be a non-negative whole number' - real quantities carry boundaries even when unstated.
The procedure for simplification is the easy part; the trap is cancelling a factor without noting where it was zero. Asking "Am I making this easier to read while keeping the result that actually matters unchanged?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Cancelling a factor without noting where it was zero - only for .
Dropping a term that changes the answer - simplification must stay equivalent, not just look shorter.
Confusing simplifying with solving - simplifying rewrites the expression; solving produces a value.
The procedure for idealization is the easy part; the trap is forgetting the idealized answer is a fiction. Asking "Am I replacing a messy real object with a flawless idealized version to make the math workable?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Forgetting the idealized answer is a fiction - check whether the erased feature (friction, air) actually matters before trusting the number.
Idealizing away the very effect being studied - you cannot model friction's heat on a frictionless surface.
Confusing it with simplification - idealization removes physical features, simplification removes symbolic clutter.
The procedure for edge cases is the easy part; the trap is testing only typical inputs. Asking "Am I deliberately testing the extreme or special inputs where a formula or argument might behave differently?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Testing only typical inputs - a rule that works for can still break at or the empty case.
Ignoring the boundary value itself - check whether the endpoint is included or excluded, not just the interior.
Confusing an edge case with a counterexample - one probes behavior, the other disproves a universal claim.
The procedure for counterexample is the easy part; the trap is giving a confirming example and thinking it proves the claim. Asking "Am I trying to kill a universal claim by exhibiting one case that fits the hypothesis but breaks the conclusion?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Giving a confirming example and thinking it proves the claim - one supporting case cannot establish a universal statement.
Producing a case that fails the hypothesis - a valid counterexample must satisfy the 'if' part and break the 'then' part.
Trying to disprove a claim that was only about 'some' - a counterexample refutes 'for all', not an existence claim.
The procedure for invariance is the easy part; the trap is saying invariant without naming the transformation. Asking "Is there a quantity that stays exactly the same every time the given transformation is applied?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Saying invariant without naming the transformation - a quantity is invariant under a specific operation, not absolutely.
Assuming an obvious quantity is preserved - verify it survives every application before relying on it.
Confusing the invariant with the whole object's symmetry - one tracks a preserved value, the other a self-mapping figure.
The procedure for symmetry (meta) is the easy part; the trap is calling a graph 'symmetric' without saying about what. Asking "After the given transformation, does the entire object land exactly on itself?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Calling a graph 'symmetric' without saying about what - name the axis or point: -axis (even), origin (odd), or a line.
Confusing even and odd symmetry - even is (mirror), odd is (half-turn).
Assuming symmetry simplifies work without verifying it - test the transformation actually leaves the object unchanged first.
The procedure for structure recognition is the easy part; the trap is forcing a pattern that does not fit. Asking "Does this unfamiliar-looking problem actually share the skeleton of a family I already know how to solve?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Forcing a pattern that does not fit - verify every part of the template actually appears before applying its method.
Recognizing the family but misidentifying the pieces - pin down exactly what plays the role of and .
Confusing recognizing a structure with generalizing one - recognition classifies an instance; generalization extends a rule.
The procedure for generalization is the easy part; the trap is generalizing from a few confirming cases without proof. Asking "Am I taking a specific result and widening it to cover a whole class by removing restrictions or introducing variables?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Generalizing from a few confirming cases without proof - a pattern true for small can fail later, so justify it.
Over-generalizing past where the result holds - check the broadened claim still has needed hypotheses.
Confusing generalizing with specializing - generalizing removes restrictions, specializing imposes specific values.
The procedure for specialization is the easy part; the trap is substituting values into the wrong general formula. Asking "Am I taking a general formula or theorem and feeding it specific values for a single concrete case?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Substituting values into the wrong general formula - first recognize the correct family, then specialize.
Mismatching which symbol gets which value, especially signs - read off carefully, e.g. not .
Confusing specializing with generalizing - specializing imposes specific values, generalizing removes restrictions.
The procedure for decomposition is the easy part; the trap is splitting into parts that secretly depend on each other. Asking "Can I split this into simpler subproblems that each be solved on their own?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Splitting into parts that secretly depend on each other - decomposition needs independent subproblems.
Forgetting to recombine the pieces - solving the parts is only half the job; reassemble for the final answer.
Confusing decomposition with simplification - decomposition partitions a problem, simplification tidies one expression.
The procedure for recomposition is the easy part; the trap is assuming recomposition is just adding. Asking "Have I already solved the pieces, and is my job now to fit them into one whole with matching seams?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Assuming recomposition is just adding - check that boundary conditions and continuity between parts actually match.
Dropping a piece or a constant during reassembly - account for every sub-result, including integration constants.
Confusing recomposition with decomposition - recomposition rebuilds the whole, decomposition splits it apart.
The procedure for equivalence classes is the easy part; the trap is grouping by a relation that is not reflexive, symmetric, and transitive. Asking "Am I grouping all elements 'the same' under a reflexive, symmetric, and transitive relation?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Grouping by a relation that is not reflexive, symmetric, and transitive - only a true equivalence relation makes clean classes.
Letting classes overlap - distinct equivalence classes are always disjoint; an element belongs to exactly one.
Confusing one class with the whole partition - is one block; the partition is all blocks together.
The procedure for consistency (meta) is the easy part; the trap is confusing consistency with completeness. Asking "Can every statement in this set be true at the same time without forcing a contradiction?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Confusing consistency with completeness - consistency forbids contradictions; completeness requires every truth be provable.
Ignoring a hidden contradiction because each rule looks fine alone - check the rules together, not one by one.
Trusting conclusions from an inconsistent set - from a contradiction every statement is derivable, so the system is meaningless.
The procedure for completeness (intuition) is the easy part; the trap is confusing completeness with consistency. Asking "Does this system prove every true statement it can express, leaving no true-but-unprovable gaps?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Confusing completeness with consistency - consistency forbids contradictions, completeness requires every truth be provable.
Mixing up completeness and soundness - completeness: true implies provable; soundness: provable implies true.
Assuming a consistent system must be complete - Gödel showed rich systems can be consistent yet incomplete.
The procedure for ambiguity is the easy part; the trap is solving one reading and ignoring the other. Asking "Could a careful reader validly interpret this in two different ways that give different answers?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Solving one reading and ignoring the other - flag both interpretations or demand clarification before answering.
Blaming the reader for an ambiguous statement - the fix is clearer notation/wording, not harder reading.
Confusing ambiguity with notation overload - ambiguity is two readings of a statement, overload is one symbol with many meanings.
The procedure for notation overload is the easy part; the trap is applying the first meaning you learned everywhere. Asking "Is one symbol being used with different meanings in different contexts, decoded by context?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Applying the first meaning you learned everywhere - read the context to pick which definition the symbol carries here.
Confusing overload with ambiguity - overload resolves cleanly by context; ambiguity may have no single right reading.
Assuming a symbol's behavior carries over - as absolute value does not act like as cardinality.
The procedure for conceptual compression is the easy part; the trap is compressing before understanding the steps. Asking "Am I packaging a whole multi-step procedure into one mental object I can manipulate as a single unit?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Compressing before understanding the steps - is only useful once you know what sum it stands for.
Confusing compression with abstraction - compression hides known detail in a unit, abstraction discards detail to generalize.
Forgetting how to unpack the chunk - keep the ability to expand back to its terms when needed.
The procedure for reasoning vs computation is the easy part; the trap is reaching for the last formula you practiced without checking it fits this structure. Asking "Am I about to execute a procedure without having decided why that procedure is the right one here?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Reaching for the last formula you practiced without checking it fits this structure — first name the structure, then choose the method.
Treating a long correct calculation as proof you reasoned well — a clean computation of the wrong quantity is still wrong.
Skipping the 'why does this method apply' step because the arithmetic feels productive — productive arithmetic on the wrong setup wastes the most time.
The procedure for proof (intuition) is the easy part; the trap is accepting a pile of confirming examples as the intuition. Asking "Do I have a chain of reasoning that forces the conclusion, beyond just examples that happen to work?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Accepting a pile of confirming examples as the intuition — verify you have a reason that applies to ALL cases, not just the ones you tried.
Writing formal proof symbols before you can say in words why it's true — get the intuitive chain first, then formalize.
Confusing intuition that the result is plausible with intuition that it's forced — only the 'must be true' kind can become a proof.
The procedure for explanation vs derivation is the easy part; the trap is handing in a derivation when asked to explain. Asking "Am I being asked to make the result feel reasonable, or to produce it through verifiable steps?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Handing in a derivation when asked to explain — add the conceptual picture, not just the algebra that lands on the formula.
Calling a vivid analogy a derivation — an explanation persuades, but only verifiable steps derive.
Assuming correct steps automatically convey understanding — check whether a reader could say why the result is reasonable afterward.
The procedure for conceptual dependency is the easy part; the trap is drilling the stuck topic harder instead of repairing the missing prerequisite. Asking "Is the later idea literally incoherent without the earlier one, or just usually taught after it?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Drilling the stuck topic harder instead of repairing the missing prerequisite — trace the dependency arrow backward first.
Treating textbook chapter order as the dependency graph — verify the later idea actually requires the earlier one logically.
Assuming all prerequisites are equally important — find which missing edge actually blocks understanding before reteaching everything.
The procedure for transfer of ideas is the easy part; the trap is transferring on surface resemblance alone. Asking "Does the new situation share the underlying structure of something I can already solve, not just its surface look?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Transferring on surface resemblance alone — confirm the underlying structures actually match before reusing the method.
Copying a technique without adapting it — transfer usually requires reshaping the method to the new domain's rules.
Re-deriving from scratch in every new area — pause to ask whether a known structure already covers this.
The procedure for analogical reasoning is the easy part; the trap is trusting an analogy as proof. Asking "Am I concluding something about a new case because it maps onto a known case with the same structure?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Trusting an analogy as proof — always verify the analogical conclusion, since the mapping can fail.
Mapping the wrong correspondence — make sure the parts of the two situations line up structurally before concluding.
Ignoring where the analog and the new case differ — a single mismatched feature can break the predicted behavior.
The procedure for multiple viewpoints is the easy part; the trap is staying in one representation when stuck. Asking "Could a different representation of this same object make the feature I need obvious?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Staying in one representation when stuck — deliberately convert to a graph, table, or alternate form to expose hidden features.
Assuming a feature is absent because one form hides it — the object's properties are the same across all valid representations.
Switching views carelessly so the new form isn't equivalent — each viewpoint must represent the SAME object.
The procedure for hidden variables is the easy part; the trap is jumping from correlation to causation. Asking "Could an unmeasured third factor be driving both variables I'm relating?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Jumping from correlation to causation — ask whether a hidden third variable could explain both before claiming a cause.
Assuming your model is complete because it fits the data — a confounder can produce a great fit for the wrong reason.
Conditioning on the wrong things — to expose the truth, condition on the suspected hidden variable , not on more of the same.
The procedure for dimensional reasoning is the easy part; the trap is trusting a formula by its numbers alone. Asking "Do the units on both sides of the equation reduce to the same thing?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Trusting a formula by its numbers alone — check the units balance on both sides first.
Adding quantities of different dimensions — only like dimensions can be added or equated.
Forgetting that exponents and arguments of functions must be dimensionless — needs to have no units.
The procedure for scaling laws is the easy part; the trap is scaling area or volume by the length factor. Asking "When I multiply length by , does the quantity multiply by , , , or another power?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Scaling area or volume by the length factor — area scales by the factor squared, volume by it cubed.
Confusing scaling (a power of a size factor) with exponential growth (a base raised to a variable) — check whether the variable is the base or the exponent.
Forgetting strength-to-weight changes with size — cross-section () and weight () don't scale together.
The procedure for limiting cases is the easy part; the trap is trusting a formula from a middle value alone. Asking "Does the formula still make sense when I push a parameter to zero, infinity, or its critical value?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Trusting a formula from a middle value alone — test the extremes where errors surface.
Confusing a limiting CASE (a sanity check at an extreme) with the formal LIMIT (an exact computed value) — one screens, the other computes.
Forgetting to check both ends — a formula can behave at zero yet break at infinity.
The procedure for robustness is the easy part; the trap is calling a method robust because it's accurate on clean data. Asking "If the assumptions are slightly violated, does the result stay approximately correct?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Calling a method robust because it's accurate on clean data — test it with outliers and broken assumptions.
Confusing robustness with sensitivity — robustness is the property (survives), sensitivity is the measure (how much it moves).
Defaulting to the mean for messy data — prefer a robust statistic like the median when outliers are likely.
The procedure for sensitivity (meta) is the easy part; the trap is reporting the raw output change as sensitivity. Asking "Am I measuring how much the output moves PER unit change in the input?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Reporting the raw output change as sensitivity — divide by the input change to get the ratio.
Ignoring low-sensitivity inputs entirely — they're cheap to estimate, but identifying them is the point of the analysis.
Confusing sensitivity (the measure) with robustness (the property) — high sensitivity is what makes a result NOT robust.
The procedure for conceptual bottlenecks is the easy part; the trap is reteaching each stuck topic separately. Asking "Would fixing this one idea unblock MANY downstream topics, not just a single successor?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Reteaching each stuck topic separately — look for one shared gateway idea that unblocks them all.
Treating a low-impact prerequisite as a bottleneck — a true bottleneck blocks many topics, not one.
Fixing downstream symptoms while the gateway stays broken — repair the high-out-degree node first.
The procedure for mental models is the easy part; the trap is keeping a model that gives wrong predictions because it feels natural. Asking "Does the internal picture I'm using actually predict this concept's behavior correctly?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Keeping a model that gives wrong predictions because it feels natural — test the model and replace it when it fails.
Confusing the internal model with the external representation — the picture in your head isn't the same as the graph on paper.
Reasoning from a model without checking it against the definition — intuition must agree with the formal meaning.
The procedure for concept networks is the easy part; the trap is studying topics as isolated islands. Asking "Am I mapping ALL kinds of links (dependence, analogy, application) among ideas, not just the prerequisite chain?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Studying topics as isolated islands — look for the edges connecting each idea to others.
Mistaking the network for a single prerequisite chain — it also has analogy and application links.
Memorizing nodes without the connections — the links, not the isolated facts, make the knowledge usable.
The procedure for error analysis is the easy part; the trap is reporting an answer without its uncertainty. Asking "Am I quantifying how large my answer's error could be and how input errors grow through the steps?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Reporting an answer without its uncertainty — pair the number with how far off it could be.
Claiming more precision than inputs allow — the output can't be more precise than its least-precise input.
Ignoring how errors compound — uncertainty grows through multiplication and repeated steps, it doesn't stay fixed.
The procedure for meaning preservation is the easy part; the trap is multiplying both sides by an expression that could be zero. Asking "Does this step leave the statement true in exactly the same cases as before?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Multiplying both sides by an expression that could be zero — it can erase or invent solutions, so it isn't meaning-preserving.
Squaring both sides without checking — squaring can introduce extraneous solutions; verify each answer afterward.
Applying a non-one-to-one function and assuming equivalence — only reversible operations preserve the solution set.
The procedure for mathematical elegance is the easy part; the trap is equating short with elegant. Asking "Does this approach reach the goal with striking simplicity that also illuminates WHY it works?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Equating short with elegant — a cryptic trick that hides its reasoning isn't elegant.
Choosing brute force when a clarifying idea exists — prefer the approach that reveals the structure.
Confusing elegance with rigor — a beautiful sketch still needs to be made airtight to count as a proof.
The procedure for proofs is the easy part; the trap is treating confirming examples as a proof. Asking "Does my argument guarantee the claim for EVERY case via valid inference, not just confirm examples?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Treating confirming examples as a proof — a universal claim needs an argument covering every case.
Leaving a gap in the inference chain — every step must follow by a valid rule from axioms or prior results.
Assuming the converse holds because the statement does — prove each direction separately.
The procedure for mathematical communication is the easy part; the trap is using a variable like without ever saying what it stands for. Asking "Could a reader who is not me follow this from the written words and symbols alone, with no verbal help?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Using a variable like without ever saying what it stands for - introduce every symbol with 'let... be...' before its first use.
Writing only equations with no connecting words - add 'because', 'so', and 'therefore' so a reader sees why each line follows.
Stopping at the last computation without stating the conclusion - end with an explicit sentence naming what you proved.
The procedure for proof techniques is the easy part; the trap is defaulting to one favorite technique for every problem. Asking "Have I matched the strategy to the claim's form before starting to write the proof?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Defaulting to one favorite technique for every problem - read the claim's structure first; the form tells you which tool fits.
Confusing the technique (the strategy) with the proof (the executed argument) - the technique is your choice of road, not the trip itself.
Picking contradiction when direct proof works - prefer the most direct route; only assume the negation when forward reasoning has no foothold.
The procedure for direct proof is the easy part; the trap is secretly assuming the conclusion and reasoning toward the hypothesis. Asking "Can I start from the hypothesis and reach the conclusion using only forward steps, never assuming the conclusion is false?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Secretly assuming the conclusion and reasoning toward the hypothesis - in a direct proof is the destination, never an assumption.
Skipping the definition of the hypothesis - unpack what actually means (e.g. 'even' means ) so you have material to work with.
Treating one worked example as the proof - a direct proof must use an arbitrary object satisfying , not a single number.
The procedure for proof by contradiction is the easy part; the trap is negating only part of the claim. Asking "Did I assume the claim is FALSE and then derive a genuinely impossible statement from it?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Negating only part of the claim - the negation of 'for all , ' is 'there exists with not ', so flip quantifiers carefully.
Ending at a strange-but-true statement and calling it a contradiction - you must reach something logically impossible, like or an integer that is both even and odd.
Confusing it with contrapositive - contradiction assumes the negation of the WHOLE claim and seeks any impossibility; contrapositive only flips an implication and stays direct.
The procedure for mathematical induction is the easy part; the trap is forgetting the base case. Asking "Is the claim indexed by all integers , with each case reachable from the one before it?" first is what keeps a correct-looking calculation from being attached to the wrong concept.
Forgetting the base case - without tipping the first domino, the chain proves nothing even if the step is valid.
Proving only specific cases instead of the general step - you must show for an arbitrary , not for .
Failing to actually use the inductive hypothesis - the step must invoke 'assume ' to derive , or it is not an induction proof.