Returns true if both subj and obj are grounded to the UN ontology.
184708
def _(s: Influence, cutoff: float = 0.7) -> bool:
    

    return all(map(lambda c: is_well_grounded(c, cutoff), s.agent_list()))
1027107
def is_sub_to_all(self, *super_entities):
        
        if super_entities:
            if len(super_entities) == 1:
                # Optimize for the case of just one super entity since this is a much less intensive query
                has_subset = EntityRelationship.objects.filter(
                    super_entity=super_entities[0]).values_list('sub_entity', flat=True)
            else:
                # Get a list of entities that have super entities with all types
                has_subset = EntityRelationship.objects.filter(
                    super_entity__in=super_entities).values('sub_entity').annotate(Count('super_entity')).filter(
                    super_entity__count=len(set(super_entities))).values_list('sub_entity', flat=True)

            return self.filter(id__in=has_subset)
        else:
            return self
1085729
def _is_child_wikicode(self, obj, recursive=True):
        """"""
        def deref(nodes):
            if isinstance(nodes, _ListProxy):
                return nodes._parent  # pylint: disable=protected-access
            return nodes

        target = deref(obj.nodes)
        if target is deref(self.nodes):
            return True
        if recursive:
            todo = [self]
            while todo:
                code = todo.pop()
                if target is deref(code.nodes):
                    return True
                for node in code.nodes:
                    todo += list(node.__children__())
        return False
687135
function(fact) {
        if ((this.explicit != fact.explicit) ||
            (this.subject != fact.subject) ||
            (this.predicate != fact.predicate) ||
            (this.object != fact.object)) {
            return false;
        }
        return true;
    }
96324
def issuperset(self, other):
        """"""
        self._binary_sanity_check(other)
        return set.issuperset(self, other)
943051
function (obj) {
        return Boolean(obj) && ((obj instanceof Response) ||
            _.inSuperChain(obj.constructor, '_postman_propertyName', Response._postman_propertyName));
    }
729448
function (obj) {
        return Boolean(obj) && ((obj instanceof CertificateList) ||
          _.inSuperChain(obj.constructor, '_postman_propertyName', CertificateList._postman_propertyName));
    }
560806
def is_suburi(self, base, test):
        
        if base == test:
            return True
        if base[0] != test[0]:
            return False
        common = posixpath.commonprefix((base[1], test[1]))
        if len(common) == len(base[1]):
            return True
        return False
1103792
public static boolean equalsOne(Object _obj, Object... _arrObj) {
       if (_obj == null || _arrObj == null) {
           return false;
       }
       for (Object o : _arrObj) {
           if (o != null && _obj.equals(o)) {
               return true;
           }
       }
       return false;
   }
1060091
def super_and_sub?(sup, sub)
      fqsup = qualify(sup)
      cls = qualify(store.get_superclass(sub), sub)
      until cls.nil?
        return true if cls == fqsup
        cls = qualify(store.get_superclass(cls), cls)
      end
      false
    end
252804
def is_subdict(self, a,b):
        '''
        
        '''
        return all((k in b and b[k]==v) for k,v in a.iteritems())
770883
def is_entailed_by(self, other):
        
        other = BoolCell.coerce(other)
        if self.value == U or other.value == self.value:
            return True
        return False
844869
public boolean isLinked(ParaObject obj, ParaObject toObj) {
		if (obj == null || obj.getId() == null || toObj == null || toObj.getId() == null) {
			return false;
		}
		return isLinked(obj, toObj.getType(), toObj.getId());
	}
1172081
def issubclass(cls, ifaces):
    """"""
    ifaces = _ensure_ifaces_tuple(ifaces)
    for iface in ifaces:

        return all((
            _check_for_definition(
                iface,
                cls,
                '__iclassattribute__',
                _is_attribute,
            ),
            _check_for_definition(
                iface,
                cls,
                '__iproperty__',
                _is_property,
            ),
            _check_for_definition(
                iface,
                cls,
                '__imethod__',
                _is_method,
            ),
            _check_for_definition(
                iface,
                cls,
                '__iclassmethod__',
                _is_classmethod,
            ),
        ))
643693
function isBoolean(obj) {
		var type = sType(obj);
		return (_.has(obj, '$value') && (type === 'xsd:boolean' || type === 'boolean'));
	}
1342911
def node_is_subclass(cls, *subclass_names):
    """"""
    if not isinstance(cls, (ClassDef, Instance)):
        return False

    # if cls.bases == YES:
    #     return False
    for base_cls in cls.bases:
        try:
            for inf in base_cls.inferred():  # pragma no branch
                if inf.qname() in subclass_names:
                    return True

                if inf != cls and node_is_subclass(  # pragma no branch
                        inf, *subclass_names):
                    # check up the hierarchy in case we are a subclass of
                    # a subclass of a subclass ...
                    return True
        except InferenceError:  # pragma no cover
            continue

    return False
499330
final boolean isStructuralSubtype(ObjectType superType,
      ImplCache implicitImplCache, SubtypingMode subtypingMode) {
    // Union types should be handled by isSubtype already
    checkArgument(!this.isUnionType());
    checkArgument(!superType.isUnionType());
    Preconditions.checkArgument(superType.isStructuralType(),
        "isStructuralSubtype should be called with structural supertype. Found %s", superType);

    MatchStatus cachedResult = implicitImplCache.checkCache(this, superType);
    if (cachedResult != null) {
      return cachedResult.subtypeValue();
    }

    boolean result =
        isStructuralSubtypeHelper(
            this, superType, implicitImplCache, subtypingMode, VOIDABLE_PROPS_ARE_OPTIONAL);
    return implicitImplCache.updateCache(this, superType, MatchStatus.valueOf(result));
  }