original_docstring: 
          Check if two terms match and compute the corresponding variable
          bindings if they do.
  
          Args:
              other: The term to match this one with.
  
          Returns:
              A tuple containing a boolean indicating whether the terms
              match, as well as a dict with the variables bindings if
              they do (the dict is empty if they don't).
          
docstring: Check if two terms match and compute the corresponding variable
  bindings if they do.
docstring_tokens: Check if two terms match and compute the corresponding variable bindings if they do .
code: def match(self, other):
          """
          Check if two terms match and compute the corresponding variable
          bindings if they do.
  
          Args:
              other: The term to match this one with.
  
          Returns:
              A tuple containing a boolean indicating whether the terms
              match, as well as a dict with the variables bindings if
              they do (the dict is empty if they don't).
          """
          assert isinstance(other, Term), "Other must be another term"
  
          if type(self.sort) != GenericSort and\
             type(other.sort) != GenericSort and\
             self.sort != other.sort:
              return (False, {})
  
          if type(self.sort) == GenericSort and\
             type(self.head) == Operation and\
             self.head.name not in other.head.sort.__dict__:
              return (False, {})
  
          if type(other.sort) == GenericSort and\
             type(other.head) == Operation and\
             other.head.name not in self.head.sort.__dict__:
              return (False, {})
  
          bindings = {}
  
          def compare(lhs, rhs):
              if type(lhs.head) == Variable and type(rhs.head) == Variable:
                  if (lhs.head in bindings and bindings[lhs.head] != rhs)\
                     or (rhs.head in bindings and bindings[rhs.head] != lhs):
                      return False
                  else:
                      bindings[lhs.head] = rhs
                      bindings[rhs.head] = lhs
                      return True
  
              elif type(lhs.head) == Variable and type(rhs.head) == Operation:
                  if lhs.head in bindings and bindings[lhs.head] != rhs:
                      return False
                  else:
                      bindings[lhs.head] = rhs
                      return True
  
              elif type(lhs.head) == Operation and type(rhs.head) == Variable:
                  if rhs.head in bindings and bindings[rhs.head] != lhs:
                      return False
                  else:
                      bindings[rhs.head] = lhs
                      return True
  
              elif type(lhs.head) == Operation and type(rhs.head) == Operation:
                  if lhs.head == rhs.head:
                      equivalent = True
                      for i in range(len(lhs.args)):
                          equivalent = equivalent and compare(lhs.args[i],
                                                              rhs.args[i])
                      return equivalent
                  else:
                      return False
  
              else:
                  return False
  
          return (compare(self, other), bindings)
code_tokens: def match ( self , other ) : assert isinstance ( other , Term ) , "Other must be another term" if type ( self . sort ) != GenericSort and type ( other . sort ) != GenericSort and self . sort != other . sort : return ( False , { } ) if type ( self . sort ) == GenericSort and type ( self . head ) == Operation and self . head . name not in other . head . sort . __dict__ : return ( False , { } ) if type ( other . sort ) == GenericSort and type ( other . head ) == Operation and other . head . name not in self . head . sort . __dict__ : return ( False , { } ) bindings = { } def compare ( lhs , rhs ) : if type ( lhs . head ) == Variable and type ( rhs . head ) == Variable : if ( lhs . head in bindings and bindings [ lhs . head ] != rhs ) or ( rhs . head in bindings and bindings [ rhs . head ] != lhs ) : return False else : bindings [ lhs . head ] = rhs bindings [ rhs . head ] = lhs return True elif type ( lhs . head ) == Variable and type ( rhs . head ) == Operation : if lhs . head in bindings and bindings [ lhs . head ] != rhs : return False else : bindings [ lhs . head ] = rhs return True elif type ( lhs . head ) == Operation and type ( rhs . head ) == Variable : if rhs . head in bindings and bindings [ rhs . head ] != lhs : return False else : bindings [ rhs . head ] = lhs return True elif type ( lhs . head ) == Operation and type ( rhs . head ) == Operation : if lhs . head == rhs . head : equivalent = True for i in range ( len ( lhs . args ) ) : equivalent = equivalent and compare ( lhs . args [ i ] , rhs . args [ i ] ) return equivalent else : return False else : return False return ( compare ( self , other ) , bindings )
short_docstring: Check if two terms match and compute the corresponding variable
  bindings if they do.
short_docstring_tokens: Check if two terms match and compute the corresponding variable bindings if they do .
comment: """
          Check if two terms match and compute the corresponding variable
          bindings if they do.
  
          Args:
              other: The term to match this one with.
  
          Returns:
              A tuple containing a boolean indicating whether the terms
              match, as well as a dict with the variables bindings if
              they do (the dict is empty if they don't).
          """