mathai 0.6.9__tar.gz → 0.7.1__tar.gz

mathai-0.7.1/PKG-INFO

@@ -0,0 +1,239 @@
+Metadata-Version: 2.4
+Name: mathai
+Version: 0.7.1
+Summary: Mathematics solving Ai tailored to NCERT
+Home-page: https://github.com/infinity390/mathai4
+Author: educated indians are having a low iq and are good for nothing
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: lark-parser
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Math AI Documentation
+## Source
+Github repository of the code
+https://github.com/infinity390/mathai4
+
+## Philosophy
+I think it is a big realization in computer science and programming to realize that computers can solve mathematics.  
+This understanding should be made mainstream. It can help transform education, mathematical research, and computation of mathematical equations for work.
+
+## Societal Implications Of Such A Computer Program And The Author's Comment On Universities Of India
+I think mathematics is valued by society because of education. Schools and universities teach them.  
+So this kind of software, if made mainstream, could bring real change.
+
+## The Summary Of How Computer "Solves" Math
+Math equations are a tree data structure (`TreeNode` class).  
+We can manipulate the math equations using various algorithms (functions provided by the `mathai` library).  
+We first parse the math equation strings to get the tree data structure (`parse` function in `mathai`).
+
+## The Library
+Import the library by doing:
+
+```python
+from mathai import *
+```
+
+### str_form
+It is the string representation of a `TreeNode` math equation.
+
+#### Example
+```text
+(cos(x)^2)+(sin(x)^2)
+```
+
+Is represented internally as:
+
+```text
+f_add
+ f_pow
+  f_cos
+   v_0
+  d_2
+ f_pow
+  f_sin
+   v_0
+  d_2
+```
+
+#### Leaf Nodes
+
+**Variables** (start with a `v_` prefix):
+
+- `v_0` -> x
+- `v_1` -> y
+- `v_2` -> z
+- `v_3` -> a
+
+**Numbers** (start with `d_` prefix; only integers):
+
+- `d_-1` -> -1
+- `d_0` -> 0
+- `d_1` -> 1
+- `d_2` -> 2
+
+#### Branch Nodes
+- `f_add` -> addition
+- `f_mul` -> multiplication
+- `f_pow` -> power
+
+### parse
+Takes a math equation string and outputs a `TreeNode` object.
+
+```python
+from mathai import *
+
+equation = parse("sin(x)^2+cos(x)^2")
+print(equation)
+```
+
+#### Output
+```text
+(cos(x)^2)+(sin(x)^2)
+```
+
+### solve, simplify
+It simplifies and cleans up a given math equation.
+
+```python
+from mathai import *
+
+equation = simplify(parse("(x+x+x+x-1-1-1-1)*(4*x-4)*sin(sin(x+x+x)*sin(3*x))"))
+printeq(equation)
+```
+
+#### Output
+```text
+((-4+(4*x))^2)*sin((sin((3*x))^2))
+```
+
+### Incomplete Documentation, Will be updated and completed later on
+
+### Demonstrations
+
+#### Example Demonstration 1
+```python
+from mathai import *
+question_list_from_lecture = [
+    "2*x/(2*x^2 + 5*x + 2) > 1/(x + 1)",
+    "(x + 2)*(x + 3)/((x - 2)*(x - 3)) <= 1",
+    "(5*x - 1) < (x + 1)^2 & (x + 1)^2 < 7*x - 3",
+    "(2*x - 1)/(2*x^3 + 3*x^2 + x) > 0",
+    "abs(x + 5)*x + 2*abs(x + 7) - 2 = 0",
+    "x*abs(x) - 5*abs(x + 2) + 6 = 0",
+    "x^2 - abs(x + 2) + x > 0",
+    "abs(abs(x - 2) - 3) <= 2",
+    "abs(3*x - 5) + abs(8 - x) = abs(3 + 2*x)",
+    "abs(x^2 + 5*x + 9) < abs(x^2 + 2*x + 2) + abs(3*x + 7)"
+]
+
+for item in question_list_from_lecture:
+  eq = simplify(parse(item))
+  eq = dowhile(eq, absolute)
+  eq = simplify(factor1(fraction(eq)))
+  eq = prepare(eq)
+  eq = factor2(eq)
+  c = wavycurvy(eq & domain(eq)).fix()
+  print(c)
+```
+#### Output
+
+```
+(-2,-1)U(-(2/3),-(1/2))
+(-inf,0)U(2,3)U{0}
+(2,4)
+(-inf,-1)U(-(1/2),0)U(1/2,+inf)
+{-4,-3,-(3/2)-(sqrt(57)/2)}
+{-1,(5/2)-(sqrt(89)/2),(5/2)+(sqrt(41)/2)}
+(-inf,-sqrt(2))U((2*sqrt(2))/2,+inf)
+(-3,1)U(3,7)U{1,-3,7,3}
+(5/3,8)U{5/3,8}
+(-inf,-(7/3))
+```
+
+#### Example Demonstration 2
+```python
+from mathai import *
+def nested_func(eq_node):
+    eq_node = fraction(eq_node)
+    eq_node = simplify(eq_node)
+    eq_node = trig1(eq_node)
+    eq_node = trig0(eq_node)
+    return eq_node
+for item in ["(cosec(x)-cot(x))^2=(1-cos(x))/(1+cos(x))", "cos(x)/(1+sin(x)) + (1+sin(x))/cos(x) = 2*sec(x)",\
+             "tan(x)/(1-cot(x)) + cot(x)/(1-tan(x)) = 1 + sec(x)*cosec(x)", "(1+sec(x))/sec(x) = sin(x)^2/(1-cos(x))",\
+             "(cos(x)-sin(x)+1)/(cos(x)+sin(x)-1) = cosec(x)+cot(x)"]:
+  eq = logic0(dowhile(parse(item), nested_func))
+  print(eq)
+```
+#### Output
+
+```
+true
+true
+true
+true
+true
+```
+
+#### Example Demonstration 3
+```python
+from mathai import *
+
+eq = simplify(parse("integrate(2*x/(x^2+1),x)"))
+eq = integrate_const(eq)
+eq = integrate_fraction(eq)
+print(simplify(fraction(simplify(eq))))
+
+eq = simplify(parse("integrate(sin(cos(x))*sin(x),x)"))
+eq = integrate_subs(eq)
+eq = integrate_const(eq)
+eq = integrate_formula(eq)
+eq = integrate_clean(eq)
+print(simplify(eq))
+
+eq = simplify(parse("integrate(x*sqrt(x+2),x)"))
+eq = integrate_subs(eq)
+eq = integrate_const(eq)
+eq = integrate_formula(eq)
+eq = expand(eq)
+eq = integrate_const(eq)
+eq = integrate_summation(eq)
+eq = simplify(eq)
+eq = integrate_const(eq)
+eq = integrate_formula(eq)
+eq = integrate_clean(eq)
+print(simplify(fraction(simplify(eq))))
+
+eq = simplify(parse("integrate(x/(e^(x^2)),x)"))
+eq = integrate_subs(eq)
+eq = integrate_const(eq)
+eq = integrate_formula(eq)
+eq = simplify(eq)
+eq = integrate_formula(eq)
+eq = integrate_clean(eq)
+print(simplify(eq))
+
+eq = fraction(trig0(trig1(simplify(parse("integrate(sin(x)^4,x)")))))
+eq = integrate_const(eq)
+eq = integrate_summation(eq)
+eq = integrate_formula(eq)
+eq = integrate_const(eq)
+eq = integrate_formula(eq)
+print(factor0(simplify(fraction(simplify(eq)))))
+```
+#### Output
+
+```
+log(abs((1+(x^2))))
+cos(cos(x))
+((6*((2+x)^(5/2)))-(20*((2+x)^(3/2))))/15
+-((e^-(x^2))/2)
+-(((8*sin((2*x)))-(12*x)-sin((4*x)))/32)
+```

