Hi, the topic of this lecture will be Naive Reconstruction and Inverse Crimes and we're

going to pick up where we stopped last time. We saw that while the infinite dimensional

deconvolution problem, which consists of trying to infer the original image from a blurry

version of it, this is ill-posed, we can see that when we discretize we end up with a very

easy linear equation system. So we consider deconvolution after discretization we ended

up with an equation of form F is AP times U, but this is a matrix, this is a vector

and this is a vector, this is the data, the blurry image, this is the convolution matrix

and this is the unknown, let's say clear image. The interesting property was that this matrix

AP, this circular matrix, is a square matrix and invertible. So why bother with ill-posedness

of the infinite dimensional setting when we can easily recover U, I will call it U star,

as the inverse of AP times F bar. So of course this is a rhetoric question, or maybe not

a rhetoric, it's a good question, so why don't we just do this and conclude by saying well

we can after all solve this problem, because the problem with this equation here is that

this operator here is, well it's injective, so it's one to one, so there are no two images

which will yield the same blurry image, the problem is that it's not surjective and it's

also unstable, but this problem, it actually vanishes when we step down from this infinite

dimensional setting and we step down to the finite dimensional setting, because any linear

invertible mapping, or let's say AP is a mapping from RN to RN and if it's injective then it's

also surjective, that's a basic property of linear mappings in the same dimensional space

and then it's of course bijective. So nothing can go wrong here, well sorry not injective

and surjective, of course that's not true exactly, but it's injective and it is also

surjective, I'm sorry that was a weird mistake, so it's injective and surjective now, because

the missing surjectiveness that is the problem of the infinite dimensional version, so the

convolution operator, that vanishes when we go down to finite dimensions, because it's

only, well let's say a sort of missing surjectivity which comes directly from the compactness

of this operator. So well the details aren't that important right now, but the fact remains

in the specific discretization we saw that we could just invert this matrix and recover

something, we can recover the same image again, so why not do that. There's a small problem

that might be spoiling our mood here, so what if f is not a p times u bar, but there's some

error term in addition, so what if the image that we have is a blurry image where there's

some small noise additionally on the single pixels. This can happen for various reasons

and it's a realistic assumption to say that we don't know the pixel intensities to infinite

precision because well our computer is storing them in some way, so they're bound to have

been maybe not randomly but at least by numerical precision cutoff methods. So there will be

some ambiguity for the single pixel intensities and this we can also model as noise, so it's

either oscillational noise or it's numerical round off errors or things like that. Then

our u star would be ap minus 1 f bar and this is now ap minus 1 of ap u bar plus epsilon

bar and this is the true image plus ap minus 1 times epsilon and this is where we could

run into problems and indeed we'll see that this is the case. So let's return to our simulation

again, so you saw this picture, a true image is this crisp clear image that you can also

look at as a 1 pixel by 64 pixel image like this. Applying a convolution operator makes

this image blurry, it smoothens out those jumps and plot as a pixel image it looks like

the bottom image here and you can see that the jump from yellow to blue has been smoothed

out by intermediate values and the same happens here and here and yes well that's how it works.

Now we do naive inversion, we'll call this naive inversion because it's the most naive

way to do this, naive doesn't mean stupid it just means that's the obvious choice to

try before trying more difficult things, so we call this naive inversion, it has its merits

so in the noise free case everything should work out and we also define the noisy version

here, maybe I'll write this down as well so this is the noisy data, noisy reconstruction

and so on. And if we do this, so we start with a blur image without any noise and we