D422 Discrete Math: Algorithms and Cryptography, catalog number MATH 2840, is the one-CU module covering searching and sorting algorithms, big-O estimates, and number theory and cryptography. It is the third part of the discrete mathematics split from C959, and it is the module that answers two questions computing students actually care about: why is this code slow, and how does anything stay secret.
Two halves that look unrelated and are not
At first glance this module is two subjects stapled together. Sorting and complexity sit on one side, prime numbers and encryption on the other. They belong together because both are about the cost of computation.
Complexity analysis asks how the work grows as input grows. Cryptography takes the same question and turns it into a security argument: an operation that is cheap in one direction and enormously expensive in the other is what makes a system usable and hard to break. Multiplying two large primes is fast. Recovering them from the product is not, at least not with known methods, and that asymmetry is the whole idea.
Reading the module through that lens turns it from two lists into one theme, which matters a great deal when the whole thing is one competency unit and there is no time to learn it twice.
D422 in the C959 arrangement
WGU carries the material in two arrangements. C959 Discrete Mathematics I under MATH 2800 covers this ground inside a four-CU course alongside logic, proofs, set theory, relations, graphs and trees. The split spreads it across D420 Discrete Math: Logic, D421 Discrete Math: Functions and Relations and this module.
Study resources transfer between the arrangements without loss. The competency list and the assessment do not: those belong to the code on your own Degree Plan, so check your Course of Study. Note also that the second discrete course, C960 Discrete Mathematics II, revisits algorithms, big-O, number theory and cryptography at greater depth, which means work done well here pays off directly there.
Trace algorithms by hand or the analysis stays abstract
The reliable way to make complexity intuitive is to run algorithms manually on tiny inputs. Take six unsorted values and perform a binary search by hand on the sorted version, writing every comparison. Then do a linear scan on the same data. The difference in the number of comparisons is the whole lesson, and having produced it yourself makes the logarithmic behaviour something you know rather than something you were told.
Do the same with sorting. Trace an insertion sort on eight elements, writing the array state after each pass. Then trace it on data that is already sorted and on data in reverse order. The three traces produce three very different counts, which is the concrete meaning of best, average and worst case, and students who have written those three traces never again report a single complexity figure without naming the case.
For the number theory half, the manual work is the greatest common divisor algorithm and modular arithmetic. Compute a few by hand. Reduce large exponents modulo a small number using repeated squaring on paper. Twenty minutes of that makes every later cryptography question readable.
A plan sized to one competency unit
Open your Course of Study first, since the competency list and assessment detail live there rather than in the public catalog. Where a performance assessment exists, each scored aspect is judged on its own three-point scale and a score of 2 in each passes the task. Where the instrument is a proctored objective assessment, the preassessment is your diagnostic.
A worked plan with numbers. Four blocks fit one competency unit: searching, sorting, complexity and big-O, and number theory with cryptography. At sixteen to twenty hours total, that is four to five hours per block, and the split inside each should be unusual for a mathematics course: one hour reading, two hours tracing algorithms or computing by hand, and one to two hours on problems. The tracing hours are not practice for the assessment. They are how the concepts become usable.
Where a written task exists, four scored aspects across a 900-word submission is about 200 words each after an opening and a close. In this material the complexity aspects need their counting shown, so keep prose short and put the working in a labelled section where a reader can follow it.
How to present a complexity or number theory answer
Follow your task directions where they set a format. Otherwise this order carries both halves of the module.
| Element | What to write | Common failure |
|---|---|---|
| Input described | What the algorithm receives and how size is measured | Analysing without defining what n counts |
| Trace | The algorithm run on a small input, states shown | Skipping straight to a claim about behaviour |
| Operation count | Comparisons or swaps counted as a function of input size | Naming a class with nothing supporting it |
| Case stated | Best, average or worst, said explicitly | A single figure that silently means worst case |
| Class | The big-O classification, with lower-order terms dropped last | Dropping terms before the count is visible |
| Modular working | Each reduction step shown, not just the final residue | A calculator answer nobody can verify |
| Security statement | What is easy, what is hard, and why that gap matters | Describing a mechanism without naming the asymmetry |
The security statement row is where careful answers separate themselves. A description of how an encryption scheme operates is mechanics. Saying which direction is computationally cheap and which is not, and that the security rests on that difference, is the reasoning the module is teaching.
Habits that make the module stick
- Keep a one-page table of the algorithms you meet, with best, average and worst case in three columns. Fill it in yourself as you go rather than copying one.
- Compute greatest common divisors by hand until the process is automatic. It is short and it underpins the key material.
- Practise modular exponentiation by repeated squaring on paper. It is the operation that makes large-number cryptography feasible.
- Learn what makes a number prime and how primality is checked at a conceptual level, since the whole security argument rests on primes being findable and factoring not being.
- Count comparisons rather than estimating them. Estimation feels faster and produces wrong classes.
- Whenever you name a complexity class, write one sentence saying what happens when the input doubles. That translation is the meaning of the notation.
What Competent looks like in D422
The outcome recorded is Competent or Not Competent. WGU does not issue letter grades or keep an ordinary grade point average, performance assessment work can go back and be resubmitted with no penalty for the earlier attempt, and objective assessments are proctored and yours alone to sit.
Work that passes cleanly here tends to show:
- Input size defined before any analysis begins.
- Counting shown, then simplified, rather than a class asserted.
- The case named every time a complexity figure appears.
- Modular arithmetic worked step by step rather than produced by a tool.
- Cryptographic explanations that name the hard direction as well as the easy one.
The rule on proctored assessments is fixed. We prepare only, with tracing exercises, complexity derivations, modular arithmetic drills and timed sets, plus an honest readiness read. We do not sit or assist during any assessment and we never ask for portal credentials.
Five mistakes that cost time in D422
- Memorising complexity classes per algorithm. The list is short enough to memorise and useless the moment you meet an algorithm not on it. Derive instead.
- Confusing better growth with faster. Constants matter on small inputs, and an answer that ignores the crossover misses the point of the notation.
- Using a calculator for modular arithmetic. The reductions are the content, and hiding them removes the reasoning that is being assessed.
- Describing encryption as scrambling. The mathematics is specific, and a vague description cannot support any claim about why the scheme is secure.
- Treating one competency unit as an afternoon. The module is compact and dense, and it feeds directly into the second discrete course.
How support works on this course
Send your competency list, any preassessment result and any task directions from your Course of Study. What comes back is built around tracing and derivation: worked algorithm traces on small inputs with the counting shown, a complexity table you complete yourself, modular arithmetic and greatest common divisor drills, cryptography explanations that separate mechanics from the security argument, and where a written task exists, a model submission mapped aspect by aspect.
Terms at WGU run six months at a flat rate, so the number of courses closed inside a term is what lowers your effective cost per course. One-CU modules make that visible: finished individually, they move your plan forward at a pace a four-CU course cannot match, and this one sets up the heavier second discrete course that usually follows.
Questions students ask about D422
Is D422 the same as MATH 2840?
How does D422 relate to C959?
Does this module overlap with C960?
Big-O and modular arithmetic in one competency unit?
Send your competency list. You get worked traces with the counting shown, a complexity table you complete yourself, and modular arithmetic drills.
Where D422 sits in WGU's programs
The July 2026 catalog places this code in 1 current WGU program. Open a program page for the complete standard path and term positions. The live Degree Plan remains authoritative after transfer credit, substitutions, and mentor planning.
The assessments, one by one
The public catalog does not publish this course's PA/OA identity or task count. WGU Tutors publishes at most one PA manual per course and only from a WGU-controlled public rubric. Until that source exists, PA help begins from the student's real Course of Study and OA support remains preparation only.