chart_parser_answer(parsed, command).
why(
  chart_parser_answer(parsed, command),
  proof(
    goal(chart_parser_answer(parsed, command)),
    by(rule("chart-parser.pl", clause(32))),
    bindings([binding("Sentence", command), binding("Length", 5)]),
    uses([
      proof(
        goal(sentence(command, 5)),
        by(fact("chart-parser.pl", clause(2)))
      ),
      proof(
        goal(span(command, s, 0, 5)),
        by(rule("chart-parser.pl", clause(31))),
        bindings([binding("Sentence", command), binding("Category", s), binding("Start", 0), binding("End", 5), binding("Left", np), binding("Right", vp), binding("Middle", 2)]),
        uses([
          proof(
            goal(rule(s, np, vp)),
            by(fact("chart-parser.pl", clause(24)))
          ),
          proof(
            goal(span(command, np, 0, 2)),
            by(rule("chart-parser.pl", clause(31))),
            bindings([binding("Sentence", command), binding("Category", np), binding("Start", 0), binding("End", 2), binding("Left", det), binding("Right", noun), binding("Middle", 1)]),
            uses([
              proof(
                goal(rule(np, det, noun)),
                by(fact("chart-parser.pl", clause(25)))
              ),
              proof(
                goal(span(command, det, 0, 1)),
                by(rule("chart-parser.pl", clause(30))),
                bindings([binding("Sentence", command), binding("Category", det), binding("Start", 0), binding("End", 1), binding("Token", the)]),
                uses([
                  proof(
                    goal(word(command, 0, the)),
                    by(fact("chart-parser.pl", clause(4)))
                  ),
                  proof(
                    goal(terminal(det, the)),
                    by(fact("chart-parser.pl", clause(17)))
                  ),
                  proof(
                    goal(add(0, 1, 1)),
                    by(builtin(add, 3))
                  )
                ])
              ),
              proof(
                goal(span(command, noun, 1, 2)),
                by(rule("chart-parser.pl", clause(30))),
                bindings([binding("Sentence", command), binding("Category", noun), binding("Start", 1), binding("End", 2), binding("Token", robot)]),
                uses([
                  proof(
                    goal(word(command, 1, robot)),
                    by(fact("chart-parser.pl", clause(5)))
                  ),
                  proof(
                    goal(terminal(noun, robot)),
                    by(fact("chart-parser.pl", clause(18)))
                  ),
                  proof(
                    goal(add(1, 1, 2)),
                    by(builtin(add, 3))
                  )
                ])
              )
            ])
          ),
          proof(
            goal(span(command, vp, 2, 5)),
            by(rule("chart-parser.pl", clause(31))),
            bindings([binding("Sentence", command), binding("Category", vp), binding("Start", 2), binding("End", 5), binding("Left", verb), binding("Right", np), binding("Middle", 3)]),
            uses([
              proof(
                goal(rule(vp, verb, np)),
                by(fact("chart-parser.pl", clause(27)))
              ),
              proof(
                goal(span(command, verb, 2, 3)),
                by(rule("chart-parser.pl", clause(30))),
                bindings([binding("Sentence", command), binding("Category", verb), binding("Start", 2), binding("End", 3), binding("Token", moves)]),
                uses([
                  proof(
                    goal(word(command, 2, moves)),
                    by(fact("chart-parser.pl", clause(6)))
                  ),
                  proof(
                    goal(terminal(verb, moves)),
                    by(fact("chart-parser.pl", clause(21)))
                  ),
                  proof(
                    goal(add(2, 1, 3)),
                    by(builtin(add, 3))
                  )
                ])
              ),
              proof(
                goal(span(command, np, 3, 5)),
                by(rule("chart-parser.pl", clause(31))),
                bindings([binding("Sentence", command), binding("Category", np), binding("Start", 3), binding("End", 5), binding("Left", det), binding("Right", noun), binding("Middle", 4)]),
                uses([
                  proof(
                    goal(rule(np, det, noun)),
                    by(fact("chart-parser.pl", clause(25)))
                  ),
                  proof(
                    goal(span(command, det, 3, 4)),
                    by(rule("chart-parser.pl", clause(30))),
                    bindings([binding("Sentence", command), binding("Category", det), binding("Start", 3), binding("End", 4), binding("Token", the)]),
                    uses([
                      proof(
                        goal(word(command, 3, the)),
                        by(fact("chart-parser.pl", clause(7)))
                      ),
                      proof(
                        goal(terminal(det, the)),
                        by(fact("chart-parser.pl", clause(17)))
                      ),
                      proof(
                        goal(add(3, 1, 4)),
                        by(builtin(add, 3))
                      )
                    ])
                  ),
                  proof(
                    goal(span(command, noun, 4, 5)),
                    by(rule("chart-parser.pl", clause(30))),
                    bindings([binding("Sentence", command), binding("Category", noun), binding("Start", 4), binding("End", 5), binding("Token", box)]),
                    uses([
                      proof(
                        goal(word(command, 4, box)),
                        by(fact("chart-parser.pl", clause(8)))
                      ),
                      proof(
                        goal(terminal(noun, box)),
                        by(fact("chart-parser.pl", clause(19)))
                      ),
                      proof(
                        goal(add(4, 1, 5)),
                        by(builtin(add, 3))
                      )
                    ])
                  )
                ])
              )
            ])
          )
        ])
      )
    ])
  )
).

chart_parser_answer(parsed, ambiguous_pp).
why(
  chart_parser_answer(parsed, ambiguous_pp),
  proof(
    goal(chart_parser_answer(parsed, ambiguous_pp)),
    by(rule("chart-parser.pl", clause(32))),
    bindings([binding("Sentence", ambiguous_pp), binding("Length", 8)]),
    uses([
      proof(
        goal(sentence(ambiguous_pp, 8)),
        by(fact("chart-parser.pl", clause(3)))
      ),
      proof(
        goal(span(ambiguous_pp, s, 0, 8)),
        by(rule("chart-parser.pl", clause(31))),
        bindings([binding("Sentence", ambiguous_pp), binding("Category", s), binding("Start", 0), binding("End", 8), binding("Left", np), binding("Right", vp), binding("Middle", 2)]),
        uses([
          proof(
            goal(rule(s, np, vp)),
            by(fact("chart-parser.pl", clause(24)))
          ),
          proof(
            goal(span(ambiguous_pp, np, 0, 2)),
            by(rule("chart-parser.pl", clause(31))),
            bindings([binding("Sentence", ambiguous_pp), binding("Category", np), binding("Start", 0), binding("End", 2), binding("Left", det), binding("Right", noun), binding("Middle", 1)]),
            uses([
              proof(
                goal(rule(np, det, noun)),
                by(fact("chart-parser.pl", clause(25)))
              ),
              proof(
                goal(span(ambiguous_pp, det, 0, 1)),
                by(rule("chart-parser.pl", clause(30))),
                bindings([binding("Sentence", ambiguous_pp), binding("Category", det), binding("Start", 0), binding("End", 1), binding("Token", the)]),
                uses([
                  proof(
                    goal(word(ambiguous_pp, 0, the)),
                    by(fact("chart-parser.pl", clause(9)))
                  ),
                  proof(
                    goal(terminal(det, the)),
                    by(fact("chart-parser.pl", clause(17)))
                  ),
                  proof(
                    goal(add(0, 1, 1)),
                    by(builtin(add, 3))
                  )
                ])
              ),
              proof(
                goal(span(ambiguous_pp, noun, 1, 2)),
                by(rule("chart-parser.pl", clause(30))),
                bindings([binding("Sentence", ambiguous_pp), binding("Category", noun), binding("Start", 1), binding("End", 2), binding("Token", robot)]),
                uses([
                  proof(
                    goal(word(ambiguous_pp, 1, robot)),
                    by(fact("chart-parser.pl", clause(10)))
                  ),
                  proof(
                    goal(terminal(noun, robot)),
                    by(fact("chart-parser.pl", clause(18)))
                  ),
                  proof(
                    goal(add(1, 1, 2)),
                    by(builtin(add, 3))
                  )
                ])
              )
            ])
          ),
          proof(
            goal(span(ambiguous_pp, vp, 2, 8)),
            by(rule("chart-parser.pl", clause(31))),
            bindings([binding("Sentence", ambiguous_pp), binding("Category", vp), binding("Start", 2), binding("End", 8), binding("Left", verb), binding("Right", np), binding("Middle", 3)]),
            uses([
              proof(
                goal(rule(vp, verb, np)),
                by(fact("chart-parser.pl", clause(27)))
              ),
              proof(
                goal(span(ambiguous_pp, verb, 2, 3)),
                by(rule("chart-parser.pl", clause(30))),
                bindings([binding("Sentence", ambiguous_pp), binding("Category", verb), binding("Start", 2), binding("End", 3), binding("Token", sees)]),
                uses([
                  proof(
                    goal(word(ambiguous_pp, 2, sees)),
                    by(fact("chart-parser.pl", clause(11)))
                  ),
                  proof(
                    goal(terminal(verb, sees)),
                    by(fact("chart-parser.pl", clause(22)))
                  ),
                  proof(
                    goal(add(2, 1, 3)),
                    by(builtin(add, 3))
                  )
                ])
              ),
              proof(
                goal(span(ambiguous_pp, np, 3, 8)),
                by(rule("chart-parser.pl", clause(31))),
                bindings([binding("Sentence", ambiguous_pp), binding("Category", np), binding("Start", 3), binding("End", 8), binding("Left", np), binding("Right", pp), binding("Middle", 5)]),
                uses([
                  proof(
                    goal(rule(np, np, pp)),
                    by(fact("chart-parser.pl", clause(26)))
                  ),
                  proof(
                    goal(span(ambiguous_pp, np, 3, 5)),
                    by(rule("chart-parser.pl", clause(31))),
                    bindings([binding("Sentence", ambiguous_pp), binding("Category", np), binding("Start", 3), binding("End", 5), binding("Left", det), binding("Right", noun), binding("Middle", 4)]),
                    uses([
                      proof(
                        goal(rule(np, det, noun)),
                        by(fact("chart-parser.pl", clause(25)))
                      ),
                      proof(
                        goal(span(ambiguous_pp, det, 3, 4)),
                        by(rule("chart-parser.pl", clause(30))),
                        bindings([binding("Sentence", ambiguous_pp), binding("Category", det), binding("Start", 3), binding("End", 4), binding("Token", the)]),
                        uses([
                          proof(
                            goal(word(ambiguous_pp, 3, the)),
                            by(fact("chart-parser.pl", clause(12)))
                          ),
                          proof(
                            goal(terminal(det, the)),
                            by(fact("chart-parser.pl", clause(17)))
                          ),
                          proof(
                            goal(add(3, 1, 4)),
                            by(builtin(add, 3))
                          )
                        ])
                      ),
                      proof(
                        goal(span(ambiguous_pp, noun, 4, 5)),
                        by(rule("chart-parser.pl", clause(30))),
                        bindings([binding("Sentence", ambiguous_pp), binding("Category", noun), binding("Start", 4), binding("End", 5), binding("Token", box)]),
                        uses([
                          proof(
                            goal(word(ambiguous_pp, 4, box)),
                            by(fact("chart-parser.pl", clause(13)))
                          ),
                          proof(
                            goal(terminal(noun, box)),
                            by(fact("chart-parser.pl", clause(19)))
                          ),
                          proof(
                            goal(add(4, 1, 5)),
                            by(builtin(add, 3))
                          )
                        ])
                      )
                    ])
                  ),
                  proof(
                    goal(span(ambiguous_pp, pp, 5, 8)),
                    by(rule("chart-parser.pl", clause(31))),
                    bindings([binding("Sentence", ambiguous_pp), binding("Category", pp), binding("Start", 5), binding("End", 8), binding("Left", prep), binding("Right", np), binding("Middle", 6)]),
                    uses([
                      proof(
                        goal(rule(pp, prep, np)),
                        by(fact("chart-parser.pl", clause(29)))
                      ),
                      proof(
                        goal(span(ambiguous_pp, prep, 5, 6)),
                        by(rule("chart-parser.pl", clause(30))),
                        bindings([binding("Sentence", ambiguous_pp), binding("Category", prep), binding("Start", 5), binding("End", 6), binding("Token", with)]),
                        uses([
                          proof(
                            goal(word(ambiguous_pp, 5, with)),
                            by(fact("chart-parser.pl", clause(14)))
                          ),
                          proof(
                            goal(terminal(prep, with)),
                            by(fact("chart-parser.pl", clause(23)))
                          ),
                          proof(
                            goal(add(5, 1, 6)),
                            by(builtin(add, 3))
                          )
                        ])
                      ),
                      proof(
                        goal(span(ambiguous_pp, np, 6, 8)),
                        by(rule("chart-parser.pl", clause(31))),
                        bindings([binding("Sentence", ambiguous_pp), binding("Category", np), binding("Start", 6), binding("End", 8), binding("Left", det), binding("Right", noun), binding("Middle", 7)]),
                        uses([
                          proof(
                            goal(rule(np, det, noun)),
                            by(fact("chart-parser.pl", clause(25)))
                          ),
                          proof(
                            goal(span(ambiguous_pp, det, 6, 7)),
                            by(rule("chart-parser.pl", clause(30))),
                            bindings([binding("Sentence", ambiguous_pp), binding("Category", det), binding("Start", 6), binding("End", 7), binding("Token", the)]),
                            uses([
                              proof(
                                goal(word(ambiguous_pp, 6, the)),
                                by(fact("chart-parser.pl", clause(15)))
                              ),
                              proof(
                                goal(terminal(det, the)),
                                by(fact("chart-parser.pl", clause(17)))
                              ),
                              proof(
                                goal(add(6, 1, 7)),
                                by(builtin(add, 3))
                              )
                            ])
                          ),
                          proof(
                            goal(span(ambiguous_pp, noun, 7, 8)),
                            by(rule("chart-parser.pl", clause(30))),
                            bindings([binding("Sentence", ambiguous_pp), binding("Category", noun), binding("Start", 7), binding("End", 8), binding("Token", telescope)]),
                            uses([
                              proof(
                                goal(word(ambiguous_pp, 7, telescope)),
                                by(fact("chart-parser.pl", clause(16)))
                              ),
                              proof(
                                goal(terminal(noun, telescope)),
                                by(fact("chart-parser.pl", clause(20)))
                              ),
                              proof(
                                goal(add(7, 1, 8)),
                                by(builtin(add, 3))
                              )
                            ])
                          )
                        ])
                      )
                    ])
                  )
                ])
              )
            ])
          )
        ])
      )
    ])
  )
).

