public static void postRelatedFacts(Stella_Object self, PropagationEnvironment environment) {
    { Surrogate testValue000 = Stella_Object.safePrimaryType(self);

      if (Surrogate.subtypeOfP(testValue000, Logic.SGT_LOGIC_LOGIC_OBJECT)) {
        { LogicObject self000 = ((LogicObject)(self));

          if (environment.elaboratedObjects.memberP(self000)) {
            return;
          }
          else {
            environment.elaboratedObjects.insert(self000);
          }
          { Proposition p = null;
            Iterator iter000 = Logic.unfilteredDependentPropositions(self000, null).allocateIterator();

            while (iter000.nextP()) {
              p = ((Proposition)(iter000.value));
              Logic.postRelatedFacts(p, environment);
              { Stella_Object arg = null;
                Vector vector000 = p.arguments;
                int index000 = 0;
                int length000 = vector000.length();

                for (;index000 < length000; index000 = index000 + 1) {
                  arg = (vector000.theArray)[index000];
                  if ((!(arg == self000)) &&
                      Proposition.followDependentPropositionArgumentP(p, arg)) {
                    Logic.postRelatedFacts(arg, environment);
                  }
                }
              }
            }
          }
          { LogicObject equivalent = null;
            Cons iter001 = self000.variableValueInverse();

            for (;!(iter001 == Stella.NIL); iter001 = iter001.rest) {
              equivalent = ((LogicObject)(iter001.value));
              Logic.postRelatedFacts(equivalent, environment);
            }
          }
        }
      }
      else if (Surrogate.subtypeOfP(testValue000, Logic.SGT_LOGIC_PROPOSITION)) {
        { Proposition self000 = ((Proposition)(self));

          if (((Keyword)(environment.evaluationStates.lookup(self000))) != null) {
            return;
          }
          { boolean assertedP = !Proposition.unknownP(self000);
            Skolem outputskolem = null;

            if ((!assertedP) &&
                (self000.kind == Logic.KWD_FUNCTION)) {
              assertedP = Proposition.functionWithDefinedValueP(self000);
            }
            if (assertedP) {
              Proposition.recursivelyReactToInferenceUpdate(self000);
            }
            { Proposition p = null;
              Iterator iter002 = self000.dependentPropositions.allocateIterator();

              while (iter002.nextP()) {
                p = ((Proposition)(iter002.value));
                Logic.postRelatedFacts(p, environment);
              }
            }
          }
        }
      }
      else if (Surrogate.subtypeOfSurrogateP(testValue000)) {
        { Surrogate self000 = ((Surrogate)(self));

          if (self000.surrogateValue != null) {
            Logic.postRelatedFacts(self000.surrogateValue, environment);
          }
        }
      }
      else if (Surrogate.subtypeOfClassP(testValue000)) {
        { Stella_Class self000 = ((Stella_Class)(self));

          if (((NamedDescription)(KeyValueList.dynamicSlotValue(self000.dynamicSlots, Logic.SYM_LOGIC_DESCRIPTION, null))) != null) {
            Logic.postRelatedFacts(((NamedDescription)(KeyValueList.dynamicSlotValue(self000.dynamicSlots, Logic.SYM_LOGIC_DESCRIPTION, null))), environment);
          }
        }
      }
      else if (Surrogate.subtypeOfP(testValue000, Logic.SGT_STELLA_SLOT)) {
        { Slot self000 = ((Slot)(self));

          if (((NamedDescription)(KeyValueList.dynamicSlotValue(self000.dynamicSlots, Logic.SYM_LOGIC_DESCRIPTION, null))) != null) {
            Logic.postRelatedFacts(((NamedDescription)(KeyValueList.dynamicSlotValue(self000.dynamicSlots, Logic.SYM_LOGIC_DESCRIPTION, null))), environment);
          }
        }
      }
      else {
      }
    }
  }