Algebra · 100% marks notes

Method 01 · Reduce before expand

This is the difference between finishing Mⁿ in 40s and still multiplying at minute three.

Do this: Find CH / nilpotent / idempotent relation before multiplying repeatedly.

Method 02 · Det early for systems

Protects you from inventing an inverse that does not exist — a classic Advanced trap.

Do this: Compute det A before discussing solutions.

Method 03 · Tiny matrix test

Turns opaque MC identities into 20-second true/false — toppers use this constantly.

Do this: Kill false identities on a 2×2 numeric example.

Method 04 · Row-op discipline for det

Stops silent sign errors that look like ‘careless arithmetic’ but are really method gaps.

Do this: Track sign on swap; factor on row scale; invariance on adding multiple.

Power / polynomial in M

Looks like: Mⁿ, Mⁿ+Mⁿ⁻¹, f(M) for a polynomial f, sum of powers

Fast model: Write tr, det (or spot I+N / idempotent) → reduce via CH or N²=0 before multiplying.

System AX=B with parameter

Looks like: Solve / discuss solutions; λ in matrix; unique/infinite/none

Fast model: Branch on det A first — never invert blindly.

Identity / Adj / inverse MC

Looks like: (AB)⁻¹, Adj(Adj A), symmetric/skew claims

Fast model: Treat each option as T/F; kill with a tiny 2×2 numeric test if algebra is opaque.

Determinant after ops

Looks like: Evaluate det after row/column operations or with parameters

Fast model: Track sign on swap, factor on scale, invariance on Rᵢ+λRⱼ — then expand once.

Method 01 · Form choice

Choosing polar vs ω vs x+iy in 15s is what makes Complex feel easy instead of messy.

Do this: Pick polar vs Cartesian vs ω before expanding.

Method 02 · Principal value lock

Deletes 2π distractors before you overthink — that is free accuracy.

Do this: State Arg interval before selecting options.

Method 03 · Locus dictionary

Stops you expanding modulus equations when the curve already has a name.

Do this: Rewrite condition into a standard |z−a| / Arg form.

Method 04 · Conjugate discipline

Prevents illegal conjugate moves that create confident wrong answers.

Do this: Replace z̄ using |z|²/z or equation of line/circle carefully.

Principal Arg / modulus value

Looks like: Find Arg z, |z|, Arg(z₁z₂) or Arg(z₁/z₂)

Fast model: Choose polar; lock Arg ∈ (−π,π] before looking at options.

Locus on Argand plane

Looks like: |z−a|=k, |z−a|/|z−b|=k, Arg((z−a)/(z−b))=α

Fast model: Rewrite into a dictionary locus (circle / perp bisector / arc) — do not expand to x,y first.

ω (cube roots of unity) simplify

Looks like: Expression in ω, 1+ω+ω², powers of ω

Fast model: Reduce powers mod 3; replace 1+ω+ω²=0 whenever the sum appears.

De Moivre power / root

Looks like: (r cis θ)ⁿ or nth roots

Fast model: Polar → De Moivre → list distinct roots if asked.

Method 01 · Tree first

If the tree is right, Bayes is arithmetic. If you skip the tree, marks become luck.

Do this: Draw 2–3 branch tree with priors and conditionals before naming Bayes.

Method 02 · Model sentence for counting-P

Keeps numerator and denominator in the same counting world — the #1 P&C-probability leak.

Do this: Write P&C model, then favourable/total.

Method 03 · Independence vs ME audit

One confusion rule saves multi-correct clusters every year.

Do this: For MC, test independence and mutually exclusive as separate T/F.

Method 04 · RV table

Makes variance mechanical so you never ship E(X²) as Var by mistake.

Do this: List x, p(x), xp, x²p in columns.

Bayes / two-source story

Looks like: Two factories/urns/tests; ask P(source | result)

Fast model: Draw a 2–3 branch tree with priors × likelihoods before naming Bayes.

Conditional definition

Looks like: ‘Given that’, P(A|B), restricted sample space

Fast model: Rewrite as P(A∩B)/P(B); redefine the sample space to the given event.

Counting-based probability

Looks like: Cards/committees/digits with probability language

Fast model: Write the P&C model sentence first (order? replacement?), then favourable/total with the SAME model.

Independence vs mutually exclusive MC