chart_parser_answer(parse_count, count(command, 1)).
why(
  chart_parser_answer(parse_count, count(command, 1)),
  proof(
    goal(chart_parser_answer(parse_count, count(command, 1))),
    by(rule("chart-parser.pl", clause(33))),
    bindings([binding("Sentence", command), binding("Count", 1), binding("Length", 5)]),
    uses([
      proof(
        goal(sentence(command, 5)),
        by(fact("chart-parser.pl", clause(2)))
      ),
      proof(
        goal(countall(span(command, s, 0, 5), 1)),
        by(builtin(countall, 2))
      )
    ])
  )
).

chart_parser_answer(parse_count, count(ambiguous_pp, 1)).
why(
  chart_parser_answer(parse_count, count(ambiguous_pp, 1)),
  proof(
    goal(chart_parser_answer(parse_count, count(ambiguous_pp, 1))),
    by(rule("chart-parser.pl", clause(33))),
    bindings([binding("Sentence", ambiguous_pp), binding("Count", 1), binding("Length", 8)]),
    uses([
      proof(
        goal(sentence(ambiguous_pp, 8)),
        by(fact("chart-parser.pl", clause(3)))
      ),
      proof(
        goal(countall(span(ambiguous_pp, s, 0, 8), 1)),
        by(builtin(countall, 2))
      )
    ])
  )
).

