The next step is doing Naive Inversion.

And Naive Inversion is very easy, you just solve the linear equation A times U is equal

to P, there's a NumPy command for that NumPy dot linear algebra dot solve.

You put the matrix here, the right hand side here, so this here solves Au equal to P for

U.

So this is what this does.

And when you plot this you get, well you don't actually see anything, there are two things

on top of each other, there's U and there's this Naive Inversion on top, so that's why

you only see one line here because they are both identical.

So as you can see this recovers the true original heat source that we've used, so Naive Inversion

works on noise-free data.

What we do next is we perturb our data by additive noise, so what we do is we fix some

relative noise strength, I've chosen 0.1% which is really quite small, so we have very

good data, we multiply this 0.001 by the magnitude of our data P and then we add a random normal

vector to our P which then gives us P noisy.

So what you have to do is the mean of this additive noise is 0, the standardization is

a sigma we've just chosen here and we just have to supply the right shape so that we

have additive noise in every entry.

So this is IID Gaussian random noise with standard deviation sigma.

And when you plot the data and the original data you don't see anything as you can see

visually, you can't really tell them apart, but if you now do Naive Inversion, so you

just copy your linear algebra solve command here and you apply it to P noisy instead,

you can see that this doesn't give you anything useful.

So it looks like some orange, this orange line, this should be the true heat source,

so this function and as you can see it has magnitude between minus 1 and roughly 2, but

the Naive Inversion gives us oscillations between minus 600,000 and 600,000, so this

is absolutely useless, we don't see anymore what the shape of the original heat source

is and of course if you increase the magnitude of the noise, so now you can see the noise

in here, you can actually see that something is happening and it doesn't get better of

course. On the other hand if you reduce the noise by another order of magnitude then well

you have to reduce it by a huge amount. Well still to watch, let's see whether, well this

starting to be better, so this is almost acceptable, so this blue area means that the Naive Inversion

gives us a lot of oscillations, so it still doesn't give us anything useful, but at least

now it's in the right magnitude, but we are, well what's the relative noise strength, it's

roughly 10 to the minus 8 or 10 or something like that which is completely unrealistic

in actual applications, so this is obviously a very very ill-posed problem because even

0.1% relative noise gives us amplifications in the order of magnitude of 10 to the 6 which

is completely unacceptable. So if we have even the slightest noise we can't do Naive

Inversion anymore. Now we're still committing an inverse crime because we're using the

same grid for the data generation and the reconstruction algorithm and well I explained

how this is an inverse crime because in reality the data that you obtain is usually acquired

in some manner that is at least partly outside of your control, so you can't decide how the

data is obtained usually and you don't know the exact details and there's always some

details that you don't know so you can't really assume to know the grid exactly on which the

discretization is obtained, so what you have to do realistically is if you use synthetic

data like we do, so this is not a real life data set but we're making our own data and

we're trying to test our algorithms on this data set then we have to be fair and generate

data that is slightly unknown in the sense that we're using slightly different parameters

for the generation and reconstruction. So what we do is we do something very mild instead

of a grid with a thousand points we use a different grid, I've chosen a grid with 1103