Looks like: Which statements true about independent / ME events

Fast model: Two separate T/F lines: ME ⇒ P∩=0; Ind ⇒ P∩=P·P — never conflate.

Discrete mean–variance

Looks like: Random variable table; mean / variance

Fast model: Columns x, p, xp, x²p → E then Var=E(X²)−[E(X)]².

Method 01 · Symmetric first

Trains you to speak Advanced’s language (∑, product) instead of Board-style root hunting.

Do this: Always write ∑ and product before expanding.

Method 02 · Transform then Vieta

Formation questions become template work — that is bankable time.

Do this: For roots α+1/α, compute new sum/product, form equation.

Method 03 · Parameter on D

Turns wordy nature conditions into one inequality you can finish cleanly.

Do this: Translate verbal nature into inequality on D (and sometimes a,c).

Method 04 · Sign conditions for location

Checklist thinking beats vague parabola sketches when options are close.

Do this: Combine D, sum, product, and f(k) signs systematically.

Symmetric function of roots

Looks like: α²+β², α³+β³, 1/α+1/β, α/β+β/α

Fast model: Write ∑α, αβ first — never expand (x−α)(x−β) early.

Nature / parameter on D

Looks like: Find λ so roots real/equal/opposite sign

Fast model: Translate words → inequality on D (and sum/product if sign conditions).

Transformed roots → new equation

Looks like: Roots α+1/α, α², (α+β)/(αβ), … form the equation

Fast model: Compute new ∑ and ∏ from old Vieta; write x²−(∑′)x+∏′=0.

Location of roots

Looks like: Both roots >1, roots in (0,1), one positive one negative

Fast model: Checklist: D, sum, product, and f(k) signs with leading coefficient — not graphs.

Method 01 · General term lock

One template ends almost every coefficient question — expand-all is a time tax.

Do this: Always write T_{r+1} before hunting coefficients.

Method 02 · x=±1 identity factory

Gives coefficient sums without proof theatre under exam pressure.

Do this: Substitute special values to get coefficient sums.

Method 03 · Small-n verify

Kills fake MATCH identities before you waste a matching cluster.

Do this: For MATCH/MC identities, test n=2,3.

Method 04 · Ratio for greatest term

Finds the largest term without computing the whole expansion.

Do this: Find largest r with T_{r+1}/T_r ≥ 1.

Coefficient of x^k

Looks like: Find coefficient in (a+b)ⁿ or product of binomials

Fast model: Write T_{r+1}; set power of x = k; solve r; compute nCr×constants.

Term independent of x

Looks like: (ax^p + b/x^q)ⁿ; independent term

Fast model: Net power of x in T_{r+1} = 0 → solve r.

Coefficient-sum identities / MATCH

Looks like: ∑nCr, alternating sums, relations among Cᵣ

Fast model: Specialise (1+x)ⁿ at x=1 or x=−1; verify fake MATCH with n=2,3.

Greatest term

Looks like: Numerically greatest term in expansion

Fast model: Use T_{r+1}/T_r ≥ 1 inequality to find r — do not compute every term.

Method 01 · Model sentence lock

This sentence is the method. Formulae are only the last line — believe that and P&C changes.

Do this: Write order/replacement/constraint in one sentence before formulae.

Method 02 · Gap / shift transform

Turns scary constraints into ordinary combinations — that feels like a superpower in the hall.

Do this: For consecutive or positivity constraints, redefine variables first.

Method 03 · Case split only when forced

Stops overlapping cases that look almost right but are wrong.

Do this: Partition into disjoint cases; add. Never overlap cases.

Method 04 · Identical-object division

Prevents counting indistinguishable arrangements as distinct.

Do this: If objects are identical in type, divide by factorials of repeats.

Arrange vs choose

Looks like: PINs, rankings, committees, teams

Fast model: One sentence: order matters? → P or × sequential; else C.

Stars-and-bars / integer solutions

Looks like: x₁+…+x_k=n with xi≥0 or ≥1

Fast model: State ≥0 vs ≥1; if ≥1 shift y_i=x_i−1; then C(·,·).

Gap / non-consecutive selection

Looks like: No two adjacent; consecutive seats; gaps

Fast model: Gap transform (y_i=x_i−(i−1)) → ordinary combination.

At least / complement

