{
  "wireMagic": "pb3",
  "pens": [ {
  
  } ],
  "wsWinStyles": [ {
  
  } ],
  "wpWinPositions": [ {
  
  } ],
  "events": [ {
    "tStartMs": 35000,
    "dDurationMs": 2500,
    "segs": [ {
      "utf8": "This is computing machine A."
    } ]
  }, {
    "tStartMs": 38000,
    "dDurationMs": 4000,
    "segs": [ {
      "utf8": "A solves problems in arithmetic."
    } ]
  }, {
    "tStartMs": 43500,
    "dDurationMs": 1800,
    "segs": [ {
      "utf8": "It receives a problem written on paper,"
    } ]
  }, {
    "tStartMs": 46500,
    "dDurationMs": 4000,
    "segs": [ {
      "utf8": "And it prints the answer."
    } ]
  }, {
    "tStartMs": 51000,
    "dDurationMs": 4000,
    "segs": [ {
      "utf8": "It always prints the right answer."
    } ]
  }, {
    "tStartMs": 59800,
    "dDurationMs": 2200,
    "segs": [ {
      "utf8": "Here’s another computing machine, C."
    } ]
  }, {
    "tStartMs": 62200,
    "dDurationMs": 4000,
    "segs": [ {
      "utf8": "C plays checkers."
    } ]
  }, {
    "tStartMs": 67000,
    "dDurationMs": 3000,
    "segs": [ {
      "utf8": "It receives the current state of the board . . ."
    } ]
  }, {
    "tStartMs": 70150,
    "dDurationMs": 4350,
    "segs": [ {
      "utf8": "And it prints how it would move one of the red pieces."
    } ]
  }, {
    "tStartMs": 75000,
    "dDurationMs": 5000,
    "segs": [ {
      "utf8": "C plays checkers so well - it will never lose a game."
    } ]
  }, {
    "tStartMs": 82500,
    "dDurationMs": 3900,
    "segs": [ {
      "utf8": "A and C are machines we can already build today, "
    } ]
  }, {
    "tStartMs": 86600,
    "dDurationMs": 2400,
    "segs": [ {
      "utf8": "and computers keep getting smarter and smarter. "
    } ]
  }, {
    "tStartMs": 89200,
    "dDurationMs": 4300,
    "segs": [ {
      "utf8": "So will they eventually be able to do everything?"
    } ]
  }, {
    "tStartMs": 113000,
    "dDurationMs": 3200,
    "segs": [ {
      "utf8": "Let’s feed A with a board of checkers."
    } ]
  }, {
    "tStartMs": 116400,
    "dDurationMs": 3000,
    "segs": [ {
      "utf8": "A was not designed to handle this kind of input, "
    } ]
  }, {
    "tStartMs": 119500,
    "dDurationMs": 3900,
    "segs": [ {
      "utf8": "and when it tries to process it, it gets stuck."
    } ]
  }, {
    "tStartMs": 123500,
    "dDurationMs": 5500,
    "segs": [ {
      "utf8": "The same thing happens to C when fed with a question in arithmetic."
    } ]
  }, {
    "tStartMs": 134800,
    "dDurationMs": 3200,
    "segs": [ {
      "utf8": "Let’s draw a blue print of A."
    } ]
  }, {
    "tStartMs": 138500,
    "dDurationMs": 4500,
    "segs": [ {
      "utf8": "This blue print is detailed down to the level of the logic circuits, "
    } ]
  }, {
    "tStartMs": 143200,
    "dDurationMs": 2800,
    "segs": [ {
      "utf8": "and it fully defines how A works."
    } ]
  }, {
    "tStartMs": 149500,
    "dDurationMs": 4700,
    "segs": [ {
      "utf8": "We are now finally ready to introduce a marvelous machine called H."
    } ]
  }, {
    "tStartMs": 154500,
    "dDurationMs": 2950,
    "segs": [ {
      "utf8": "H solves what is known as the halting problem: "
    } ]
  }, {
    "tStartMs": 157550,
    "dDurationMs": 2950,
    "segs": [ {
      "utf8": "It can analyze the blue print of another machine, "
    } ]
  }, {
    "tStartMs": 160600,
    "dDurationMs": 5200,
    "segs": [ {
      "utf8": "and determine which inputs are good for it, and which will cause it to get stuck."
    } ]
  }, {
    "tStartMs": 165900,
    "dDurationMs": 2900,
    "segs": [ {
      "utf8": "It receives the blue print of the machine to be tested,"
    } ]
  }, {
    "tStartMs": 168900,
    "dDurationMs": 2100,
    "segs": [ {
      "utf8": "and an input to test it with."
    } ]
  }, {
    "tStartMs": 171800,
    "dDurationMs": 4700,
    "segs": [ {
      "utf8": "Based on the blue print, H simulates the given machine on the given input . . ."
    } ]
  }, {
    "tStartMs": 176800,
    "dDurationMs": 3000,
    "segs": [ {
      "utf8": "and then determines if it gets stuck or not."
    } ]
  }, {
    "tStartMs": 184300,
    "dDurationMs": 3000,
    "segs": [ {
      "utf8": "H solves the halting problem perfectly. "
    } ]
  }, {
    "tStartMs": 187400,
    "dDurationMs": 3100,
    "segs": [ {
      "utf8": "It always prints the right answer."
    } ]
  }, {
    "tStartMs": 195400,
    "dDurationMs": 5000,
    "segs": [ {
      "utf8": "Here are two more examples with the blue print of the checkers machine."
    } ]
  }, {
    "tStartMs": 221500,
    "dDurationMs": 3500,
    "segs": [ {
      "utf8": "H is a nice machine, but can we really build it?"
    } ]
  }, {
    "tStartMs": 225500,
    "dDurationMs": 2750,
    "segs": [ {
      "utf8": "We’ll now prove that its very existence . . . "
    } ]
  }, {
    "tStartMs": 228350,
    "dDurationMs": 2950,
    "segs": [ {
      "utf8": "is logically impossible."
    } ]
  }, {
    "tStartMs": 253400,
    "dDurationMs": 3600,
    "segs": [ {
      "utf8": "Let’s assume that H does exist."
    } ]
  }, {
    "tStartMs": 259000,
    "dDurationMs": 4900,
    "segs": [ {
      "utf8": "We’ll place it on this stand for reasons that will be made clear in a minute."
    } ]
  }, {
    "tStartMs": 264000,
    "dDurationMs": 3800,
    "segs": [ {
      "utf8": "Recall that we assume H solves the halting problem perfectly: "
    } ]
  }, {
    "tStartMs": 267900,
    "dDurationMs": 2300,
    "segs": [ {
      "utf8": "it should always print the correct answer. "
    } ]
  }, {
    "tStartMs": 270300,
    "dDurationMs": 2700,
    "segs": [ {
      "utf8": "We are about to put this to the test."
    } ]
  }, {
    "tStartMs": 273200,
    "dDurationMs": 7000,
    "segs": [ {
      "utf8": "This is a photocopying machine. It simply prints two copies of its input."
    } ]
  }, {
    "tStartMs": 282000,
    "dDurationMs": 3000,
    "segs": [ {
      "utf8": "We’ll place it behind H."
    } ]
  }, {
    "tStartMs": 288500,
    "dDurationMs": 4300,
    "segs": [ {
      "utf8": "Here’s another simple machine. We call this one – the Negator."
    } ]
  }, {
    "tStartMs": 293000,
    "dDurationMs": 4400,
    "segs": [ {
      "utf8": "When the Negator receives the words “not stuck”, it gets stuck."
    } ]
  }, {
    "tStartMs": 297500,
    "dDurationMs": 3700,
    "segs": [ {
      "utf8": "And when it receives the words “stuck”, it does not get stuck . . . "
    } ]
  }, {
    "tStartMs": 301500,
    "dDurationMs": 3000,
    "segs": [ {
      "utf8": "and it prints a smile."
    } ]
  }, {
    "tStartMs": 306500,
    "dDurationMs": 3000,
    "segs": [ {
      "utf8": "We’ll place it in front of H."
    } ]
  }, {
    "tStartMs": 317800,
    "dDurationMs": 4200,
    "segs": [ {
      "utf8": "Let’s wrap it all in a neat package we call: the X machine."
    } ]
  }, {
    "tStartMs": 322500,
    "dDurationMs": 3500,
    "segs": [ {
      "utf8": "X has one input, and one output."
    } ]
  }, {
    "tStartMs": 326500,
    "dDurationMs": 3000,
    "segs": [ {
      "utf8": "Let’s draw its blue print."
    } ]
  }, {
    "tStartMs": 331500,
    "dDurationMs": 5000,
    "segs": [ {
      "utf8": "As before, this blue print fully defines X."
    } ]
  }, {
    "tStartMs": 337500,
    "dDurationMs": 4550,
    "segs": [ {
      "utf8": "What do you think will happen if we feed X with its own blue print? "
    } ]
  }, {
    "tStartMs": 342250,
    "dDurationMs": 3750,
    "segs": [ {
      "utf8": "Will it get stuck? Let’s find out."
    } ]
  }, {
    "tStartMs": 349500,
    "dDurationMs": 3000,
    "segs": [ {
      "utf8": "P . . .  simply duplicates our input."
    } ]
  }, {
    "tStartMs": 353000,
    "dDurationMs": 3500,
    "segs": [ {
      "utf8": "H receives two copies of the blue print of X. "
    } ]
  }, {
    "tStartMs": 356800,
    "dDurationMs": 5200,
    "segs": [ {
      "utf8": "It should now determine what happens when X is fed with its own blue print. "
    } ]
  }, {
    "tStartMs": 362500,
    "dDurationMs": 3600,
    "segs": [ {
      "utf8": "Let’s assume it says . . . not stuck."
    } ]
  }, {
    "tStartMs": 368800,
    "dDurationMs": 3200,
    "segs": [ {
      "utf8": "N negates that, and gets stuck."
    } ]
  }, {
    "tStartMs": 373000,
    "dDurationMs": 4400,
    "segs": [ {
      "utf8": "So feeding X with its own blueprint causes it to get stuck."
    } ]
  }, {
    "tStartMs": 377500,
    "dDurationMs": 3500,
    "segs": [ {
      "utf8": "But H said it wouldn’t. H was wrong."
    } ]
  }, {
    "tStartMs": 382000,
    "dDurationMs": 3000,
    "segs": [ {
      "utf8": "Let’s try again."
    } ]
  }, {
    "tStartMs": 392300,
    "dDurationMs": 3700,
    "segs": [ {
      "utf8": "This time we’ll assume H says “stuck”."
    } ]
  }, {
    "tStartMs": 404000,
    "dDurationMs": 5500,
    "segs": [ {
      "utf8": "X didn’t get stuck - but H said it would. "
    } ]
  }, {
    "tStartMs": 410000,
    "dDurationMs": 2300,
    "segs": [ {
      "utf8": "H was wrong again. "
    } ]
  }, {
    "tStartMs": 412500,
    "dDurationMs": 2500,
    "segs": [ {
      "utf8": "But H is supposed to always be right . . ."
    } ]
  }, {
    "tStartMs": 415250,
    "dDurationMs": 4750,
    "segs": [ {
      "utf8": "This is a contradiction, . . . proving H cannot exist."
    } ]
  } ]
}