Visit  https://brilliant.org/Reducible/ to get started learning STEM for free, and the first 200 people will get 20% off their annual premium subscription.

Chapters:
00:00 Introducing JPEG and RGB Representation
2:15 Lossy Compression
3:41 What information can we get rid of?
4:36 Introducing YCbCr
6:10 Chroma subsampling/downsampling
8:10 Images represented as signals
9:52 Introducing the Discrete Cosine Transform (DCT)
11:32 Sampling cosine waves
12:43 Playing around with the DCT
17:38 Mathematically defining the DCT
21:02 The Inverse DCT
22:45 The 2D DCT
23:49 Visualizing the 2D DCT
24:35 Introducing Energy Compaction
26:05 Brilliant Sponsorship
27:23 Building an image from the 2D DCT
28:20 Quantization
30:23 Run-length/Huffman Encoding within JPEG
32:56 How JPEG fits into the big picture of data compression

The JPEG algorithm is rather complex and in this video, we break down the core parts of the algorithm, specifically color spaces, YCbCr, chroma subsampling, the discrete cosine transform, quantization, and lossless encoding. The majority of the focus is on the mathematical and signal processing insights that lead to advancements in image compression and the big themes in compression as a whole that we can take away from it. 

Animations created jointly by Nipun Ramakrishnan and Jesús Rascón.

References/Additional Resources:
https://www.red.com/red-101/video-chroma-subsampling - great resource on different types of chroma subsampling

http://weitz.de/dct/ - play around with the DCT

https://www.cse.iitd.ac.in/~pkalra/col783-2017/DCT-History.pdf - paper referenced in video

http://www.ee.ic.ac.uk/hp/staff/dmb/courses/DSPDF/00300_Transforms.pdf - a more rigorous signal processing approach to the DCT

https://www.impulseadventure.com/photo/jpeg-huffman-coding.html - great landing point for learning more about how huffman codes work in the context of JPEG

https://www.youtube.com/watch?v=CPT4FSkFUgs&list=PLpsTn9TA_Q8VMDyOPrDKmSJYt1DLgDZU4&ab_channel=DanielHarding - a great playlist I recommend that dives deep into actually implementing a JPEG decoder

This video wouldn't be possible without the open source library manim created by 3blue1brown and maintained by Manim Community.
The Manim Community Developers. (2021). Manim – Mathematical Animation Framework (Version v0.11.0) [Computer software]. https://www.manim.community/

Here is link to the repository that contains the code used to generate the animations in this video: https://github.com/nipunramk/Reducible

All music in the video is from Aakash Gandhi

The Unreasonable Effectiveness of JPEG: A Signal Processing Approach

Painting a cute little flower with mathematical formulas in Google Sheets.
Support this channel by subscribing or on Patreon: https://www.patreon.com/inigoquilez

Google Document with the flower: https://docs.google.com/spreadsheets/d/1zPtl4DpFRb-RANetrK4RrgSH-nuttDo6FdSgNiViKic/edit?usp=sharing
Tutorials on maths , art, SDFs and computer graphics: http://iquilezles.org


Donate: http://paypal.me/inigoquilez
Subscribe: https://www.youtube.com/c/inigoquilez
Support: https://www.patreon.com/inigoquilez
Twitter: https://twitter.com/iquilezles
Facebook: https://www.facebook.com/inigo.quilez

Soundtrack by Khrome:  https://www.facebook.com/KhromeMusic

Painting with Maths in Google Sheets

The maths behind rounding procedural shapes with SDFs. 
Support this channel: https://www.patreon.com/inigoquilez

Tutorials on maths , art, SDFs and computer graphics: http://iquilezles.org

Donate: http://paypal.me/inigoquilez
Subscribe: https://www.youtube.com/c/inigoquilez
Support: https://www.patreon.com/inigoquilez
Twitter: https://twitter.com/iquilezles
Facebook: https://www.facebook.com/inigo.quilez

Soundtrack by Khrome:  https://www.facebook.com/KhromeMusic

Rounding Corners in SDFs

In this video, I introduce the field of graph theory. We first answer the important question of why someone should even care about studying graph theory through an application perspective. Afterwards, we introduce definitions and essential terminology in graph theory, followed by a discussion of the types of graphs you may encounter. We then define several ways to represent graphs as a data structure and finish off the video with a discussion of what types of interesting problems you can ask about graphs to help motivate the ideas in future videos. 

Typo correction: at 5:12 the vertex set V should be {0, 1, 2, 3, 4} instead of {0, 1, 2, 3, 4, 5} (there is no vertex 5). 

Big thanks to Dániel László Bertalan for making the closed captions for this video!

The sudoku example was inspired by this incredible reddit visualization: https://www.reddit.com/r/dataisbeautiful/comments/6ty4vf/visualizing_the_sudoku_connectivity_graph_more_in/

Support: https://www.patreon.com/reducible

This video wouldn't be possible without the open source manim library created by 3blue1brown: https://github.com/3b1b/manim

Here is link to the repository that contains the code used to generate the animations in this video: https://github.com/nipunramk/Reducible

