If the other is as or more specific than self
770883
def is_entailed_by(self, other):
        
        other = BoolCell.coerce(other)
        if self.value == U or other.value == self.value:
            return True
        return False
1150462
def match(self, other):
        """"""

        if len(self) != len(other):
            raise ValueError()
        for s1, s2 in zip(self, other):
            i = s2.position - s1.position
            if i < 0:
                return False
            n = len(s1)
            while i+n > len(s2) and s1[n-1] == syntax.BLANK:
                n -= 1
            if s2.values[i:i+n] != s1.values[:n]:
                return False
        return True
696139
def _eq(self, other):
        """"""
        return (self.type, self.value) == (other.type, other.value)
1004532
def __i(self, other, func):
        """"""

        if isinstance(other, type(self)):
            other = tuple(other)

        elif isinstance(other, self.__contenttype__):
            other = (other, )

        for melt in list(other):
            if not isinstance(melt, self.__contenttype__):
                raise TypeError('Wrong element {0}'.format(melt))

            else:
                func(melt)

        return self
1182238
def fuzzy_match(self, other):
        
        magic, fuzzy = False, False
        try:
            magic = self.alias == other.magic
        except AttributeError:
            pass

        if '.' in self.alias:
            major = self.alias.split('.')[0]
            fuzzy = major == other.alias
        return magic or fuzzy
123021
def within(self, other: "Interval", inclusive: bool = True) -> bool:
        
        if not other:
            return False
        if inclusive:
            return self.start >= other.start and self.end <= other.end
        else:
            return self.start > other.start and self.end < other.end
308278
def hasAspect(obj1, obj2, aspList):
    
    aspType = aspectType(obj1, obj2, aspList)
    return aspType != const.NO_ASPECT
45058
def _match_literal(self, a, b=None):
        """"""

        return a.lower() == b if not self.case_sensitive else a == b
1305368
def _compare_title(self, other):
        """"""

        # If title is omitted, assume a match
        if not self.title or not other.title:
            return True

        titles = set(self.title_list + other.title_list)

        return not (titles & MALE_TITLES and titles & FEMALE_TITLES)
1073087
def eq_or_parent(self, other):
        
        return self.parts[: len(other.parts)] == other.parts[: len(self.parts)]
231234
def is_contradictory(self, other):
        
        other = self.coerce(other)
        to_i = self.to_i
        assert to_i(other.low) <= to_i(other.high), "Low must be <= high"
        if max(map(to_i, [other.low, self.low])) <= min(map(to_i, [other.high, self.high])):
            return False
        else:
            return True
484832
def is_subset(self, other):
        """"""
        if isinstance(other, Permissions):
            return (self.value & other.value) == self.value
        else:
            raise TypeError("cannot compare {} with {}".format(self.__class__.__name__, other.__class__.__name__))
144769
def _one_contains_other(s1, s2):
    
    return min(len(s1), len(s2)) == len(s1 & s2)
998931
def isAncestorOf(self, other):
    '''

    '''
    if isinstance(other, Key):
      return other._string.startswith(self._string + '/')
    raise TypeError('%s is not of type %s' % (other, Key))
1209780
def amod(a, b):
    ''''''
    modded = int(a % b)
    return b if modded is 0 else modded
357028
function(a, b) {
    if (a !== b) {
      const atype = whatis(a);
      const btype = whatis(b);

      if (atype === btype) {
        return _equal.hasOwnProperty(atype) ? _equal[atype](a, b) : a == b;
      }

      return false;
    }

    return true;
  }
1322414
def is_entailed_by(self, other):
        
        other = IntervalCell.coerce(other)
        return other.low >= self.low and other.high <= self.high