W.D.Clinger
Philosopher
- Joined
- Oct 3, 2009
- Messages
- 6,103
The highlighted statement is flat-out false. Readers can decide for themselves whether it was a deliberate lie, or just another indication that Mike Helland doesn't understand his own algorithm.Right. The only change I made was to update distances using v=c/(1+z), without changing the lines of code that update z and H.
You changed the line of code that applies H to the model.
You could set it to H = "Clinger Was Here" and it wouldn't make a lick of difference
Here is the body of Mike Helland's while loop after I modified it. The "if useHX" code is Mike Helland's original code. The "if not useHX" code is the result of changing the two lines of code that update distances. It should be obvious that I never changed a "line of code that applies H to the model", because (apart from the two lines that update distances) there never was such a line of code.
Code:
t -= 1
if useHX:
x1 += c - H * x1
x += c - H * x
z = 0.1 / (x1 - x) - 1
if not useHX:
x1 += c / (1 + z)
x += c / (1 + z)
z = 0.1 / (x1 - x) - 1
H = H0 * (OmegaM * (1+z)**3 + OmegaL + OmegaK * (1+z)**2)**0.5
The spoiler immediately below shows Scheme code for the system derivative that uses v=c−Hd, followed by the code for the system derivative that uses v=c/(1+z). It should be obvious that the only changes are to the derivatives used to update x1 and x2. Those changes correspond exactly to the changes I made to Mike Helland's Python code, as shown above.His algorithm breaks because it is more fragile than the bog-standard algorithm. The bog-standard algorithm does not break if we make precisely and only the change from v=c−Hd to v=c/(1+z).
Your "bog-standard" code is also updating the reference distance using H. Of course it works.
Here is the system derivative for the bog-standard algorithm using v=c−Hd:
Note that neither x1 nor x2 affect the computation of a, z, or H. The distances x1 and x2 appear in the above code only because they were present in Mike Helland's original code, where they were used to update z.
Here is the system derivative for the bog-standard algorithm using v=c/(1+z):
It should be obvious that no changes were made to the derivative for a (highlighted in green). The only changes that were made were to the derivatives for the distances (highlighted in blue).
Code:
(lambda (state)
(let ((a (vector-ref state 0))
(x1 (vector-ref state 1))
(x2 (vector-ref state 2)))
(let* ((z (- (/ 1.0 a) 1.0))
(H (* H0 (sqrt (+ (* OmegaM (expt (+ 1.0 z) 3.0)) OmegaL)))))
(vector [color=green](- (* H a))[/color]
[color=blue](- c (* H x1))[/color]
[color=blue](- c (* H x2))[/color])))))
Here is the system derivative for the bog-standard algorithm using v=c/(1+z):
Code:
(lambda (state)
(let ((a (vector-ref state 0))
(x1 (vector-ref state 1))
(x2 (vector-ref state 2)))
(let* ((z (- (/ 1.0 a) 1.0))
(H (* H0 (sqrt (+ (* OmegaM (expt (+ 1.0 z) 3.0)) OmegaL)))))
(vector [color=green](- (* H a))[/color]
[color=blue](/ c (+ 1.0 z))[/color]
[color=blue](/ c (+ 1.0 z))[/color])))))
With those changes, the Scheme code continues to work correctly for models with constant H.
With exactly those same changes, Mike Helland's Python code breaks.
Those changes break Mike Helland's algorithm because that algorithm uses x1-x2 to update z instead of using the scale factor.
That's the only significant difference between Mike Helland's algorithm and the bog-standard algorithm, and it is precisely that difference that has served as the basis for Mike Helland's almost daily claim that his algorithm is more general and easier to understand than the bog-standard algorithm.
Mike Helland now admits that his algorithm doesn't work with v=c/(1+z) unless we also change the part of his algorithm that he's been most proud of.
It seems Mike Helland is falling for his own antics.I hope no one is failing for your antics this time.
Let's note once again that no such change was needed when I modified the bog-standard algorithm to use v=c/(1+z) instead of v=c−Hd (for models with constant H).That "significant change" just ensures that the value of H still affects the results of the model.
You significantly changed it by removing it from the model.
But Mike Helland's algorithm breaks if we use v=c/(1+z) instead of v=c−Hd. To repair that breakage, it is necessary to make a significant change to Mike Helland's algorithm. To be precise, we must replace the very aspect of Mike Helland's algorithm that Mike Helland has been touting as superior to the bog-standard algorithm.
Last edited: