Michigan EECS 203: Discrete Mathematics

EECS 203 is the discrete math requirement for the CS major, covering logic, proofs, set theory, combinatorics, graphs, and an introduction to algorithm analysis. It's typically taken alongside EECS 280, and together they form the gateway pair into the Michigan CS core.

Fennie is independent and not affiliated with University of Michigan. This is an unofficial study guide.

Build my EECS 203 study plan

What makes it hard

For most students it's the first course where answers are proofs, and the transition from computing to arguing is rough — induction in particular takes weeks to feel natural. The homework is long and the exams are conceptual, with counting problems that look easy and aren't, and group homework only helps students who actually fought the problems alone first.

What you'll cover

• Propositional logic and predicates
• Proof techniques and induction
• Set theory and functions
• Combinatorics and counting
• Probability basics
• Graphs and relations
• Big-O and algorithm analysis

The EECS 203 study guide

How to study for Michigan EECS 203, step by step.

1
Fight every homework problem alone first
Group work in EECS 203 only helps after a solo attempt — proofs are learned in the struggle, not in reading a groupmate's answer. Budget time to be stuck.
2
Write induction proofs until the skeleton is automatic
Base case, hypothesis, step — produce the full structure on paper for many problems. Induction anchors both exams, and recognition isn't production.
3
Treat counting as the danger zone
Combinatorics problems read as easy and grade as hard. After solving, re-derive the answer a second way to check the logic — double-counting errors are the course's signature miss.
4
Work old exams from the archive
Michigan keeps past EECS 203 exams accessible, and the conceptual style is consistent. Timed practice with full written justifications is the closest rehearsal available.
5
Keep proof reps daily with Fennie
Upload your EECS 203 materials and Fennie's Daily Plan spreads proof and counting practice across every week between problem sets, with quizzes generated from your actual coursework. Free to start.
Start my EECS 203 plan free

How Fennie helps with EECS 203

Fennie's Daily Plans keep EECS 203's proof skills building daily rather than in pre-deadline bursts — the abstraction needs spacing to settle. Use chat to walk through an induction argument and have the shaky step exposed, and drill counting problems with quizzes generated from your own materials.

FAQ

Is EECS 203 hard at Michigan?

It's a major adjustment more than a brutal course — the first time most students write real proofs. The homework takes long hours early on, then shortens as the proof style becomes familiar. Counting and induction are where exam grades diverge.

Should I take EECS 203 and 280 together?

It's the standard pairing and most students manage it, since 203's math and 280's programming use different muscles. If you're also carrying a heavy fourth course, be honest about total workload — both courses punish falling behind.

How do I get better at proofs in EECS 203?

Write them, badly at first, without looking at solutions. Attempt every homework proof solo before group work, and rewrite any proof you needed help on from a blank page days later. Reading proofs builds familiarity; writing them builds the graded skill.

Pass EECS 203 with a plan, not a cram

Upload your EECS 203 materials and Fennie generates a Daily Plan paced to your deadline — plus chat, flashcards, and quizzes built from the actual course content.

Get started free

More Michigan courses

EECS 183 — Elementary Programming Concepts

EECS 183 is Michigan's intro programming course for students with little or no coding experience, taught in C++ and Python. It's the standard entry point into the CS sequence for students who aren't ready to jump straight into EECS 280, and it ends with an open-ended final team project.

EECS 280 — Programming and Introductory Data Structures

EECS 280 is the second course in Michigan's CS sequence, covering C++ programming in depth: pointers, dynamic memory, container ADTs, polymorphism, and recursion. It's a prerequisite for nearly everything in the CS major and the course where Michigan students first hit serious multi-week projects.

EECS 281 — Data Structures and Algorithms

EECS 281 is Michigan's data structures and algorithms course and the gateway to upper-level CS — most 400-level EECS courses require it. It covers algorithm analysis, sorting, hashing, trees, graphs, and dynamic programming, with large C++ projects graded heavily on runtime performance.

EECS 370 — Introduction to Computer Organization

EECS 370 covers how computers actually execute programs: assembly language, instruction set architecture, pipelining, caches, and virtual memory. It's a core requirement after EECS 280, with projects that include building a simulator and an assembler in C.