"I can go into more detail if you want" - if you don't mind, sure. I'd find that quite interesting.
My impression was you can't influence what state will be measured, but I might very well be wrong there. How would you set up an experiment in which you can transmit information?
You can't influence it, no, that's exactly why you need to see which measurement outcome you got, and pass that along.
The hand-wavy explanation of how teleportation works is something like this. Let's say that in one lab you have two qubits, A and B, and in another lab you have a third qubit C. Initially, qubits B and C are entangled, meaning that if you do the same measurement on both of them, the outcomes will be correlated. They might be the same, or they might be opposite, depending on the type of correlation, however the measurement outcome of each individual qubit is random, all you can say about them is that they will have a certain relationship.
The idea of teleportation is that we also entangle qubit A with qubit B, so their measurement outcomes will become correlated too. Then when we measure them, since A is correlated with B, and B is correlated with C, we end up with A being correlated with C. However, when we measure qubits A and B, we get some random outcome, which means that if one were to measure C it would also look random, since it's correlated with the other random outcomes. Only by using the information of what the outcomes for A and B were can you make predictions about the measurement outcomes for C, so we have to send this information along. This description isn't fully accurate though, it doesn't explain why C would get the correct result for any possible measurement we choose to do on it.
Here's a description of how the protocol actually works, in the most simple case.
Let's say the state A, which we want to teleport, is simply in the state '0', I will write this as |0>.
The entangled state of B and C could for example be: |0,0>+|1,1>. The way to understand this is that either both qubits are '0' or both qubits are '1'. In general, a qubit state is written:
a|0>+b|1>
where the coefficients 'a' and 'b' tell you something about the probability for the qubit to be '0' and '1' respectively.
The first step is to try to entangle A with B. What this means is that we should change B in some way that is conditional on the state of A. One way to do this is to perform what is called a controlled-NOT operation, which does a bit-flip on B if A is in the state '1' and does nothing on B if A is in the state '0'. Here A controls what happens to B, hence the name.
In our case, since A is simply in the state '0', nothing actually happens. However, A could in principle also be in a more exotic state, such as a superposition of '0' and '1'. For example, if we perform the C-NOT gate on the state:
(|0>+|1>)|0> = |0,0> + |1,0>
where the left qubit is is the control, then we would get:
|0,0> + |1,1>
which is an entangled state.
Okay, but in our case as I said, nothing happens, because A is in the state '0' and we still have the state:
|0>(|0,0>+|1,1>) = |0,0,0>+|0,1,1>
Then we do what is called a Hadamard gate on qubit A, which does the following.
|0> -> |0>+|1>
|1> -> |0>-|1>
and we end up with:
|0,0,0>+|1,0,0>+|0,1,1>+|1,1,1>
where the qubits are ordered A,B,C
The reason we do this gate, is that now measuring qubit A won't tell us whether or not it was '0' or '1' in the beginning. If you look above, you see that the Hadamard gate takes both '0' and '1' to equal superpositions of '0' and '1' only with a different sign. When we do the measurement, this actually means that we have an equal probability to get the outcome '0' or '1' in both cases, therefore not giving any information about whether or not the state was '0' or '1' initially.
Anyway, now we measure qubits A and B. Now we should change the state C, depending on which outcomes we got for A and B. In this case, because we started with a simple state (A=|0>), we actually only need to care about the outcome for B. We can see by looking at the state:
|0,0,0>+|1,0,0>+|0,1,1>+|1,1,1>
That if B is '0' then C is '0' as well, however if B is '1' then C is '1'. From this it's clear that if we get the outcome '1' for B, then we should do a bit-flip on C to get the original state which was '0'. Okay, so this works, but it's probably still not clear why it works in the general case, but if you could follow the math here, then it's not much harder.
In the general case, we have that A is an arbitrary superposition of '0' and '1':
A = a|0>+b|1>
where 'a' and 'b' are complex numbers.
Then the total initial state is then:
(a|0>+b|1>)(|0,0>+|11> = a|0,0,0> + a|0,1,1> + b|1,0,0>+b|1,1,1>
We do the C-NOT gate between A and B, so the terms where A is '1' we do a bit-flip on B:
a|0,0,0> + a|0,1,1> + b|1,0,0>+b|1,1,1> -> a|0,0,0> + a|0,1,1> + b|1,1,0>+b|1,0,1>
so we did a bit-flip on B in the the last two terms. Now we should do the Hadamard gate on A. Going through one term at a time:
a|0,0,0> -> a|0,0,0> + a|1,0,0>
a|0,1,1> -> a|0,1,1> + a|1,1,1>
b|1,1,0> -> b|0,1,0> - b|1,1,0>
b|1,0,1> -> b|0,0,1> - b|1,0,1>
and the whole state is:
a|0,0,0> + a|1,0,0> + a|0,1,1> + a|1,1,1> + b|0,1,0> - b|1,1,0> + b|0,0,1> - b|1,0,1>
We now measure A and B as before, and the full correction procedure is that if we get that A is '1' then we flip the sign in front of C, and if we get '1' for B then we again do a bit-flip on C. Let's look at the four different outcomes by simply looking at the corresponding terms above:
There are two possible ways to get A=0 and B=0, these are:
a|0,0,0> + b|0,0,1>
but from this we get that:
C = a|0> + b|1>
(I didn't actually fully explain how the measurement works mathematically, but the point here is that the state a|0,0,0> + b|0,0,1> can also be written a|0,0,0> + b|0,0,1> = |0,0>(a|0>+b|1>) so if A,B = |00> then we can read off what the state of C is)
A=1, B=0:
a|1,0,0> - b|1,0,1> -> C = a|0> - b|1>
but since A was '1' we chance the sign, and we get back a|0> + b|1>
A=0, B=1:
a|0,1,1> + b|0,1,0> -> C = a|1> + b|0>
But now we do the bit-flip and get a|0> + b|1>
Finally,
A=1, B=1:
a|1,0,0> - b|1,0,1> -> C = a|1> - b|0>
Now we do both a bit-flip and change the sign, and we get the original state.
So in all four possible cases, we get that C ends up in the state that A was initially in, but as you can see the state is actually wrong if we don't take into account what the measurement outcomes were. If you look at the full state before the measurement, you'll even see that there are an equal number of terms where C is '0' and '1', which means that only measuring C without any knowledge of the other outcomes gives you a random state.
Note that the reason this works, is that no matter what outcome we get for A and B, it doesn't tell us anything about the coefficients 'a' and 'b' in the original state!
There's another way to understand the protocol. There are four different maximally entangled two-qubit states. These are:
|Phi+> = |0,0> + |1,1>
|Phi-> = |0,0> - |1,1>
|Psi+> = |1,0> + |0,1>
|Psi-> = |1,0> - |0,1>
If we again let A be in some general qubit state:
|A> = a|0> + b|1>
and, BC in the entangled Phi+ state as before:
|BC> = |0,0> + |1,1>
then it turns out that:
|A>|BC> = |A>|Phi+> = a|Phi+>|0> + b|Phi+>|1> + a|Phi->|0> - b|Phi->|1> + a|Psi+|1> + b|Psi+|0> - a|Psi-|1> + b|Psi-|0>
Basically, the state where A is some qubit and BC are entangled, can also be written as a superposition of states where A and B are entangled. What we're actually doing when we do the C-NOT and Hadamard gates, followed by measuring, is that we are measuring A and B in the basis of these entangled states, i.e. the possible measurement outcomes are that AB are in one of the maximally entangled states. So you see above that if we get that A and B are in a Phi+ state, then C = a|0>+b|1> and so on (the other ones need the same corrections as before).
You could check this identity above for some simple case, for example A=|0> as before, then:
|0>|Phi+> = |Phi+>|0> + |Phi->|0> + |Psi+|1> - |Psi-|1> =
= |0,0,0>+|1,1,0> + |0,0,0>-|1,1,0> + |0,1,1>+|1,0,1> - |1,0,1>+|0,1,1> = 2|0,0,0> + |1,1,0>-|1,1,0> + 2|0,1,1> + |1,0,1>-|1,0,1> =
= 2(|0,0,0>+2|0,1,1>) = 2|0>(|0,0>+|1,1>) = 2|0>|Phi+>
(The factor of 2 shows up because for simplicity I skipped some factors that should appear)