Looks like: At least one girl; none of type A; complementary counting

Fast model: Try total − unwanted before multi-case ‘at least’ expansions.

Method 01 · Algebra then count

Simplifying first prevents counting a monster expression region-by-region.

Do this: Simplify the expression with laws before assigning numbers.

Method 02 · Region table

Disjoint regions end double-counting — the usual survey-problem failure.

Do this: List disjoint Venn regions and assign values; never double-use overlapping data.

Method 03 · Tiny universe test

False identities die in seconds — use this on every suspicious MC option.

Do this: For identity MC, test both sides on U={1,2,3} with concrete A,B.

Method 04 · Word → sets map

Fixes language errors before arithmetic — ‘neither/only/both’ stops being fuzzy.

Do this: Translate English (‘both’, ‘only’, ‘neither’) into region language before arithmetic.

2-set / 3-set cardinality

Looks like: Survey / |A∪B∪C| / how many like both

Fast model: Inclusion-exclusion with all terms, or fill disjoint Venn regions (centre first).

De Morgan / identity simplify

Looks like: Simplify (A∪B)′ or prove equality of set expressions

Fast model: Apply De Morgan outside-in; verify with a 3-element universe if MC.

Word → region translation

Looks like: Neither / only A / both / at least one

Fast model: Translate English to region language before arithmetic.

Exactly-k region from Venn data

Looks like: Exactly one / exactly two / none of the three

Fast model: Correct multiplicities: exactly-one = Σ|A| − 2Σ pairwise + 3|triple|.

Method 01 · Three-line T/F

Makes equivalence claims honest. This habit alone protects matching and multi-correct.

Do this: Always write R / S / T as separate verdicts with one-line reason.

Method 02 · Counterexample first for ‘which is true’

Faster than full proofs when the relation is oddly defined.

Do this: To kill a property, hunt a minimal counterexample before proving.

Method 03 · Matrix / grid count

Makes counting formulae obvious instead of memorised and swapped.

Do this: Visualise n×n yes/no grid; impose reflexive/symmetric constraints on cells.

Method 04 · Partition translation

Turns abstract R into concrete classes you can count and describe.

Do this: If equivalence, describe classes; counting equivalences ↔ counting partitions when asked that way.

Property audit (R/S/T)

Looks like: Which properties hold? Is R equivalence?

Fast model: Three separate T/F lines with counterexample-to-kill — never ‘two out of three’.

Count reflexive / symmetric relations

Looks like: Number of relations of a type on an n-set

Fast model: n×n yes/no grid → count free cells → 2^(free).

Equivalence ↔ partition

Looks like: Classes / ‘same type’ / number of equivalences via partitions

Fast model: If equivalence, describe classes; counting ↔ partitions when asked that way.

Function type from relation / mapping

Looks like: one-one / onto / invertible / number of functions of a type

Fast model: Decide injection/surjection separately; invertible ⇔ bijective on finite equal sets.

Method 01 · Parameter lock

After a,d (or a,r) exist, the rest of the question is template — that is the scoring feeling.

Do this: Write a,d or a,r on rough sheet before any sum/term formula.

Method 02 · Finite vs infinite gate

Stops illegal infinite-sum applications — a trap that looks like a formula miss.

Do this: For GP sums, explicitly write ‘finite n’ or ‘|r|<1 infinite’.

Method 03 · HP → AP transform

Removes fear of HP by recycling AP skills you already trust.

Do this: Take reciprocals; solve as AP; reciprocate back if needed.

Method 04 · Equation in n

NUM answers are often that n — form the equation cleanly and discard non-natural roots.

Do this: When Sn or Tn given as a number, form equation in n; check n∈ℕ.

Two terms → a,d or a,r → ask

Looks like: T_p and T_q given; find T_n or S_n

Fast model: Lock parameters from two equations before any sum formula.

Infinite GP

Looks like: Dots / infinite series with constant ratio

Fast model: Identify a,r → stamp |r|<1 → S=a/(1−r).

HP via reciprocal AP

Looks like: Harmonic progression terms / means

Fast model: Take reciprocals → solve as AP → reciprocate back if needed.

∑k / ∑k² series

Looks like: Sum of polynomial in k from 1 to n

Fast model: Expand if needed; apply standard ∑ formulae; factor.