chart_parser_answer(noun_phrase_count, count(command, 2)).
why(
  chart_parser_answer(noun_phrase_count, count(command, 2)),
  proof(
    goal(chart_parser_answer(noun_phrase_count, count(command, 2))),
    by(rule("chart-parser.pl", clause(34))),
    bindings([binding("Sentence", command), binding("Count", 2), binding("Length", 5)]),
    uses([
      proof(
        goal(sentence(command, 5)),
        by(fact("chart-parser.pl", clause(2)))
      ),
      proof(
        goal(countall(span(command, np, _start, _end), 2)),
        by(builtin(countall, 2))
      ),
      proof(
        goal(gt(5, 0)),
        by(builtin(gt, 2))
      )
    ])
  )
).

chart_parser_answer(noun_phrase_count, count(ambiguous_pp, 4)).
why(
  chart_parser_answer(noun_phrase_count, count(ambiguous_pp, 4)),
  proof(
    goal(chart_parser_answer(noun_phrase_count, count(ambiguous_pp, 4))),
    by(rule("chart-parser.pl", clause(34))),
    bindings([binding("Sentence", ambiguous_pp), binding("Count", 4), binding("Length", 8)]),
    uses([
      proof(
        goal(sentence(ambiguous_pp, 8)),
        by(fact("chart-parser.pl", clause(3)))
      ),
      proof(
        goal(countall(span(ambiguous_pp, np, _start, _end), 4)),
        by(builtin(countall, 2))
      ),
      proof(
        goal(gt(8, 0)),
        by(builtin(gt, 2))
      )
    ])
  )
).