Kolmogorov complexity added

Author: shahriariravanian

src/candidates.jl

@@ -28,14 +28,20 @@ function generate_basis(eq, x, try_kernel = true)
     return cache.(unique([one(x); [equivalent(t, x) for t in terms(S)]]))
 end
 
-function expand_basis(basis, x)
-    b = sum(expr.(basis))
-    δb = sum(deriv!.(basis, x))
+function expand_basis(basis, x; Kmax=1000)
+    b = sum(expr.(basis))    
+
+    Kb = complexity(b)		# Kolmogorov complexity
+	if Kb > Kmax
+		return basis, false
+	end
+	
+    δb = sum(deriv!.(basis, x))	    
     eq = (1 + x) * (b + δb)
     eq = expand(eq)
     S = Set{Any}()
     enqueue_expr!(S, eq, x)
-    return cache.([one(x); [s for s in S]])
+    return cache.([one(x); [s for s in S]]), true
 end
 
 function closure(eq, x; max_terms = 50)

src/homotopy.jl

@@ -112,6 +112,8 @@ function ∂(x)
     return isequal(d, 0) ? 1 : d
 end
 
+@syms 𝛷(x)
+
 partial_int_rules = [
                      # trigonometric functions
                      @rule 𝛷(sin(~x)) => (cos(~x) + si(~x), ∂(~x))
@@ -128,19 +130,19 @@ partial_int_rules = [
                      @rule 𝛷(sech(~x)) => (atan(sinh(~x)), ∂(~x))
                      @rule 𝛷(coth(~x)) => (log(sinh(~x)), ∂(~x))
                      # 1/trigonometric functions
-                     @rule 𝛷(1 / sin(~x)) => (log(csc(~x) + cot(~x)), ∂(~x))
-                     @rule 𝛷(1 / cos(~x)) => (log(sec(~x) + tan(~x)), ∂(~x))
-                     @rule 𝛷(1 / tan(~x)) => (log(sin(~x)), ∂(~x))
-                     @rule 𝛷(1 / csc(~x)) => (cos(~x), ∂(~x))
-                     @rule 𝛷(1 / sec(~x)) => (sin(~x), ∂(~x))
-                     @rule 𝛷(1 / cot(~x)) => (log(cos(~x)), ∂(~x))
+                     @rule 𝛷(1 / sin(~x)) => (log(csc(~x) + cot(~x)) + log(sin(~x)), ∂(~x))
+                     @rule 𝛷(1 / cos(~x)) => (log(sec(~x) + tan(~x)) + log(cos(~x)), ∂(~x))
+                     @rule 𝛷(1 / tan(~x)) => (log(sin(~x)) + log(tan(~x)), ∂(~x))
+                     @rule 𝛷(1 / csc(~x)) => (cos(~x) + log(csc(~x)), ∂(~x))
+                     @rule 𝛷(1 / sec(~x)) => (sin(~x) + log(sec(~x)), ∂(~x))
+                     @rule 𝛷(1 / cot(~x)) => (log(cos(~x)) + log(cot(~x)), ∂(~x))
                      # 1/hyperbolic functions
-                     @rule 𝛷(1 / sinh(~x)) => (log(tanh(~x / 2)), ∂(~x))
-                     @rule 𝛷(1 / cosh(~x)) => (atan(sinh(~x)), ∂(~x))
-                     @rule 𝛷(1 / tanh(~x)) => (log(sinh(~x)), ∂(~x))
-                     @rule 𝛷(1 / csch(~x)) => (cosh(~x), ∂(~x))
-                     @rule 𝛷(1 / sech(~x)) => (sinh(~x), ∂(~x))
-                     @rule 𝛷(1 / coth(~x)) => (log(cosh(~x)), ∂(~x))
+                     @rule 𝛷(1 / sinh(~x)) => (log(tanh(~x / 2)) + log(sinh(~x)), ∂(~x))
+                     @rule 𝛷(1 / cosh(~x)) => (atan(sinh(~x)) + log(cosh(~x)), ∂(~x))
+                     @rule 𝛷(1 / tanh(~x)) => (log(sinh(~x)) + log(tanh(~x)), ∂(~x))
+                     @rule 𝛷(1 / csch(~x)) => (cosh(~x) + log(csch(~x)), ∂(~x))
+                     @rule 𝛷(1 / sech(~x)) => (sinh(~x) + log(sech(~x)), ∂(~x))
+                     @rule 𝛷(1 / coth(~x)) => (log(cosh(~x)) + log(coth(~x)), ∂(~x))
                      # inverse trigonometric functions
                      @rule 𝛷(asin(~x)) => (~x * asin(~x) + sqrt(1 - ~x * ~x), ∂(~x))
                      @rule 𝛷(acos(~x)) => (~x * acos(~x) + sqrt(1 - ~x * ~x), ∂(~x))
@@ -168,15 +170,15 @@ partial_int_rules = [
                      @rule 𝛷(sqrt(~x)) => (sum(candidate_sqrt(~x, 0.5); init = one(~x)), ∂(~x));
                      @rule 𝛷(1 / sqrt(~x)) => (sum(candidate_sqrt(~x, -0.5); init = one(~x)), ∂(~x));
                      # rational functions                                                              
-                     @rule 𝛷(1 / ^(~x::is_poly, ~k)) => (sum(candidate_pow_minus(~x, -~k);
+                     @rule 𝛷(1 / ^(~x::is_poly, ~k::is_pos_int)) => (sum(candidate_pow_minus(~x, -~k);
                                                                  init = one(~x)), 1)
                      @rule 𝛷(1 / ~x::is_poly) => (sum(candidate_pow_minus(~x, -1);
                                                                  init = one(~x)), 1)
                      @rule 𝛷(^(~x, -1)) => (log(~x), ∂(~x))
                      @rule 𝛷(^(~x, ~k::is_neg_int)) => (sum(^(~x, i) for i in (~k + 1):-1),
                                                         ∂(~x))
                      @rule 𝛷(1 / ~x) => (log(~x), ∂(~x))
-                     @rule 𝛷(^(~x, ~k)) => (sum(^(~x, i+1) for i=1:~k+1), ∂(~x))
+                     @rule 𝛷(^(~x, ~k::is_pos_int)) => (sum(^(~x, i+1) for i=1:~k+1), ∂(~x))
                      @rule 𝛷(1) => (𝑥, 1)
                      @rule 𝛷(~x) => ((~x + ^(~x, 2)), ∂(~x))]
 

src/integral.jl

@@ -204,8 +204,12 @@ function integrate_term(eq, x, l; kwargs...)
         inform(l, "Failed numeric")
 
         if i < num_steps
-            basis1 = expand_basis(basis1, x)
-            basis2 = expand_basis(basis2, x)
+            basis1, ok1 = expand_basis(basis1, x)
+            basis2, ok2 = expand_basis(basis2, x)
+            
+            if !ok1 && ~ok2            	
+            	break
+            end
 
             if show_basis
                 inform(l, "Expanding the basis (|β| = $(length(basis)))", basis1)

src/rules.jl

@@ -258,4 +258,24 @@ inv_rules = [@rule Ω(1 / ~x) => ~x
 
 inverse(eq) = Prewalk(PassThrough(Chain(inv_rules)))(Ω(value(eq)))
 
+###############################################################################
+
+is_sym(x) = first(ops(x)) isa Sym
+
+h_rules = [
+			@rule +(~~xs) => 1 + sum(~~xs)
+			@rule *(~~xs) => 1 + sum(~~xs)
+			@rule ~x / ~y => 1 + ~x + ~y
+			@rule ^(~x, ~y) => 1 + ~x + ~y
+			@rule log(~x) => 1 + ~x
+			@rule (~f)(~x) => 1 + ~x
+			@rule ~x::is_sym => 1
+		  ]			
+
+# complexity returns a measure of the complexity of an equation
+# it is roughly similar ro kolmogorov complexity
+function complexity(eq)
+	_, eq = ops(eq)	
+	return Prewalk(PassThrough(Chain(h_rules)))(eq)
+end