public static void quickpropagateError(Proposition prop, double error) {
    { PropositionNeuralNetwork net = ((PropositionNeuralNetwork)(KeyValueList.dynamicSlotValue(prop.dynamicSlots, Logic.SYM_LOGIC_NEURAL_NETWORK, null)));
      double output = ((FloatWrapper)(KeyValueList.dynamicSlotValue(prop.dynamicSlots, Logic.SYM_LOGIC_MATCH_SCORE, Stella.NULL_FLOAT_WRAPPER))).wrapperValue;
      double fullError = error;
      double temp = 0.0;
      int numIn = 0;
      int numHidden = 0;
      Vector inputError = null;

      if (net != null) {
        numIn = net.input.length();
        numHidden = net.hidden.length();
        (net.input.theArray)[0] = (FloatWrapper.wrapFloat(1.0));
        { int i = Stella.NULL_INTEGER;
          int iter000 = 1;
          int upperBound000 = numIn - 1;

          for (;iter000 <= upperBound000; iter000 = iter000 + 1) {
            i = iter000;
            (net.input.theArray)[i] = (FloatWrapper.wrapFloat(((FloatWrapper)(KeyValueList.dynamicSlotValue(((Proposition)((prop.arguments.theArray)[(i - 1)])).dynamicSlots, Logic.SYM_LOGIC_MATCH_SCORE, Stella.NULL_FLOAT_WRAPPER))).wrapperValue));
          }
        }
        PropositionNeuralNetwork.activatePropositionalNeuralNetwork(net);
        error = error * (Logic.$SIGMOID_PRIME_OFFSET$ + (output * (1.0 - output)));
        inputError = Vector.newVector(numIn);
        Logic.zeroVector(inputError);
        { int h = Stella.NULL_INTEGER;
          int iter001 = 0;
          int upperBound001 = numHidden - 1;

          for (;iter001 <= upperBound001; iter001 = iter001 + 1) {
            h = iter001;
            (net.hoSlope.theArray)[h] = (FloatWrapper.wrapFloat(((FloatWrapper)((net.hoSlope.theArray)[h])).wrapperValue + (error * ((FloatWrapper)((net.hidden.theArray)[h])).wrapperValue)));
            temp = error * ((FloatWrapper)((net.ho.theArray)[h])).wrapperValue * (Logic.$SIGMOID_PRIME_OFFSET$ + (((FloatWrapper)((net.hidden.theArray)[h])).wrapperValue * (1.0 - ((FloatWrapper)((net.hidden.theArray)[h])).wrapperValue)));
            { int i = Stella.NULL_INTEGER;
              int iter002 = 0;
              int upperBound002 = numIn - 1;

              for (;iter002 <= upperBound002; iter002 = iter002 + 1) {
                i = iter002;
                (net.ihSlope.theArray)[((i * net.ihSlope.nofColumns) + h)] = (FloatWrapper.wrapFloat(((FloatWrapper)((net.ihSlope.theArray)[((i * net.ihSlope.nofColumns) + h)])).wrapperValue + (temp * ((FloatWrapper)((net.input.theArray)[i])).wrapperValue)));
                (inputError.theArray)[i] = (FloatWrapper.wrapFloat(((FloatWrapper)((inputError.theArray)[i])).wrapperValue + (temp * ((FloatWrapper)((net.ih.theArray)[((i * net.ih.nofColumns) + h)])).wrapperValue)));
              }
            }
          }
        }
      }
      { Keyword testValue000 = prop.kind;

        if ((testValue000 == Logic.KWD_AND) ||
            (testValue000 == Logic.KWD_OR)) {
          { Proposition child = null;
            Vector vector000 = ((Vector)(prop.arguments));
            int index000 = 0;
            int length000 = vector000.length();
            int i = Stella.NULL_INTEGER;
            int iter003 = 1;
            int upperBound003 = numIn - 1;

            for (;(index000 < length000) &&
                      (iter003 <= upperBound003); index000 = index000 + 1, iter003 = iter003 + 1) {
              child = ((Proposition)((vector000.theArray)[index000]));
              i = iter003;
              Proposition.quickpropagateError(child, ((FloatWrapper)((inputError.theArray)[i])).wrapperValue);
            }
          }
        }
        else {
          if (!(prop.support() == Stella.NIL)) {
            { Cons proofs = prop.support();
              Cons guilty = Stella.NIL;

              if (Logic.$RULE_COMBINATION$ == Logic.KWD_MAX) {
                guilty = Cons.consList(Cons.cons(((PartialSupport)(proofs.value)), Stella.NIL));
                { PartialSupport proof = null;
                  Cons iter004 = proofs.rest;

                  for (;!(iter004 == Stella.NIL); iter004 = iter004.rest) {
                    proof = ((PartialSupport)(iter004.value));
                    if (proof.score == output) {
                      guilty = Cons.consList(Cons.cons(proof, Stella.NIL));
                    }
                  }
                }
              }
              else if (Logic.$RULE_COMBINATION$ == Logic.KWD_NOISY_OR) {
                guilty = proofs;
              }
              else {
                { OutputStringStream stream000 = OutputStringStream.newOutputStringStream();

                  stream000.nativeStream.print("`" + Logic.$RULE_COMBINATION$ + "' is not a valid case option");
                  throw ((StellaException)(StellaException.newStellaException(stream000.theStringReader()).fillInStackTrace()));
                }
              }
              { PartialSupport proof = null;
                Cons iter005 = guilty;

                for (;!(iter005 == Stella.NIL); iter005 = iter005.rest) {
                  proof = ((PartialSupport)(iter005.value));
                  if (!Logic.$PARTIAL_SUPPORT_CACHE$.memberP(IntegerWrapper.wrapInteger(proof.id))) {
                    { Proposition fact = proof.fact;

                      if (proof.argumentScores.length() == 1) {
                        KeyValueList.setDynamicSlotValue(fact.dynamicSlots, Logic.SYM_LOGIC_MATCH_SCORE, FloatWrapper.wrapFloat(((FloatWrapper)(proof.argumentScores.value)).wrapperValue), Stella.NULL_FLOAT_WRAPPER);
                      }
                      else {
                        { FloatWrapper score = null;
                          Cons iter006 = proof.argumentScores;
                          Stella_Object arg = null;
                          Vector vector001 = fact.arguments;
                          int index001 = 0;
                          int length001 = vector001.length();

                          for (;(!(iter006 == Stella.NIL)) &&
                                    (index001 < length001); iter006 = iter006.rest, index001 = index001 + 1) {
                            score = ((FloatWrapper)(iter006.value));
                            arg = (vector001.theArray)[index001];
                            KeyValueList.setDynamicSlotValue(((Proposition)(arg)).dynamicSlots, Logic.SYM_LOGIC_MATCH_SCORE, FloatWrapper.wrapFloat(score.wrapperValue), Stella.NULL_FLOAT_WRAPPER);
                          }
                        }
                      }
                      Logic.$PARTIAL_SUPPORT_CACHE$.push(IntegerWrapper.wrapInteger(proof.id));
                      Proposition.quickpropagateError(proof.fact, fullError * proof.score);
                      Logic.$PARTIAL_SUPPORT_CACHE$.pop();
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }