public static boolean hasShallowDisproofP(ControlFrame frame) {
    { Iterator iterator = ((Iterator)(KeyValueList.dynamicSlotValue(frame.dynamicSlots, Logic.SYM_STELLA_ITERATOR, null)));
      Proposition proposition = frame.proposition;
      TruthValue truthvalue = frame.truthValue;
      boolean hasdisproofP = false;

      KeyValueList.setDynamicSlotValue(frame.dynamicSlots, Logic.SYM_STELLA_ITERATOR, null, null);
      { Object old$ReversepolarityP$000 = Logic.$REVERSEPOLARITYp$.get();

        try {
          Native.setBooleanSpecial(Logic.$REVERSEPOLARITYp$, !frame.reversePolarityP);
          frame.reversePolarityP = ((Boolean)(Logic.$REVERSEPOLARITYp$.get())).booleanValue();
          ControlFrame.setFrameTruthValue(frame, null);
          if ((((((QueryIterator)(Logic.$QUERYITERATOR$.get())) != null) &&
              (((QueryIterator)(Logic.$QUERYITERATOR$.get())).partialMatchStrategy != null)) &&
              Stella_Object.isaP(((QueryIterator)(Logic.$QUERYITERATOR$.get())).partialMatchStrategy, Logic.SGT_LOGIC_WHYNOT_PARTIAL_MATCH)) &&
              (proposition.kind == Logic.KWD_ISA)) {
            if (!((Boolean)(Logic.$REVERSEPOLARITYp$.get())).booleanValue()) {
              hasdisproofP = ControlFrame.tryIsaPropositionProof(frame) == Logic.KWD_FINAL_SUCCESS;
            }
            else {
              { NamedDescription queriedtype = Logic.getDescription(proposition.operator);
                Stella_Object instance = Logic.argumentBoundTo((proposition.arguments.theArray)[0]);
                Cons assertedtypes = Stella.NIL;

                if (instance != null) {
                  { Object old$ReversepolarityP$001 = Logic.$REVERSEPOLARITYp$.get();

                    try {
                      Native.setBooleanSpecial(Logic.$REVERSEPOLARITYp$, false);
                      assertedtypes = Logic.allAssertedTypes(instance);

                    } finally {
                      Logic.$REVERSEPOLARITYp$.set(old$ReversepolarityP$001);
                    }
                  }
                  { Stella_Object type = null;
                    Cons iter000 = assertedtypes;

                    loop000 : for (;!(iter000 == Stella.NIL); iter000 = iter000.rest) {
                      type = iter000.value;
                      if (Description.disjointTermsP(((Description)(type)), queriedtype)) {
                        hasdisproofP = true;
                        ControlFrame.setFrameTruthValue(frame, Logic.TRUE_TRUTH_VALUE);
                        break loop000;
                      }
                    }
                  }
                }
              }
            }
          }
          if (!(hasdisproofP)) {
            hasdisproofP = ControlFrame.tryScanPropositionsProof(frame) == Logic.KWD_FINAL_SUCCESS;
          }
          if ((!hasdisproofP) &&
              (((Boolean)(Logic.$REVERSEPOLARITYp$.get())).booleanValue() &&
               ((frame.proposition.kind == Logic.KWD_FUNCTION) ||
                Proposition.singleValuedPredicateP(frame.proposition)))) {
            hasdisproofP = ControlFrame.tryScanForValueClashProof(frame) == Logic.KWD_FINAL_SUCCESS;
          }
          frame.reversePolarityP = !frame.reversePolarityP;

        } finally {
          Logic.$REVERSEPOLARITYp$.set(old$ReversepolarityP$000);
        }
      }
      if (!(hasdisproofP)) {
        frame.truthValue = truthvalue;
      }
      KeyValueList.setDynamicSlotValue(frame.dynamicSlots, Logic.SYM_STELLA_ITERATOR, iterator, null);
      return (hasdisproofP);
    }
  }