When we come to compress images
in the real world,

we do this quite a lot.

So, when I took this the original image,

I actually had a perfect
representation of the image,

at least at that particular scale:

I had a tiff.

The file format there means
that every single pixel in the file

is registered as either being
on or off, black or white.

On the left-hand side,
you can see what happens

if I use my unfortunately non-patented
compression algorithm,

where here, instead of compressing it
using 10x10 grids,

I do a much less aggressive compression

where I only take little 3x3 grids.

If you compare how ugly
the 10x10 grid compression is,

to the 3x3 grid compression,

you might think,
"Hey, that's pretty good."

And, in fact, by doing that,
by going from a grid that's 1x1,

by keeping track of every pixel,

and instead going to a grid that's 3x3,

I decreased the file size
by a factor of 9.

What I also can do is take that tiff file,

open it up, and max preview,

and now ask the computer
to do some coarse graining for me.

because we spend a lot of time trying
to figure out how to compress images,

how to reduce their size,

how to throw away the information
that people don't need,

in order to allow the image
to be transmitted faster,

to be stored more conveniently.

So, on the right-hand side here,

we also have a coarse graining
of the Alice image,

but now using a coarse-graining algorithm
called the JPEG.

No one's ever referred to the JPEG
as a coarse-graining algorithm,

at least they don't do it that much.

What you can see is both images
look reasonably good.

In fact, they have different properties,
so let's go zoom in here on Dinah.

What you can see on the left-hand side
is the majority vote coarse graining.

One of the features of the majority vote
coarse graining, by the way, you will see,

is that each pixel
is still a bit black or white.

If I zoom in again,

and I guess Dinah's looking here much more
like a rat now than she is like a cat,

but if you zoom in on Dinah
on the right-hand side,

you can see now the JPEG image
has made different choices

about what to keep and what to throw away.

Importantly, one of the ways
the JPEG works

is not in what we call real space,
in what the physicists call real space,

but instead what's called Fourian Space.

We'll talk a little bit more

about the distinction between
those two ways to represent an image,

but for now the simplest way
to think of it is this:

On the right-hand side,

what I did was I took the representation
of the image in the spatial field.

So, I took the entire array,

and I turned it by taking chunks
that were locally connected to each other.

I took little local chunks from the image,

and, for each of those chunks,
I did a little compression scheme.

I said all these differences here
don't matter,

you don't have to keep track

of all the either 9 or 100 pixels
within that square,

I'm going to summarize it,
I'm going to coarse grain it,

I'm going to simplify it,
going to losslessly compress it –

all these words are equivalent,

different ways and different fields,

or rather different ways

that different fields
have discovered to talk about this –

I'm going to simplify all of those pixels
in a particular way.

On the right-hand side,
what the JPEG does is the following:

it does a transformation on this image,

it represents this image
in a very different way.

What it does is it represents the image

in terms of the fluctuations
that occur in it.

So, it takes the long-wavelength
parts of the image,

the fact that in the center
it's darker than it is around the edges,

and it puts that in one pixel.

Then it also takes
the high-frequency component,

the wiggles where the image is going
from black to white

very quickly along the line.

So, here, for example, you can see

on the back of the armchair
where Alice is sitting,

very fine grid lines.

What the JPEG does, is it says,

"There's a patch here where things
are oscillating very quickly,

so I'm going to put that over

in this high-frequency part
of the image data."

It's also true of Alice's hair.

If you look at Alice's hair there,
she has these sort of kinky curls,

and those curls

have a high-frequency component
the JPEG records.

So, what the JPEG does is,

it represents that image now,

instead of representing it spatially –

so stuff on the left
is physically stuff that was on the left

in Tenniel's original recording –

it puts the low-frequency components
in one part

and the high-frequency components
in the other part.

And then it does two things.

First of all blurs them,

so it does a kind of chunking
coarse graining on those components,

and then also it just entirely cuts off

all the high-frequency components
in the image –

because there are parts of that image

that you yourself are not sensitive to,

and those parts are where the image starts
fluctuating back and forth very quickly.

In fact, you can see it:

on the right-hand side,
the JPEG looks smoother

than in the compression I've done.

In fact, what's so clever about the JPEG

is it actually respects the way

in which the human eye
records information.

Amazingly enough, of course,

when the human eyes
gets data from the real world,

and makes an image
on the back of your retina,

it appears almost like a set of pixels.

But before it actually wants to transmit
that image back into your brain

to make decisions,

it does itself
a series of coarse grainings

using Gabor functions in the particular
sensitivity of the neurons.

It does a particular set
of coarse grainings

that, in fact, the JPEG knows about.

So the things that your retina
is going to throw out anyway

as it transmits it backwards,

the JPEG has already thrown out
on your behalf.