mathai-0.7.1/README.md

@@ -0,0 +1,222 @@
+# Math AI Documentation
+## Source
+Github repository of the code
+https://github.com/infinity390/mathai4
+
+## Philosophy
+I think it is a big realization in computer science and programming to realize that computers can solve mathematics.  
+This understanding should be made mainstream. It can help transform education, mathematical research, and computation of mathematical equations for work.
+
+## Societal Implications Of Such A Computer Program And The Author's Comment On Universities Of India
+I think mathematics is valued by society because of education. Schools and universities teach them.  
+So this kind of software, if made mainstream, could bring real change.
+
+## The Summary Of How Computer "Solves" Math
+Math equations are a tree data structure (`TreeNode` class).  
+We can manipulate the math equations using various algorithms (functions provided by the `mathai` library).  
+We first parse the math equation strings to get the tree data structure (`parse` function in `mathai`).
+
+## The Library
+Import the library by doing:
+
+```python
+from mathai import *
+```
+
+### str_form
+It is the string representation of a `TreeNode` math equation.
+
+#### Example
+```text
+(cos(x)^2)+(sin(x)^2)
+```
+
+Is represented internally as:
+
+```text
+f_add
+ f_pow
+  f_cos
+   v_0
+  d_2
+ f_pow
+  f_sin
+   v_0
+  d_2
+```
+
+#### Leaf Nodes
+
+**Variables** (start with a `v_` prefix):
+
+- `v_0` -> x
+- `v_1` -> y
+- `v_2` -> z
+- `v_3` -> a
+
+**Numbers** (start with `d_` prefix; only integers):
+
+- `d_-1` -> -1
+- `d_0` -> 0
+- `d_1` -> 1
+- `d_2` -> 2
+
+#### Branch Nodes
+- `f_add` -> addition
+- `f_mul` -> multiplication
+- `f_pow` -> power
+
+### parse
+Takes a math equation string and outputs a `TreeNode` object.
+
+```python
+from mathai import *
+
+equation = parse("sin(x)^2+cos(x)^2")
+print(equation)
+```
+
+#### Output
+```text
+(cos(x)^2)+(sin(x)^2)
+```
+
+### solve, simplify
+It simplifies and cleans up a given math equation.
+
+```python
+from mathai import *
+
+equation = simplify(parse("(x+x+x+x-1-1-1-1)*(4*x-4)*sin(sin(x+x+x)*sin(3*x))"))
+printeq(equation)
+```
+
+#### Output
+```text
+((-4+(4*x))^2)*sin((sin((3*x))^2))
+```
+
+### Incomplete Documentation, Will be updated and completed later on
+
+### Demonstrations
+
+#### Example Demonstration 1
+```python
+from mathai import *
+question_list_from_lecture = [
+    "2*x/(2*x^2 + 5*x + 2) > 1/(x + 1)",
+    "(x + 2)*(x + 3)/((x - 2)*(x - 3)) <= 1",
+    "(5*x - 1) < (x + 1)^2 & (x + 1)^2 < 7*x - 3",
+    "(2*x - 1)/(2*x^3 + 3*x^2 + x) > 0",
+    "abs(x + 5)*x + 2*abs(x + 7) - 2 = 0",
+    "x*abs(x) - 5*abs(x + 2) + 6 = 0",
+    "x^2 - abs(x + 2) + x > 0",
+    "abs(abs(x - 2) - 3) <= 2",
+    "abs(3*x - 5) + abs(8 - x) = abs(3 + 2*x)",
+    "abs(x^2 + 5*x + 9) < abs(x^2 + 2*x + 2) + abs(3*x + 7)"
+]
+
+for item in question_list_from_lecture:
+  eq = simplify(parse(item))
+  eq = dowhile(eq, absolute)
+  eq = simplify(factor1(fraction(eq)))
+  eq = prepare(eq)
+  eq = factor2(eq)
+  c = wavycurvy(eq & domain(eq)).fix()
+  print(c)
+```
+#### Output
+
+```
+(-2,-1)U(-(2/3),-(1/2))
+(-inf,0)U(2,3)U{0}
+(2,4)
+(-inf,-1)U(-(1/2),0)U(1/2,+inf)
+{-4,-3,-(3/2)-(sqrt(57)/2)}
+{-1,(5/2)-(sqrt(89)/2),(5/2)+(sqrt(41)/2)}
+(-inf,-sqrt(2))U((2*sqrt(2))/2,+inf)
+(-3,1)U(3,7)U{1,-3,7,3}
+(5/3,8)U{5/3,8}
+(-inf,-(7/3))
+```
+
+#### Example Demonstration 2
+```python
+from mathai import *
+def nested_func(eq_node):
+    eq_node = fraction(eq_node)
+    eq_node = simplify(eq_node)
+    eq_node = trig1(eq_node)
+    eq_node = trig0(eq_node)
+    return eq_node
+for item in ["(cosec(x)-cot(x))^2=(1-cos(x))/(1+cos(x))", "cos(x)/(1+sin(x)) + (1+sin(x))/cos(x) = 2*sec(x)",\
+             "tan(x)/(1-cot(x)) + cot(x)/(1-tan(x)) = 1 + sec(x)*cosec(x)", "(1+sec(x))/sec(x) = sin(x)^2/(1-cos(x))",\
+             "(cos(x)-sin(x)+1)/(cos(x)+sin(x)-1) = cosec(x)+cot(x)"]:
+  eq = logic0(dowhile(parse(item), nested_func))
+  print(eq)
+```
+#### Output
+
+```
+true
+true
+true
+true
+true
+```
+
+#### Example Demonstration 3
+```python
+from mathai import *
+
+eq = simplify(parse("integrate(2*x/(x^2+1),x)"))
+eq = integrate_const(eq)
+eq = integrate_fraction(eq)
+print(simplify(fraction(simplify(eq))))
+
+eq = simplify(parse("integrate(sin(cos(x))*sin(x),x)"))
+eq = integrate_subs(eq)
+eq = integrate_const(eq)
+eq = integrate_formula(eq)
+eq = integrate_clean(eq)
+print(simplify(eq))
+
+eq = simplify(parse("integrate(x*sqrt(x+2),x)"))
+eq = integrate_subs(eq)
+eq = integrate_const(eq)
+eq = integrate_formula(eq)
+eq = expand(eq)
+eq = integrate_const(eq)
+eq = integrate_summation(eq)
+eq = simplify(eq)
+eq = integrate_const(eq)
+eq = integrate_formula(eq)
+eq = integrate_clean(eq)
+print(simplify(fraction(simplify(eq))))
+
+eq = simplify(parse("integrate(x/(e^(x^2)),x)"))
+eq = integrate_subs(eq)
+eq = integrate_const(eq)
+eq = integrate_formula(eq)
+eq = simplify(eq)
+eq = integrate_formula(eq)
+eq = integrate_clean(eq)
+print(simplify(eq))
+
+eq = fraction(trig0(trig1(simplify(parse("integrate(sin(x)^4,x)")))))
+eq = integrate_const(eq)
+eq = integrate_summation(eq)
+eq = integrate_formula(eq)
+eq = integrate_const(eq)
+eq = integrate_formula(eq)
+print(factor0(simplify(fraction(simplify(eq)))))
+```
+#### Output
+
+```
+log(abs((1+(x^2))))
+cos(cos(x))
+((6*((2+x)^(5/2)))-(20*((2+x)^(3/2))))/15
+-((e^-(x^2))/2)
+-(((8*sin((2*x)))-(12*x)-sin((4*x)))/32)
+```

{mathai-0.6.9 → mathai-0.7.1}/mathai/base.py

@@ -370,21 +370,23 @@ def product(lst):
     for item in lst[1:]:
         s *= item
     return s
-def flatten_tree(node, add=[]):
+def flatten_tree(node):
+    if node is None:
+        return None
     if not node.children:
         return node
     ad = []
     if node.name in ["f_add", "f_mul", "f_and", "f_or", "f_wmul"]:
         merged_children = []
         for child in node.children:
-            flattened_child = flatten_tree(child, add)
+            flattened_child = flatten_tree(child)
             if flattened_child.name == node.name:
                 merged_children.extend(flattened_child.children)
             else:
                 merged_children.append(flattened_child)
         return TreeNode(node.name, merged_children)
     else:
-        node.children = [flatten_tree(child, add) for child in node.children]
+        node.children = [flatten_tree(child) for child in node.children]
         return node
 def dowhile(eq, fx):
     if eq is None:

mathai-0.7.1/mathai/expand.py

@@ -0,0 +1,175 @@
+from .base import *
+from .simplify import simplify
+import itertools
+
+def eliminate_powers(node):
+    if not node.children:
+        return node
+
+    node.children = [eliminate_powers(c) for c in node.children]
+
+    if node.name == "f_pow":
+        base, exp = node.children
+        n = frac(exp)
+
+        # Only expand positive integer powers
+        if not (n and n.denominator == 1 and n.numerator > 1):
+            return node
+
+        n = n.numerator
+
+        # ---- Multinomial expansion ----
+        if base.name == "f_add":
+            terms = []
+            for combo in itertools.product(base.children, repeat=n):
+                prod = combo[0]
+                for c in combo[1:]:
+                    prod = prod * c
+                terms.append(prod)
+            return simplify(TreeNode("f_add", terms))
+
+        # ---- Fallback: simple power ----
+        return TreeNode("f_mul", [base] * n)
+
+    return node
+
+
+
+# =====================================================
+# Phase 2: Single distributive rewrite (DEEPEST FIRST)
+# =====================================================
+
+def expand_once(node):
+    """
+    Performs exactly ONE distributive expansion.
+    Deepest-first (post-order).
+    """
+
+    # ---- recurse FIRST (this is the fix) ----
+    for i, c in enumerate(node.children):
+        new, changed = expand_once(c)
+        if changed:
+            node.children[i] = new
+            return node, True
+
+    # ---- now try expanding at this node ----
+    if node.name == "f_mul":
+        for i, child in enumerate(node.children):
+            if child.name == "f_add":
+                left = node.children[:i]
+                right = node.children[i+1:]
+
+                terms = []
+                for t in child.children:
+                    prod = t
+                    for r in right:
+                        prod = prod * r
+                    for l in reversed(left):
+                        prod = l * prod
+                    terms.append(prod)
+
+                return TreeNode("f_add", terms), True
+
+    return node, False
+
+def _expand2(equation):
+    """Iterative version of _expand without recursion."""
+    # Stack: (node, child_index, partially_processed_children)
+    stack = [(equation, 0, [])]
+
+    while stack:
+        node, child_index, processed_children = stack.pop()
+
+        # If all children are processed
+        if child_index >= len(node.children):
+            # Replace children with processed versions
+            node.children = processed_children
+
+            # === Handle f_pow ===
+            if node.name == "f_pow":
+                n = frac(node.children[1])
+                if n is not None and n.denominator == 1 and n.numerator > 1:
+                    # Convert power to repeated multiplication
+                    power_children = [node.children[0] for _ in range(n.numerator)]
+                    new_node = TreeNode("f_mul", power_children)
+                    # Flatten tree
+                    node = flatten_tree(new_node)
+                    # Push it back for further processing
+                    stack.append((node, 0, []))
+                    continue
+
+            # === Handle f_mul ===
+            elif node.name == "f_mul":
+                # Separate lone children and bracket children
+                lone_children = tree_form("d_1")
+                bracket_children = []
+
+                # Iterate in reverse (like original)
+                for child in reversed(node.children):
+                    if child.name == "f_add":
+                        bracket_children.append(child)
+                    elif child.name == "f_pow" and child.children[0].name == "f_add":
+                        n = frac(child.children[1])
+                        if n is not None and n.denominator == 1 and n.numerator > 1:
+                            for _ in range(n.numerator):
+                                bracket_children.append(child.children[0])
+                        else:
+                            lone_children = lone_children * child
+                    else:
+                        lone_children = lone_children * child
+
+                lone_children = simplify(lone_children)
+
+                # Distribute bracket children over lone children iteratively
+                while bracket_children:
+                    tmp = tree_form("d_0")
+                    bracket = bracket_children.pop(0)
+                    for bc in bracket.children:
+                        if lone_children.name == "f_add":
+                            for lc in lone_children.children:
+                                tmp = tmp + bc * lc
+                        else:
+                            tmp = tmp + bc * lone_children
+                    # Simplify after each distribution
+                    lone_children = flatten_tree(simplify(tmp))
+
+                node = lone_children
+
+            # === Return node to parent ===
+            if stack:
+                parent, idx, parent_children = stack.pop()
+                parent_children.append(node)
+                stack.append((parent, idx + 1, parent_children))
+            else:
+                # Root node fully expanded
+                return node
+
+        else:
+            # Push current node back for next child
+            stack.append((node, child_index, processed_children))
+            # Push the child to process next
+            child = flatten_tree(node.children[child_index])
+            stack.append((child, 0, []))
+
+# =====================================================
+# Phase 3: Global fixed-point driver
+# =====================================================
+
+def expand(eq):
+    orig = TreeNode.matmul
+    if TreeNode.matmul is None:
+        return _expand2(eq)
+    eq = simplify(eq)
+    if TreeNode.matmul is not None:
+        TreeNode.matmul = True
+        eq = tree_form(str_form(eq).replace("f_wmul", "f_mul"))
+        eq = flatten_tree(eq)
+    eq = eliminate_powers(eq)
+    while True:        
+        eq = flatten_tree(eq)        
+        eq, changed = expand_once(eq)
+        if not changed:
+            break
+    eq =simplify(eq)
+    TreeNode.matmul = orig
+    return eq

{mathai-0.6.9 → mathai-0.7.1}/mathai/matrix.py

@@ -215,7 +215,7 @@ def fold_wmul(root):
     return newnode[root]
 
 def flat(eq):
-    return flatten_tree(eq, ["f_wmul"])
+    return flatten_tree(eq)
 def use(eq):
     return TreeNode(eq.name, [use(child) for child in eq.children])
 def _matrix_solve(eq):

{mathai-0.6.9 → mathai-0.7.1}/mathai/parser.py

@@ -154,7 +154,7 @@ def parse(equation, funclist=None):
         return tree_node
     
     tree_node = rfx(tree_node)
-    tree_node = flatten_tree(tree_node, ["f_wmul"])
+    tree_node = flatten_tree(tree_node)
     if TreeNode.matmul == True:
         TreeNode.matmul = False
         tree_node = use(tree_form(str_form(tree_node).replace("f_w","f_")))