docs: protected Explanation<E> computeExplanation(E entailment) {
  
          TelemetryTimer justificationTimer = new TelemetryTimer();
  
          TelemetryInfo findOneInfo = new DefaultTelemetryInfo("findone", justificationTimer);
          final TelemetryTransmitter transmitter = TelemetryTransmitter.getTransmitter();
          transmitter.beginTransmission(findOneInfo);
  
          Explanation<E> result = Explanation.getEmptyExplanation(entailment);
  
          boolean entailed = false;
  
          try {
              justificationTimer.start();
  
              // Quick get out!
              if (entailment instanceof OWLAxiom && workingAxioms.contains((OWLAxiom) entailment)) {
                  entailed = true;
                  result = new Explanation<E>(entailment, Collections.singleton((OWLAxiom) entailment));
              }
              else {
                  if (progressMonitor.isCancelled()) {
                      throw new ExplanationGeneratorInterruptedException();
                  }
                  EntailmentChecker<E> checker = checkerFactory.createEntailementChecker(entailment);
                  // Expansion phase
                  Set<OWLAxiom> expandedAxioms = doExpansion(checker);
  
                  if (!expandedAxioms.isEmpty()) {
                      // Contraction phase
                      Set<OWLAxiom> justificationAxioms = doContraction(checker, expandedAxioms);
  
                      result = new Explanation<E>(entailment, justificationAxioms);
                  }
  
              }
              justificationTimer.stop();
  
          }
          catch (TimeOutException e) {
              transmitter.recordMeasurement(findOneInfo, "reasoner time out", true);
              throw e;
          }
          catch (ExplanationGeneratorInterruptedException e) {
              transmitter.recordMeasurement(findOneInfo, "interrupted", true);
              throw e;
          }
          catch (RuntimeException e) {
              transmitter.recordException(findOneInfo, e);
              throw e;
          }
          finally {
              transmitter.recordMeasurement(findOneInfo, "input size", module.size());
              transmitter.recordMeasurement(findOneInfo, "entailed", entailed);
              transmitter.recordMeasurement(findOneInfo, "self justification", result.isJustificationEntailment());
              transmitter.recordMeasurement(findOneInfo, "justification size", result.getSize());
              transmitter.recordTiming(findOneInfo, "time", justificationTimer);
              recordJustification(entailment, findOneInfo, result);
              transmitter.endTransmission(findOneInfo);
          }
  
  
          return result;
      }