Remove debugging leftover
Fix imports in hyperexpand.py
Rename IndexPair to Hyper_Function and subclass Expr

This class actually represents a hypergeometric function.
This makes it explicit.
s/x > 0/x.is_positive/ and similar changes

bool(x > 0) doesn't return a meaningful result when x is
symbolic, whereas x.is_positive does.
Simplify Lambda.__call__
Add Hyper_Function.__call__
Add simple tests for Hyper_Function
Add Hyper_Function._hashable_content.

Makes equality comparisons work correctly.
Use Hyper_Function in Formula
Refactor Hyper_Function.compute_buckets()

* Use sift()
* Take advantage of the return value being a defaultdict(list)
Add property Hyper_Function.gamma
Remove Hyper_Function.compute_buckets().

Instead, just use sift().
Rename IndexQuadruple to G_Function and make it callable.
Make G_Function a subclass of Expr.
Start implementing differential operators
Remove complicated piece of code that doesn't seem useful.
Formula.find_instantiations() returns a replacement dict.

Formula.find_instantiations can be quite slow, and spends most
of its time performing substitutions. Extracting the substitution
step into Formula.do_subs() is a first step towards making them
more lazily.
Extract Hyper_Function._is_suitable_origin from Formula.is_suitable

Dealing with Hyper_Function objects is cheap compared to working
with matrices. The extracted part of Formula.is_suitable() is
cheap but contains the most significant part of the test, cf.
sample line_prof output below.


In [1]: from sympy.simplify.hyperexpand import Formula

In [2]: from sympy.simplify.tests.test_hyperexpand import test_meijerg_expand

In [3]: %lprun -f Formula.is_suitable test_meijerg_expand()
Timer unit: 1e-06 s

File: /home/ronan/dev/sympy/sympy/simplify/hyperexpand.py
Function: is_suitable at line 761
Total time: 7.69085 s

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
   761                                               def is_suitable(self):
   762                                                   """
   763                                                   Decide if the formula is suitable.
   764
   765                                                   A formula is suitable iff it has no symbolic parameters, the function
   766                                                   is a suitable origin and the matrix representations are well defined.
   767
   768                                                   """
   769       525         5471     10.4      0.1          if len(self.symbols) > 0:
   770                                                       return None
   771       525       530601   1010.7      6.9          if not self.func._is_suitable_origin():
   772        38          174      4.6      0.0              return False
   773      1948        14713      7.6      0.2          for e in [self.B, self.M, self.C]:
   774      1461      7137660   4885.5     92.8              if e.has(S.NaN, oo, -oo, zoo):
   775                                                           return False
   776       487         2234      4.6      0.0          return True
FormulaCollection.lookup_origin: do matrix ops last

Matrix operations are the most expensive part of
lookup_collection(). Doing them as late as possible, after
various bad cases have been filtered out, reduces their number
significantly. This reduces the function's running time by up
to 40%.

* Inline Formula.do_ops() and Formula.is_suitable().
* Remove guard against symbolic formulas, since find_instantations()
  cannot return these.
* Reorder operations.