The purpose of this document is to demonstrate some of the formulas that Math Pattern Hunter is capable of handling. The examples are made up and serve more to show off the program's print function than marvel at the formula discovery (for that see the Formula Discoveries page). In the diagrams the function denoted "fn" can stand for any function that the program can handle. Note that if these functions were tested in a run through Math Pattern Hunter they would likely get simplified considerably.

This example is the 12th formula in "/usr/share/math_pattern_hunter/input_patterns.test".

           fn()        fn()
fn()      /           /    
---- fn()^     * fn()^     
fn()                       

This example is the 9th formula in "/usr/share/math_pattern_hunter/input_patterns.test".

      fn()                      
---------------- fn()           
           fn()                 
fn()      /                     
---- fn()^                  fn()
fn()                       /    
--------------------- fn()^     
        fn()                    

Now add in some real functions and variables (...). This example is (12 + 1)th in "/usr/share/math_pattern_hunter/input_patterns.test".

                 2k+1(n)                   
                /               minus_one()
2k(j) * 2k+1(j)^               /           
------------------------- k(n)^            
         1                                 
       ----- k(n)                          
       2k(n)                               

Finally, this example is from the guts of "test_print.cpp" in the Math Pattern Hunter source code ± some random function and variable fills. Again, if this function were used in the program quite a bit of simplification would happen.

                                 2k(n)                                            
          minus_one()           /                                         k(n)
        --------------- 2k+1(n)^                        2k(j)            /    
                 2k(j)                              ----------- 2k+1(j)^     
                /                                  / minus_one()              
        2k+1(j)^                                  /                            
-------------------------------------------- k(n)^                             
                                       k(n)                                      
                           k(j)       /                                          
                           ---- 2k(j)^                                           
                         / k(j)                                                  
minus_one()             /                                                         
----------- minus_one()^                                                          
minus_one()