Just a Logplot

"Thoughts on a logplot." My latest thoughts on logplot I made regarding the Corona virus.

Usual disclaimer, this all initial theorizing regarding numbers I sloppily collected from the Internet, which were hastily gathered themselves, and may suffer from a myriad of other distorting effects. Hardly affected people may have gone unnoticed, doctors may simply have become better at collecting data leading to initial exaggerated growth, people might have run out of test kits in the field, etc.. Use a lot of caution regarding the data.

Second, even if high-school math, it may very well be plain wrong. It's unconfirmed theorizing, and -honestly- I am a bit embarrassed how this simple math still takes considerable effort from my part.

Now we have that out of the way, the initial thoughts:

We have a logplot with two lines: The confirmed and the dead cases. I am going to treat them as is. [BIG IF]

Hypothesis: The illness follows an exponential growth modeled as a function f(t) = c_0^t. The deaths can be modeled as percentage time-lagged dependent function g(t) = m*f(t-t_0) where m is mortality rate and t_0 is average time to death or lag [SECOND BIG IF]. c_0 (growth), m (mortality rate), t_0 (lag) are constants.

In the logplot, c_0 can just be deduced from the slope. The fact that both f and g have the same slope seems to confirm stable exponential growth and the dependence of g on f.

Because we know c_0, we actually know the start of the disease, just extrapolate f to where it meets the horizontal axis. I am going to assume 1/1/2020, twenty days prior.

Now, we have _two_ unknowns: m (mortality rate) and t_0 (lag). Hypothesis: I can fiddle with either to make f map on g corresponding to I can move f either horizontally or vertically to place it on g. [THIRD BIG IF]

Support for that: Is an academic case of a mortality rate of 100% possible? Sure, just assume m is 1 and t_0 is twenty days. This corresponds to shifting f twenty days to the right; i.e., everybody dies, f is exactly reproduced twenty days later. Orthogonal: Is an academic case of 2% possible? just shift directly f downward, this corresponds to 2% dying within 0 days.

Do I know the mortality rate? No. But I could tell you if the above is correct and I would know the average time it takes to die. Only thing I know now it's between 2% (unlikely) and 100% (unlikely).

This seems to confirm the old adagium that you cannot know the details of a disease in the initial phase because you have two unknowns you're trying to fit. Visually you're trying to fit a line on another one by moving either horizontally or vertically and both works.

Again, no idea whether the above is bullshit. The only thing is that I can tell you that I think this model seems to suggest that we're still firmly in the unknown regarding anything.

Newen Afrobeat feat. Seun Kuti & Cheick Tidiane Seck - Opposite People (...

Triple Pendulum on a Cart

Lady Gaga If I Ever Lose My Faith - Sting - Kennedy Center Honors 2014

Boom Festival 2014 Official Webdoc #1: The Feminine

「ニッポン饅頭

Tame Impala - Elephant

Authentic House Project Pres. Marc

I am eclectic in music, as long as it is mostly electronic, but turns out I really like the first song on this album.

Fuck Gödel

Gödel assumes that the system he works in is consistent. He then derives[1]:

"If p were provable, then Bew(G(p)) would be provable, as argued above. But p asserts the negation of Bew(G(p)). Thus the system would be inconsistent, proving both a statement and its negation."

Fuck Gödel. Let's just assume that the system he used is inconsistent, that he has proven an inconsistency (p ∧¬p) in his inconsistent system, and lets concentrate on complete and consistent logics.

[1]: http://en.wikipedia.org/wiki/G%C3%B6del's_incompleteness_theorems

Melody Gardot - It Gonna Come

Predictions from 1900

How the US became the World Dominant Power

Through Vox.

Ursula Rucker - She Said (Live In Philly)

The Number of the Beast

A post by Conor McBride

Hi

I'm sorry about the level of consternation this discussion seems to be
generating, so let me attempt to clarify my previous remarks.

The diagonalization argument which shows that any total language
misses some total programs is the usual one: Godel-code everything in
sight, then make the alleged universal program eat a twisted copy of
itself. It's the Epimenides/Cantor/Russell/Quine/Godel/Turing
argument. And it goes like this...

  Suppose we have a programming language in which all expressions
  compute to a value excluding bottom. For sake of argument, let's
  code expressions and values as natural numbers (an ascii source file
  is just a big number; so is a finite output). In particular, every
  function f from Nat to Nat which lives in the language is quoted by a
  code (quote f) :: Nat, and we know a total function which unquotes,
  executing a coded f at a given argument

    eval :: Nat -> (Nat -> Nat)

  with spec

    eval (quote f) x = f x
    eval _         _ = 0

  Given such a function, I can summon up its evil cousin, with spec:

    evil :: Nat -> Nat

    evil code = 1 + (eval code code)

  Now, if eval is total, so is evil. But if evil lies within our language,
  it will have a number. Without loss of generality, quote evil is a human
  number and that number is 666. So, we get

    evil 666
    = 1 + (eval 666 666)
    = 1 + evil 666

  which is plainly untrue.

  Hence evil is a total function which is not expressible in the language
  (so eval better not be expressible either).

Of course, for any language of total functions, its Halting Problem is
trivial, but that's beside the point.  There is no largest class of
recognizably terminating programs, because no such class can include
its own *evaluation* function, which is by definition terminating.
Given a total language L, we can always construct a strictly larger
language L', also recognizable, which also includes the eval function
for L.

Meanwhile, back in the cafe, why should Haskellers give a monkeys? Two
reasons: one pertinent now, one potential.

Firstly, when we make (or Haskell derives) recursive instance
declarations, we might like to know that

  (1) the compiler will not go into a spin when attempting to compute the
        object code which generates the dictionary for a given instance
  (2) the code so generated will not loop at run-time

You might argue that (1) is not so important, because you can always
ctrl-C, but (2) is more serious, because if it fails, you get the
situation where the compiler approves your program, then breaks it
by inserting bogus code, promising to deliver an instance which does
not actually exist.

To guarantee these properties, we essentially need to ensure that the
instance declaration language is a terminating fragment of Prolog. The
various flags available now are either way too cautious or way too
liberal: what's a suitable middle way? There is no most general choice.

Secondly, might it be desirable to isolate a recognizable sublanguage of
Haskell which contains only total programs?  Pedagogically, Turner argues
that it's useful to have a `safe' language in which to learn.
Rhetorically, making bottom a value is just sophistry to hide the fact
that looping and match failure are pretty bad side-effects available
within an allegedly pure language---preferable to core-dumps or wiping
your hard drive, but still bad. Logically, if you want to show a program
is correct, it helps if you can get its totality for free. Pragmatically,
there are fewer caveats to optimizing bottomless programs.

As we've seen, such a sublanguage (perhaps called `Ask', a part of Haskell
which definitely excludes Hell) cannot contain all the angels, but it
certainly admits plenty of useful ones who can always answer mundane
things you might Ask. It's ironic, but not disastrous that lucifer, the
evaluation function by which Ask's angels bring their light, is himself an
angel, but one who must be cast into Hell.

Yours religiously

Conor

Duckface Zombies

Africa For Norway

Best of Web 3 - HD - Zapatou

Towards Learning Robot Table Tennis

Das Pri-V - Slik Mijn Cookie Bitch!

Ry Cooder - Take Your Hands Off It