Music: 
October by Kai Engel https://freemusicarchive.org/music/Ka...
November by Kai Engel
https://freemusicarchive.org/music/Ka...
Cobweb Morning by Kai Engel
https://freemusicarchive.org/music/Ka...

Introduction to Graph Theory: A Computer Science Perspective

In this video, we start with an interesting animation of blobby objects which we introduce as metaballs. There's a lot of surprisingly intricate ideas behind making these objects render on a screen. We'll see how folks in computer graphics attempted to solve this problem through a really elegant algorithm called marching squares. Marching squares is a really powerful algorithm that allows you to render any implicit function. But what's even more impressive in my opinion is the many clever shifts in perspective that allowed a vague problems such as this one to be transformed into a clear, well-defined, and solvable problem.

0:00 Introduction
3:29 Circles and Ellipses
4:57 Defining the Problem
6:00 A Guessing Game
8:29 Contours around Two Points
10:35 Sampling The Space
12:32 Breaking Down Cases
15:00 A Clever Optimization
17:20 How Marching Squares Works
18:59 Parallel Marching Squares
20:21 How Do Metaballs Work?
24:59 Marching Cubes
25:58 Some Parting Thoughts

References/Additional Resources:
http://jamie-wong.com/2014/08/19/metaballs-and-marching-squares/ - the initial inspiration for the framework of this video, great introduction to metaballs and how they can be rendered using marching squares.

http://www.geisswerks.com/ryan/BLOBS/blobs.html  - great resource on implementing metaballs and some of the physics inspirations behind implicit functions

Original Marching cubes paper: https://www.researchgate.net/publication/202232897_Marching_Cubes_A_High_Resolution_3D_Surface_Construction_Algorithm 

Sebastian Lague Video on Marching Cubes:
https://www.youtube.com/watch?v=M3iI2l0ltbE

Further reading on polynomial approximations of metaball implicit functions:
https://www.researchgate.net/publication/242914163_Data_Structure_for_Soft_Objects

Implementation Help for Marching Cubes
http://paulbourke.net/geometry/implicitsurf/ 

Excellent lecture by Casey Muratori about Marching Cubes: https://www.youtube.com/watch?v=SDS5gLSiLg0&t=978s

https://courses.lumenlearning.com/physics/chapter/19-4-equipotential-lines/ - some of the physics behind equipotential lines in electric fields

Support: https://www.patreon.com/reducible
Twitter: https://twitter.com/Reducible20

This video wouldn't be possible without the open source library manim created by 3blue1brown and maintained by Manim Community.
The Manim Community Developers. (2021). Manim – Mathematical Animation Framework (Version v0.11.0) [Computer software]. https://www.manim.community/

Here is link to the repository that contains the code used to generate the animations in this video: https://github.com/nipunramk/Reducible

All music in the video is from Aakash Gandhi

How Computers Draw Weird Shapes (Marching Squares)

In 1988, three engineers came together and developed one of the most clever solutions to the problem of detecting when two complex objects collide. Their solution, the Gilbert Johnson Keerthi (GJK) algorithm, named after the authors, made an incredible impact in the fields of robotics, control, and computer graphics. This video is about understanding this ingenious algorithm from first principles.

The video covers a broad range of topics from Minkowski sums and differences to support functions to the full implementation of the 2D GJK algorithm. But what I hope you get out of this is an appreciation of the incredible shifts in perspective that lead to the final algorithm. Coming up with the algorithm is an amazing feat and useful for specific applications, but the overarching problem solving techniques that come through in the journey to the solution is truly invaluable. 

0:00 Introducing the Problem
2:02 Convexity
3:15 Infinite Point Perspective
4:07 Minkowski Sums and Differences
6:37 Triangles inside Minkowski Differences
7:41 Simplexes
8:57 Support Functions
13:05 Core GJK Algorithm: Broad Perspective
17:15 Remaining Key Questions
17:56 How to determine if a point passed the origin?
19:10 The line case
20:41 The triangle case
26:25 GJK Implementation
29:38 Recap and quick note about original GJK paper

This video is supported by a community of Patreons
Special Thanks to the following Patreons:
Burt Humburg
Justin Hiester
Michael Nawenstein
Richard Wells
Sebastian Gamboa
Zac Landis

There's a lot more to the GJK algorithm to learn for those interested. Here are some resources I recommend:
https://www.youtube.com/watch?v=Qupqu1xe7Io - a full walkthrough of how to implement GJK in 3D by Casey Muratori, the game developer/engineer that came up with some of the clever optimizations that I present in this video.
http://www.dyn4j.org/2010/04/gjk-gilbert-johnson-keerthi/ - a really nice writeup on GJK
https://www.youtube.com/watch?v=MDusDn8oTSE - A quick intro to GJK and an implementation in C++
https://www.toptal.com/game/video-game-physics-part-ii-collision-detection-for-solid-objects - solid resource for collision detection in general and goes deeper into the theory.
https://box2d.org/files/ErinCatto_GJK_GDC2010.pdf - an alternative perspective to GJK using barycentric coordinates -- I really wanted to cover this in this video, but it would have been an hour long instead of half an hour long so I'll compromise and give you this resource :)

