Berkeley CS 70: Discrete Mathematics and Probability Theory
CS 70 is Berkeley's discrete math and probability course, required for the CS major, covering proofs, graph theory, modular arithmetic, RSA, polynomials, counting, and a substantial probability unit. It's the theory gateway and, by reputation, the hardest lower-division course in the major.
Fennie is independent and not affiliated with UC Berkeley. This is an unofficial study guide.
What makes it hard
CS 70 is many students' first proof-based course, and the jump from computation to proof is brutal: homework can take entire weekends, and exam medians are famously low before curving. The probability half punishes anyone who survived the first half on pattern-matching instead of understanding.
What you'll cover
- • Propositional logic and proofs
- • Induction
- • Graph theory
- • Modular arithmetic and RSA
- • Counting and combinatorics
- • Discrete probability and random variables
- • Markov chains
The CS 70 study guide
How to study for Berkeley CS 70, step by step.
- 1
Pre-study proofs before the semester starts
The freely available CS 70 course notes are the classic summer prep among Berkeley students. Getting comfortable with induction, contradiction, and contrapositive before week one removes the worst of the adjustment shock.
- 2
Treat homework as the course
The problem sets are where CS 70 learning actually happens, and they can consume whole weekends. Start them the day they release, work with study groups within course policy, and use office hours and discussion sections relentlessly.
- 3
Do proof reps daily, not weekly
Proof skill compounds like a language. Even 30 minutes of daily problem work beats a single marathon session, and it's the only defense against the pattern-matching trap that the probability half punishes.
- 4
Rebuild the probability half from first principles
When random variables arrive, re-derive expectations and distributions yourself instead of memorizing formulas. Counting and probability are where exam points hemorrhage, so overweight them in your practice.
- 5
Drill past exams before each midterm
CS 70 exam medians are famously low before curving, and past exams from the TBP/HKN archives are the best calibration available. Work them timed and grade your own proofs harshly.
Today
Today's CS 70 plan
What a Fennie Daily Plan looks like for CS 70. Yours is built from your own syllabus and adapts every day to your deadlines and progress.
First plan free, no card required. Fennie is independent and unaffiliated with your school.
FAQ
Is CS 70 the hardest class at Berkeley?
It's routinely nominated for that title among lower-division courses. The difficulty is the proof-based style, not any single topic; students with prior proof exposure find it manageable, while everyone else faces a steep adjustment in the first month.
How do I prepare for CS 70?
Get comfortable with proofs before the semester, especially induction, contradiction, and contrapositive. Working through the freely available CS 70 notes over summer is a common and effective strategy among Berkeley students.
How much time does CS 70 take per week?
Expect 15-20+ hours during problem-set weeks. The homework is where the learning happens, and collaboration within course policy plus office hours are near-essential. Budget for it like a double course during midterm stretches.
More Berkeley courses
CS 61A: The Structure and Interpretation of Computer Programs
CS 61A is Berkeley's legendary intro CS course, taught primarily in Python with excursions into Scheme and SQL. It emphasizes abstraction (higher-order functions, recursion, object-oriented programming, and interpreters) and it's the first course in the CS 61 series that every CS and Data Science student takes.
CS 61B: Data Structures
CS 61B is Berkeley's data structures course, taught in Java, covering lists, trees, hashing, graphs, sorting, and asymptotic analysis. It's the second course in the 61 series and the one most cited in industry-interview prep. Its projects, including the famous build-your-own-world and Gitlet (build a mini Git), are substantial software engineering exercises.
CS 61C: Great Ideas of Computer Architecture (Machine Structures)
CS 61C completes Berkeley's 61 series, going below the abstraction line: C programming, RISC-V assembly, CPU datapaths and pipelining, caches, virtual memory, and parallelism. It's required for the CS and EECS majors and is the course where software students finally see what the hardware is doing.
CS 161: Computer Security
CS 161 is Berkeley's upper-division security course, covering memory-safety attacks and defenses, cryptography, web security, and network security. Its centerpiece is a substantial project sequence, including a famous secure file-sharing system built in Go that students design and defend themselves.