Support: https://www.patreon.com/reducible
Twitter: https://twitter.com/Reducible20

This video wouldn't be possible without the open source library manim created by 3blue1brown: https://github.com/3b1b/manim

Here is link to the repository that contains the code used to generate the animations in this video: https://github.com/nipunramk/Reducible

Music attributions:
Midsummer Sky by Kevin MacLeod is licensed under a Creative Commons Attribution 4.0 license. https://creativecommons.org/licenses/by/4.0/
Source: http://incompetech.com/music/royalty-free/index.html?isrc=USUAN1100158
Artist: http://incompetech.com/
Luminous Rain by Kevin MacLeod is licensed under a Creative Commons Attribution 4.0 license. https://creativecommons.org/licenses/by/4.0/
Source: http://incompetech.com/music/royalty-free/index.html?isrc=USUAN1100169
Artist: http://incompetech.com/
Prelude No. 23 by Chris Zabriskie is licensed under a Creative Commons Attribution 4.0 license. https://creativecommons.org/licenses/by/4.0/
Source: http://chriszabriskie.com/preludes/
Artist: http://chriszabriskie.com/
All other tracks by Aakash Gandhi

A Strange But Elegant Approach to a Surprisingly Hard Problem (GJK Algorithm)

In this video, we take a look at Big O notation. We go through how Big O notation came about and why it's so useful as a method of measuring efficiency of algorithms. We then go through some examples of you can find the Big O runtime of various algorithms. 

Support: https://www.patreon.com/reducible

This video wouldn't be possible without the open source manim library created by 3blue1brown: https://github.com/3b1b/manim

Here is link to the repository that contains the code used to generate the animations in this video: https://github.com/nipunramk/Reducible

Music: 
October by Kai Engel https://freemusicarchive.org/music/Kai_Engel/Chapter_Four__Fall/Kai_Engel_-_Chapter_Four_-_Fall_-_05_October
November by Kai Engel
https://freemusicarchive.org/music/Kai_Engel/Chapter_Four__Fall/Kai_Engel_-_Chapter_Four_-_Fall_-_08_November
Cobweb Morning by Kai Engel
https://freemusicarchive.org/music/Kai_Engel/Chapter_Four__Fall/Kai_Engel_-_Chapter_Four_-_Fall_-_04_Cobweb_Morning

What Is Big O Notation?

In this video, we take a look at one of the most beautiful algorithms ever created: the Fast Fourier Transform (FFT). This is a tricky algorithm to understand so we take a look at it in a context that we are all familiar with: polynomial multiplication. You will see how the core ideas of the FFT can be "discovered" through asking the right questions. The key insights that are presented in this video is that polynomial multiplication can be improved significantly by multiplying polynomials in a special value representation. The challenge that presents itself is the problem of converting a polynomial from a standard coefficient representation to value representation. 

We see that the FFT is an incredibly efficient recursive algorithm that performs this task, and we also discover that a slightly tweaked FFT (Inverse FFT) can also solve the reverse problem of interpolation. If this video doesn't blow your mind, I don't know what will. 

0:00 Introduction
2:19 Polynomial Multiplication
3:36 Polynomial Representation
6:06 Value Representation Advantages
7:07 Polynomial Multiplication Flowchart
8:04 Polynomial Evaluation
13:49 Which Evaluation Points?
16:30 Why Nth Roots of Unity?
18:28 FFT Implementation
22:47 Interpolation and Inverse FFT
26:49 Recap

Also a subtle mistake that a commenter made me aware of -- at 26:40 instead of replacing w with (1/n * e^{-2 * pi i/ n}), the actual right way to do this is by taking the final output of the IFFT at the end of the recursion and dividing by n. 

So the full change is w = e^{-2 pi i / n} 
And then somewhere outside the scope of the IFFT function ifft_result = 1/n * IFFT(values)

The treatment of the FFT in this video is inspired by several well known references, mainly Introduction to Algorithms (Cormen et al.) and Algorithms (Papadimitriou et al.).

Support: https://www.patreon.com/reducible

This video wouldn't be possible without the open source manim library created by 3blue1brown: https://github.com/3b1b/manim

Here is link to the repository that contains the code used to generate the animations in this video: https://github.com/nipunramk/Reducible

Elegant proof that the matrix used in the proof that (d + 1) points uniquely define a degree d polynomial is invertible: https://math.stackexchange.com/questions/426932/why-are-vandermonde-matrices-invertible

Music:
Lift Motif by Kevin MacLeod is licensed under a Creative Commons Attribution license (https://creativecommons.org/licenses/...)
Source: http://incompetech.com/music/royalty-...
Artist: http://incompetech.com/

All other music by Aakash Gandhi

SVG Attributions:
Earth: Designed by Flat Icons from www.flaticon.com, CC BY 4.0 https://creativecommons.org/licenses/by/4.0, via Wikimedia Commons
GPS: Icons made by https://www.flaticon.com/authors/pause08 from https://www.flaticon.com/
Wireless Comms: Design inspired by https://svgsilh.com/image/297434.html