testing dependency


y = symmath.var'y'
GOOD time: 0.038000ms
stack: size: 0

    assertEq(#y:getDependentVars(), 0)
    ${0} = {0}$
    GOOD
    time: 0.217000ms
    stack: size: 0

      assertEq(#y'^p':getDependentVars(), 0)
      ${0} = {0}$
      GOOD
      time: 0.128000ms
      stack: size: 0
        depends regardless of specification
        assertEq(true, y:dependsOn(y))
        ${true} = {true}$
        GOOD
        time: 0.088000ms
        stack: size: 0
          was not specified
          assertEq(false, y:dependsOn(y'^p'))
          ${false} = {false}$
          GOOD
          time: 0.263000ms
          stack: size: 0
            was not specified
            assertEq(false, y'^p':dependsOn(y))
            ${false} = {false}$
            GOOD
            time: 0.178000ms
            stack: size: 0
              depends regardless of specification
              assertEq(true, y'^p':dependsOn(y'^q'))
              ${true} = {true}$
              GOOD
              time: 0.211000ms
              stack: size: 0


                y = symmath.var'y'
                GOOD time: 0.025000ms
                stack: size: 0

                  y:setDependentVars(x'^a')
                  GOOD time: 0.044000ms
                  stack: size: 0

                    assertEq(#y:getDependentVars() == 1 and y:getDependentVars()[1], x'^a')
                    ${{ x} ^a} = {{ x} ^a}$
                    GOOD
                    time: 0.443000ms
                    stack: size: 0

                      assertEq(#y'^p':getDependentVars(), 0)
                      ${0} = {0}$
                      GOOD
                      time: 0.147000ms
                      stack: size: 0

                        assertEq(#y'^pq':getDependentVars(), 0)
                        ${0} = {0}$
                        GOOD
                        time: 0.095000ms
                        stack: size: 0
                          was not specified
                          assertEq(false, y'^p':dependsOn(x))
                          ${false} = {false}$
                          GOOD
                          time: 0.118000ms
                          stack: size: 0
                            was not specified
                            assertEq(false, y'^p':dependsOn(x'^q'))
                            ${false} = {false}$
                            GOOD
                            time: 0.246000ms
                            stack: size: 0
                              was specified
                              assertEq(true, y:dependsOn(x'^q'))
                              ${true} = {true}$
                              GOOD
                              time: 0.196000ms
                              stack: size: 0
                                was not specified
                                assertEq(false, y:dependsOn(x))
                                ${false} = {false}$
                                GOOD
                                time: 0.185000ms
                                stack: size: 0


                                  y = symmath.var'y'
                                  GOOD time: 0.027000ms
                                  stack: size: 0
                                    not by default
                                    assertEq(false, y:dependsOn(x))
                                    ${false} = {false}$
                                    GOOD
                                    time: 0.279000ms
                                    stack: size: 0

                                      assertEq(false, y:dependsOn(x'^p'))
                                      ${false} = {false}$
                                      GOOD
                                      time: 0.305000ms
                                      stack: size: 0

                                        assertEq(false, y:dependsOn(x'^pq'))
                                        ${false} = {false}$
                                        GOOD
                                        time: 0.171000ms
                                        stack: size: 0

                                          assertEq(false, y'^i':dependsOn(x))
                                          ${false} = {false}$
                                          GOOD
                                          time: 0.114000ms
                                          stack: size: 0

                                            assertEq(false, y'^i':dependsOn(x'^p'))
                                            ${false} = {false}$
                                            GOOD
                                            time: 0.342000ms
                                            stack: size: 0

                                              assertEq(false, y'^i':dependsOn(x'^pq'))
                                              ${false} = {false}$
                                              GOOD
                                              time: 0.104000ms
                                              stack: size: 0

                                                assertEq(false, y'^ij':dependsOn(x))
                                                ${false} = {false}$
                                                GOOD
                                                time: 0.182000ms
                                                stack: size: 0

                                                  assertEq(false, y'^ij':dependsOn(x'^p'))
                                                  ${false} = {false}$
                                                  GOOD
                                                  time: 0.372000ms
                                                  stack: size: 0

                                                    assertEq(false, y'^ij':dependsOn(x'^pq'))
                                                    ${false} = {false}$
                                                    GOOD
                                                    time: 0.327000ms
                                                    stack: size: 0

                                                      y:setDependentVars(x)
                                                      GOOD time: 0.033000ms
                                                      stack: size: 0

                                                        assertEq(#y:getDependentVars() == 1 and y:getDependentVars()[1], x)
                                                        ${x} = {x}$
                                                        GOOD
                                                        time: 0.116000ms
                                                        stack: size: 0

                                                          assertEq(#y'^p':getDependentVars(), 0)
                                                          ${0} = {0}$
                                                          GOOD
                                                          time: 0.119000ms
                                                          stack: size: 0

                                                            assertEq(#y'^pq':getDependentVars(), 0)
                                                            ${0} = {0}$
                                                            GOOD
                                                            time: 0.121000ms
                                                            stack: size: 0

                                                              assertEq(true, y:dependsOn(x))
                                                              ${true} = {true}$
                                                              GOOD
                                                              time: 0.215000ms
                                                              stack: size: 0

                                                                assertEq(false, y:dependsOn(x'^p'))
                                                                ${false} = {false}$
                                                                GOOD
                                                                time: 0.193000ms
                                                                stack: size: 0

                                                                  assertEq(false, y:dependsOn(x'^pq'))
                                                                  ${false} = {false}$
                                                                  GOOD
                                                                  time: 0.603000ms
                                                                  stack: size: 0

                                                                    assertEq(false, y'^i':dependsOn(x))
                                                                    ${false} = {false}$
                                                                    GOOD
                                                                    time: 0.233000ms
                                                                    stack: size: 0

                                                                      assertEq(false, y'^i':dependsOn(x'^p'))
                                                                      ${false} = {false}$
                                                                      GOOD
                                                                      time: 0.247000ms
                                                                      stack: size: 0

                                                                        assertEq(false, y'^i':dependsOn(x'^pq'))
                                                                        ${false} = {false}$
                                                                        GOOD
                                                                        time: 0.097000ms
                                                                        stack: size: 0

                                                                          assertEq(false, y'^ij':dependsOn(x))
                                                                          ${false} = {false}$
                                                                          GOOD
                                                                          time: 0.178000ms
                                                                          stack: size: 0

                                                                            assertEq(false, y'^ij':dependsOn(x'^p'))
                                                                            ${false} = {false}$
                                                                            GOOD
                                                                            time: 0.254000ms
                                                                            stack: size: 0

                                                                              assertEq(false, y'^ij':dependsOn(x'^pq'))
                                                                              ${false} = {false}$
                                                                              GOOD
                                                                              time: 0.091000ms
                                                                              stack: size: 0

                                                                                TODO this should be in tests/unit/diff.lua

                                                                                simplifyAssertEq(y:diff(y), 1)
                                                                                ${\frac{\partial y}{\partial y}} = {1}$
                                                                                GOOD
                                                                                time: 1.316000ms
                                                                                stack: size: 7
                                                                                • Init
                                                                                • Prune
                                                                                • Expand
                                                                                • Prune
                                                                                • Factor
                                                                                • Prune
                                                                                • Tidy
                                                                                assert and not simplifyAssertEq so the rhs doesn't simplify
                                                                                assertEq(y:diff(x)(), y:diff(x))
                                                                                ${\frac{\partial y}{\partial x}} = {\frac{\partial y}{\partial x}}$
                                                                                GOOD
                                                                                time: 2.396000ms
                                                                                stack: size: 7
                                                                                • Init
                                                                                • Prune
                                                                                • Expand
                                                                                • Prune
                                                                                • Factor
                                                                                • Prune
                                                                                • Tidy

                                                                                simplifyAssertEq(y:diff(x'^p'), zero)
                                                                                ${\frac{\partial y}{\partial { x} ^p}} = {0}$
                                                                                GOOD
                                                                                time: 1.998000ms
                                                                                stack: size: 9
                                                                                • Init
                                                                                • Derivative:Prune:other
                                                                                • Prune
                                                                                • Expand
                                                                                • Prune
                                                                                • Factor
                                                                                • Prune
                                                                                • Constant:Tidy:apply
                                                                                • Tidy

                                                                                simplifyAssertEq(y:diff(x'^pq'), zero)
                                                                                ${\frac{\partial y}{\partial {{ x} ^p} ^q}} = {0}$
                                                                                GOOD
                                                                                time: 2.074000ms
                                                                                stack: size: 8
                                                                                • Init
                                                                                • Derivative:Prune:other
                                                                                • Prune
                                                                                • Expand
                                                                                • Prune
                                                                                • Factor
                                                                                • Prune
                                                                                • Tidy

                                                                                simplifyAssertEq(y'^i':diff(x), zero)
                                                                                ${\frac{\partial { y} ^i}{\partial x}} = {0}$
                                                                                GOOD
                                                                                time: 1.154000ms
                                                                                stack: size: 8
                                                                                • Init
                                                                                • Derivative:Prune:other
                                                                                • Prune
                                                                                • Expand
                                                                                • Prune
                                                                                • Factor
                                                                                • Prune
                                                                                • Tidy

                                                                                simplifyAssertEq(y'^i':diff(x'^p'), zero)
                                                                                ${\frac{\partial { y} ^i}{\partial { x} ^p}} = {0}$
                                                                                GOOD
                                                                                time: 0.875000ms
                                                                                stack: size: 8
                                                                                • Init
                                                                                • Derivative:Prune:other
                                                                                • Prune
                                                                                • Expand
                                                                                • Prune
                                                                                • Factor
                                                                                • Prune
                                                                                • Tidy

                                                                                simplifyAssertEq(y'^i':diff(x'^pq'), zero)
                                                                                ${\frac{\partial { y} ^i}{\partial {{ x} ^p} ^q}} = {0}$
                                                                                GOOD
                                                                                time: 1.075000ms
                                                                                stack: size: 8
                                                                                • Init
                                                                                • Derivative:Prune:other
                                                                                • Prune
                                                                                • Expand
                                                                                • Prune
                                                                                • Factor
                                                                                • Prune
                                                                                • Tidy

                                                                                simplifyAssertEq(y'^ij':diff(x), zero)
                                                                                ${\frac{\partial {{ y} ^i} ^j}{\partial x}} = {0}$
                                                                                GOOD
                                                                                time: 0.779000ms
                                                                                stack: size: 8
                                                                                • Init
                                                                                • Derivative:Prune:other
                                                                                • Prune
                                                                                • Expand
                                                                                • Prune
                                                                                • Factor
                                                                                • Prune
                                                                                • Tidy

                                                                                simplifyAssertEq(y'^ij':diff(x'^p'), zero)
                                                                                ${\frac{\partial {{ y} ^i} ^j}{\partial { x} ^p}} = {0}$
                                                                                GOOD
                                                                                time: 0.712000ms
                                                                                stack: size: 8
                                                                                • Init
                                                                                • Derivative:Prune:other
                                                                                • Prune
                                                                                • Expand
                                                                                • Prune
                                                                                • Factor
                                                                                • Prune
                                                                                • Tidy

                                                                                simplifyAssertEq(y'^ij':diff(x'^pq'), zero)
                                                                                ${\frac{\partial {{ y} ^i} ^j}{\partial {{ x} ^p} ^q}} = {0}$
                                                                                GOOD
                                                                                time: 0.448000ms
                                                                                stack: size: 8
                                                                                • Init
                                                                                • Derivative:Prune:other
                                                                                • Prune
                                                                                • Expand
                                                                                • Prune
                                                                                • Factor
                                                                                • Prune
                                                                                • Tidy

                                                                                simplifyAssertEq(y:diff(x,z), zero)
                                                                                ${\frac{\partial^ 2 y}{\partial z\partial x}} = {0}$
                                                                                GOOD
                                                                                time: 0.458000ms
                                                                                stack: size: 8
                                                                                • Init
                                                                                • Derivative:Prune:other
                                                                                • Prune
                                                                                • Expand
                                                                                • Prune
                                                                                • Factor
                                                                                • Prune
                                                                                • Tidy


                                                                                simplifyAssertEq(y'^p':diff(y'^q'), delta'^p_q')
                                                                                ${\frac{\partial { y} ^p}{\partial { y} ^q}} = {{{ δ} ^p} _q}$
                                                                                GOOD
                                                                                time: 1.842000ms
                                                                                stack: size: 7
                                                                                • Init
                                                                                • Prune
                                                                                • Expand
                                                                                • Prune
                                                                                • Factor
                                                                                • Prune
                                                                                • Tidy

                                                                                simplifyAssertEq(y'_p':diff(y'_q'), delta'_p^q')
                                                                                ${\frac{\partial { y} _p}{\partial { y} _q}} = {{{ δ} _p} ^q}$
                                                                                GOOD
                                                                                time: 1.955000ms
                                                                                stack: size: 7
                                                                                • Init
                                                                                • Prune
                                                                                • Expand
                                                                                • Prune
                                                                                • Factor
                                                                                • Prune
                                                                                • Tidy

                                                                                simplifyAssertEq(y'_p':diff(y'^q'), g'_pq')
                                                                                ${\frac{\partial { y} _p}{\partial { y} ^q}} = {{{ g} _p} _q}$
                                                                                GOOD
                                                                                time: 1.892000ms
                                                                                stack: size: 7
                                                                                • Init
                                                                                • Prune
                                                                                • Expand
                                                                                • Prune
                                                                                • Factor
                                                                                • Prune
                                                                                • Tidy

                                                                                simplifyAssertEq(y'^p':diff(y'_q'), g'^pq')
                                                                                ${\frac{\partial { y} ^p}{\partial { y} _q}} = {{{ g} ^p} ^q}$
                                                                                GOOD
                                                                                time: 1.411000ms
                                                                                stack: size: 7
                                                                                • Init
                                                                                • Prune
                                                                                • Expand
                                                                                • Prune
                                                                                • Factor
                                                                                • Prune
                                                                                • Tidy


                                                                                simplifyAssertEq(y'^pq':diff(y'^rs'), delta'^p_r' * delta'^q_s')
                                                                                ${\frac{\partial {{ y} ^p} ^q}{\partial {{ y} ^r} ^s}} = {{{{{ δ} ^p} _r}} {{{{ δ} ^q} _s}}}$
                                                                                GOOD
                                                                                time: 5.946000ms
                                                                                stack: size: 8
                                                                                • Init
                                                                                • Prune
                                                                                • Expand
                                                                                • Prune
                                                                                • Factor
                                                                                • Prune
                                                                                • *:Tidy:apply
                                                                                • Tidy



                                                                                y = symmath.var'y'
                                                                                GOOD time: 0.039000ms
                                                                                stack: size: 0

                                                                                  y:setDependentVars(x'^a')
                                                                                  GOOD time: 0.064000ms
                                                                                  stack: size: 0

                                                                                    assertEq(#y:getDependentVars(), 1)
                                                                                    ${1} = {1}$
                                                                                    GOOD
                                                                                    time: 0.137000ms
                                                                                    stack: size: 0

                                                                                      assertEq(#y'^a':getDependentVars(), 0)
                                                                                      ${0} = {0}$
                                                                                      GOOD
                                                                                      time: 0.117000ms
                                                                                      stack: size: 0

                                                                                        assertEq(false, y:dependsOn(x))
                                                                                        ${false} = {false}$
                                                                                        GOOD
                                                                                        time: 0.106000ms
                                                                                        stack: size: 0

                                                                                          assertEq(true, y:dependsOn(x'^p'))
                                                                                          ${true} = {true}$
                                                                                          GOOD
                                                                                          time: 0.498000ms
                                                                                          stack: size: 0

                                                                                            assertEq(false, y:dependsOn(x'^pq'))
                                                                                            ${false} = {false}$
                                                                                            GOOD
                                                                                            time: 0.160000ms
                                                                                            stack: size: 0

                                                                                              assertEq(false, y'^i':dependsOn(x))
                                                                                              ${false} = {false}$
                                                                                              GOOD
                                                                                              time: 0.109000ms
                                                                                              stack: size: 0

                                                                                                assertEq(false, y'^i':dependsOn(x'^p'))
                                                                                                ${false} = {false}$
                                                                                                GOOD
                                                                                                time: 0.107000ms
                                                                                                stack: size: 0

                                                                                                  assertEq(false, y'^i':dependsOn(x'^pq'))
                                                                                                  ${false} = {false}$
                                                                                                  GOOD
                                                                                                  time: 0.109000ms
                                                                                                  stack: size: 0

                                                                                                    assertEq(false, y'^ij':dependsOn(x))
                                                                                                    ${false} = {false}$
                                                                                                    GOOD
                                                                                                    time: 0.519000ms
                                                                                                    stack: size: 0

                                                                                                      assertEq(false, y'^ij':dependsOn(x'^p'))
                                                                                                      ${false} = {false}$
                                                                                                      GOOD
                                                                                                      time: 0.169000ms
                                                                                                      stack: size: 0

                                                                                                        assertEq(false, y'^ij':dependsOn(x'^pq'))
                                                                                                        ${false} = {false}$
                                                                                                        GOOD
                                                                                                        time: 0.158000ms
                                                                                                        stack: size: 0

                                                                                                          simplifyAssertEq(y:diff(x), zero)
                                                                                                          ${\frac{\partial y}{\partial x}} = {0}$
                                                                                                          GOOD
                                                                                                          time: 0.442000ms
                                                                                                          stack: size: 8
                                                                                                          • Init
                                                                                                          • Derivative:Prune:other
                                                                                                          • Prune
                                                                                                          • Expand
                                                                                                          • Prune
                                                                                                          • Factor
                                                                                                          • Prune
                                                                                                          • Tidy

                                                                                                          simplifyAssertEq(y:diff(x'^p'), y:diff(x'^p'))
                                                                                                          ${\frac{\partial y}{\partial { x} ^p}} = {\frac{\partial y}{\partial { x} ^p}}$
                                                                                                          GOOD
                                                                                                          time: 1.741000ms
                                                                                                          stack: size: 7
                                                                                                          • Init
                                                                                                          • Prune
                                                                                                          • Expand
                                                                                                          • Prune
                                                                                                          • Factor
                                                                                                          • Prune
                                                                                                          • Tidy

                                                                                                          simplifyAssertEq(y:diff(x'^pq'), zero)
                                                                                                          ${\frac{\partial y}{\partial {{ x} ^p} ^q}} = {0}$
                                                                                                          GOOD
                                                                                                          time: 0.559000ms
                                                                                                          stack: size: 8
                                                                                                          • Init
                                                                                                          • Derivative:Prune:other
                                                                                                          • Prune
                                                                                                          • Expand
                                                                                                          • Prune
                                                                                                          • Factor
                                                                                                          • Prune
                                                                                                          • Tidy

                                                                                                          simplifyAssertEq(y'^i':diff(x), zero)
                                                                                                          ${\frac{\partial { y} ^i}{\partial x}} = {0}$
                                                                                                          GOOD
                                                                                                          time: 0.772000ms
                                                                                                          stack: size: 8
                                                                                                          • Init
                                                                                                          • Derivative:Prune:other
                                                                                                          • Prune
                                                                                                          • Expand
                                                                                                          • Prune
                                                                                                          • Factor
                                                                                                          • Prune
                                                                                                          • Tidy

                                                                                                          simplifyAssertEq(y'^i':diff(x'^p'), zero)
                                                                                                          ${\frac{\partial { y} ^i}{\partial { x} ^p}} = {0}$
                                                                                                          GOOD
                                                                                                          time: 0.979000ms
                                                                                                          stack: size: 8
                                                                                                          • Init
                                                                                                          • Derivative:Prune:other
                                                                                                          • Prune
                                                                                                          • Expand
                                                                                                          • Prune
                                                                                                          • Factor
                                                                                                          • Prune
                                                                                                          • Tidy

                                                                                                          simplifyAssertEq(y'^i':diff(x'^pq'), zero)
                                                                                                          ${\frac{\partial { y} ^i}{\partial {{ x} ^p} ^q}} = {0}$
                                                                                                          GOOD
                                                                                                          time: 0.803000ms
                                                                                                          stack: size: 8
                                                                                                          • Init
                                                                                                          • Derivative:Prune:other
                                                                                                          • Prune
                                                                                                          • Expand
                                                                                                          • Prune
                                                                                                          • Factor
                                                                                                          • Prune
                                                                                                          • Tidy

                                                                                                          simplifyAssertEq(y'^ij':diff(x), zero)
                                                                                                          ${\frac{\partial {{ y} ^i} ^j}{\partial x}} = {0}$
                                                                                                          GOOD
                                                                                                          time: 0.729000ms
                                                                                                          stack: size: 8
                                                                                                          • Init
                                                                                                          • Derivative:Prune:other
                                                                                                          • Prune
                                                                                                          • Expand
                                                                                                          • Prune
                                                                                                          • Factor
                                                                                                          • Prune
                                                                                                          • Tidy

                                                                                                          simplifyAssertEq(y'^ij':diff(x'^p'), zero)
                                                                                                          ${\frac{\partial {{ y} ^i} ^j}{\partial { x} ^p}} = {0}$
                                                                                                          GOOD
                                                                                                          time: 0.622000ms
                                                                                                          stack: size: 8
                                                                                                          • Init
                                                                                                          • Derivative:Prune:other
                                                                                                          • Prune
                                                                                                          • Expand
                                                                                                          • Prune
                                                                                                          • Factor
                                                                                                          • Prune
                                                                                                          • Tidy

                                                                                                          simplifyAssertEq(y'^ij':diff(x'^pq'), zero)
                                                                                                          ${\frac{\partial {{ y} ^i} ^j}{\partial {{ x} ^p} ^q}} = {0}$
                                                                                                          GOOD
                                                                                                          time: 0.805000ms
                                                                                                          stack: size: 8
                                                                                                          • Init
                                                                                                          • Derivative:Prune:other
                                                                                                          • Prune
                                                                                                          • Expand
                                                                                                          • Prune
                                                                                                          • Factor
                                                                                                          • Prune
                                                                                                          • Tidy


                                                                                                          y = symmath.var'y'
                                                                                                          GOOD time: 0.046000ms
                                                                                                          stack: size: 0

                                                                                                            y'^a':setDependentVars(x)
                                                                                                            GOOD time: 0.068000ms
                                                                                                            stack: size: 0

                                                                                                              assertEq(#y:getDependentVars(), 0)
                                                                                                              ${0} = {0}$
                                                                                                              GOOD
                                                                                                              time: 0.093000ms
                                                                                                              stack: size: 0

                                                                                                                assertEq(#y'^a':getDependentVars(), 1)
                                                                                                                ${1} = {1}$
                                                                                                                GOOD
                                                                                                                time: 0.101000ms
                                                                                                                stack: size: 0

                                                                                                                  assertEq(false, y:dependsOn(x))
                                                                                                                  ${false} = {false}$
                                                                                                                  GOOD
                                                                                                                  time: 0.098000ms
                                                                                                                  stack: size: 0

                                                                                                                    assertEq(false, y:dependsOn(x'^p'))
                                                                                                                    ${false} = {false}$
                                                                                                                    GOOD
                                                                                                                    time: 0.096000ms
                                                                                                                    stack: size: 0

                                                                                                                      assertEq(false, y:dependsOn(x'^pq'))
                                                                                                                      ${false} = {false}$
                                                                                                                      GOOD
                                                                                                                      time: 0.093000ms
                                                                                                                      stack: size: 0

                                                                                                                        assertEq(true, y'^i':dependsOn(x))
                                                                                                                        ${true} = {true}$
                                                                                                                        GOOD
                                                                                                                        time: 0.081000ms
                                                                                                                        stack: size: 0

                                                                                                                          assertEq(false, y'^i':dependsOn(x'^p'))
                                                                                                                          ${false} = {false}$
                                                                                                                          GOOD
                                                                                                                          time: 0.105000ms
                                                                                                                          stack: size: 0

                                                                                                                            assertEq(false, y'^i':dependsOn(x'^pq'))
                                                                                                                            ${false} = {false}$
                                                                                                                            GOOD
                                                                                                                            time: 0.577000ms
                                                                                                                            stack: size: 0

                                                                                                                              assertEq(false, y'^ij':dependsOn(x))
                                                                                                                              ${false} = {false}$
                                                                                                                              GOOD
                                                                                                                              time: 0.095000ms
                                                                                                                              stack: size: 0

                                                                                                                                assertEq(false, y'^ij':dependsOn(x'^p'))
                                                                                                                                ${false} = {false}$
                                                                                                                                GOOD
                                                                                                                                time: 0.091000ms
                                                                                                                                stack: size: 0

                                                                                                                                  assertEq(false, y'^ij':dependsOn(x'^pq'))
                                                                                                                                  ${false} = {false}$
                                                                                                                                  GOOD
                                                                                                                                  time: 0.095000ms
                                                                                                                                  stack: size: 0

                                                                                                                                    simplifyAssertEq(y:diff(x), zero)
                                                                                                                                    ${\frac{\partial y}{\partial x}} = {0}$
                                                                                                                                    GOOD
                                                                                                                                    time: 0.311000ms
                                                                                                                                    stack: size: 8
                                                                                                                                    • Init
                                                                                                                                    • Derivative:Prune:other
                                                                                                                                    • Prune
                                                                                                                                    • Expand
                                                                                                                                    • Prune
                                                                                                                                    • Factor
                                                                                                                                    • Prune
                                                                                                                                    • Tidy

                                                                                                                                    simplifyAssertEq(y:diff(x'^p'), zero)
                                                                                                                                    ${\frac{\partial y}{\partial { x} ^p}} = {0}$
                                                                                                                                    GOOD
                                                                                                                                    time: 0.435000ms
                                                                                                                                    stack: size: 8
                                                                                                                                    • Init
                                                                                                                                    • Derivative:Prune:other
                                                                                                                                    • Prune
                                                                                                                                    • Expand
                                                                                                                                    • Prune
                                                                                                                                    • Factor
                                                                                                                                    • Prune
                                                                                                                                    • Tidy

                                                                                                                                    simplifyAssertEq(y:diff(x'^pq'), zero)
                                                                                                                                    ${\frac{\partial y}{\partial {{ x} ^p} ^q}} = {0}$
                                                                                                                                    GOOD
                                                                                                                                    time: 0.622000ms
                                                                                                                                    stack: size: 8
                                                                                                                                    • Init
                                                                                                                                    • Derivative:Prune:other
                                                                                                                                    • Prune
                                                                                                                                    • Expand
                                                                                                                                    • Prune
                                                                                                                                    • Factor
                                                                                                                                    • Prune
                                                                                                                                    • Tidy

                                                                                                                                    simplifyAssertEq(y'^i':diff(x), y'^i':diff(x))
                                                                                                                                    ${\frac{\partial { y} ^i}{\partial x}} = {\frac{\partial { y} ^i}{\partial x}}$
                                                                                                                                    GOOD
                                                                                                                                    time: 2.129000ms
                                                                                                                                    stack: size: 7
                                                                                                                                    • Init
                                                                                                                                    • Prune
                                                                                                                                    • Expand
                                                                                                                                    • Prune
                                                                                                                                    • Factor
                                                                                                                                    • Prune
                                                                                                                                    • Tidy

                                                                                                                                    simplifyAssertEq(y'^i':diff(x'^p'), zero)
                                                                                                                                    ${\frac{\partial { y} ^i}{\partial { x} ^p}} = {0}$
                                                                                                                                    GOOD
                                                                                                                                    time: 1.104000ms
                                                                                                                                    stack: size: 8
                                                                                                                                    • Init
                                                                                                                                    • Derivative:Prune:other
                                                                                                                                    • Prune
                                                                                                                                    • Expand
                                                                                                                                    • Prune
                                                                                                                                    • Factor
                                                                                                                                    • Prune
                                                                                                                                    • Tidy

                                                                                                                                    simplifyAssertEq(y'^i':diff(x'^pq'), zero)
                                                                                                                                    ${\frac{\partial { y} ^i}{\partial {{ x} ^p} ^q}} = {0}$
                                                                                                                                    GOOD
                                                                                                                                    time: 1.016000ms
                                                                                                                                    stack: size: 8
                                                                                                                                    • Init
                                                                                                                                    • Derivative:Prune:other
                                                                                                                                    • Prune
                                                                                                                                    • Expand
                                                                                                                                    • Prune
                                                                                                                                    • Factor
                                                                                                                                    • Prune
                                                                                                                                    • Tidy

                                                                                                                                    simplifyAssertEq(y'^ij':diff(x), zero)
                                                                                                                                    ${\frac{\partial {{ y} ^i} ^j}{\partial x}} = {0}$
                                                                                                                                    GOOD
                                                                                                                                    time: 0.812000ms
                                                                                                                                    stack: size: 8
                                                                                                                                    • Init
                                                                                                                                    • Derivative:Prune:other
                                                                                                                                    • Prune
                                                                                                                                    • Expand
                                                                                                                                    • Prune
                                                                                                                                    • Factor
                                                                                                                                    • Prune
                                                                                                                                    • Tidy

                                                                                                                                    simplifyAssertEq(y'^ij':diff(x'^p'), zero)
                                                                                                                                    ${\frac{\partial {{ y} ^i} ^j}{\partial { x} ^p}} = {0}$
                                                                                                                                    GOOD
                                                                                                                                    time: 0.793000ms
                                                                                                                                    stack: size: 8
                                                                                                                                    • Init
                                                                                                                                    • Derivative:Prune:other
                                                                                                                                    • Prune
                                                                                                                                    • Expand
                                                                                                                                    • Prune
                                                                                                                                    • Factor
                                                                                                                                    • Prune
                                                                                                                                    • Tidy

                                                                                                                                    simplifyAssertEq(y'^ij':diff(x'^pq'), zero)
                                                                                                                                    ${\frac{\partial {{ y} ^i} ^j}{\partial {{ x} ^p} ^q}} = {0}$
                                                                                                                                    GOOD
                                                                                                                                    time: 0.816000ms
                                                                                                                                    stack: size: 8
                                                                                                                                    • Init
                                                                                                                                    • Derivative:Prune:other
                                                                                                                                    • Prune
                                                                                                                                    • Expand
                                                                                                                                    • Prune
                                                                                                                                    • Factor
                                                                                                                                    • Prune
                                                                                                                                    • Tidy


                                                                                                                                    y = symmath.var'y'
                                                                                                                                    GOOD time: 0.046000ms
                                                                                                                                    stack: size: 0

                                                                                                                                      y'^a':setDependentVars(x'^b')
                                                                                                                                      GOOD time: 0.131000ms
                                                                                                                                      stack: size: 0

                                                                                                                                        assertEq(false, y:dependsOn(x))
                                                                                                                                        ${false} = {false}$
                                                                                                                                        GOOD
                                                                                                                                        time: 0.170000ms
                                                                                                                                        stack: size: 0

                                                                                                                                          assertEq(false, y:dependsOn(x'^p'))
                                                                                                                                          ${false} = {false}$
                                                                                                                                          GOOD
                                                                                                                                          time: 0.139000ms
                                                                                                                                          stack: size: 0

                                                                                                                                            assertEq(false, y:dependsOn(x'^pq'))
                                                                                                                                            ${false} = {false}$
                                                                                                                                            GOOD
                                                                                                                                            time: 0.133000ms
                                                                                                                                            stack: size: 0

                                                                                                                                              assertEq(false, y'^i':dependsOn(x))
                                                                                                                                              ${false} = {false}$
                                                                                                                                              GOOD
                                                                                                                                              time: 0.129000ms
                                                                                                                                              stack: size: 0

                                                                                                                                                assertEq(true, y'^i':dependsOn(x'^p'))
                                                                                                                                                ${true} = {true}$
                                                                                                                                                GOOD
                                                                                                                                                time: 0.133000ms
                                                                                                                                                stack: size: 0

                                                                                                                                                  assertEq(false, y'^i':dependsOn(x'^pq'))
                                                                                                                                                  ${false} = {false}$
                                                                                                                                                  GOOD
                                                                                                                                                  time: 0.216000ms
                                                                                                                                                  stack: size: 0

                                                                                                                                                    assertEq(false, y'^ij':dependsOn(x))
                                                                                                                                                    ${false} = {false}$
                                                                                                                                                    GOOD
                                                                                                                                                    time: 0.146000ms
                                                                                                                                                    stack: size: 0

                                                                                                                                                      assertEq(false, y'^ij':dependsOn(x'^p'))
                                                                                                                                                      ${false} = {false}$
                                                                                                                                                      GOOD
                                                                                                                                                      time: 0.142000ms
                                                                                                                                                      stack: size: 0

                                                                                                                                                        assertEq(false, y'^ij':dependsOn(x'^pq'))
                                                                                                                                                        ${false} = {false}$
                                                                                                                                                        GOOD
                                                                                                                                                        time: 0.142000ms
                                                                                                                                                        stack: size: 0

                                                                                                                                                          simplifyAssertEq(y:diff(x), zero)
                                                                                                                                                          ${\frac{\partial y}{\partial x}} = {0}$
                                                                                                                                                          GOOD
                                                                                                                                                          time: 0.402000ms
                                                                                                                                                          stack: size: 8
                                                                                                                                                          • Init
                                                                                                                                                          • Derivative:Prune:other
                                                                                                                                                          • Prune
                                                                                                                                                          • Expand
                                                                                                                                                          • Prune
                                                                                                                                                          • Factor
                                                                                                                                                          • Prune
                                                                                                                                                          • Tidy

                                                                                                                                                          simplifyAssertEq(y:diff(x'^p'), zero)
                                                                                                                                                          ${\frac{\partial y}{\partial { x} ^p}} = {0}$
                                                                                                                                                          GOOD
                                                                                                                                                          time: 0.421000ms
                                                                                                                                                          stack: size: 8
                                                                                                                                                          • Init
                                                                                                                                                          • Derivative:Prune:other
                                                                                                                                                          • Prune
                                                                                                                                                          • Expand
                                                                                                                                                          • Prune
                                                                                                                                                          • Factor
                                                                                                                                                          • Prune
                                                                                                                                                          • Tidy

                                                                                                                                                          simplifyAssertEq(y:diff(x'^pq'), zero)
                                                                                                                                                          ${\frac{\partial y}{\partial {{ x} ^p} ^q}} = {0}$
                                                                                                                                                          GOOD
                                                                                                                                                          time: 0.645000ms
                                                                                                                                                          stack: size: 8
                                                                                                                                                          • Init
                                                                                                                                                          • Derivative:Prune:other
                                                                                                                                                          • Prune
                                                                                                                                                          • Expand
                                                                                                                                                          • Prune
                                                                                                                                                          • Factor
                                                                                                                                                          • Prune
                                                                                                                                                          • Tidy

                                                                                                                                                          simplifyAssertEq(y'^i':diff(x), zero)
                                                                                                                                                          ${\frac{\partial { y} ^i}{\partial x}} = {0}$
                                                                                                                                                          GOOD
                                                                                                                                                          time: 1.067000ms
                                                                                                                                                          stack: size: 8
                                                                                                                                                          • Init
                                                                                                                                                          • Derivative:Prune:other
                                                                                                                                                          • Prune
                                                                                                                                                          • Expand
                                                                                                                                                          • Prune
                                                                                                                                                          • Factor
                                                                                                                                                          • Prune
                                                                                                                                                          • Tidy

                                                                                                                                                          simplifyAssertEq(y'^i':diff(x'^p'), y'^i':diff(x'^p'))
                                                                                                                                                          ${\frac{\partial { y} ^i}{\partial { x} ^p}} = {\frac{\partial { y} ^i}{\partial { x} ^p}}$
                                                                                                                                                          GOOD
                                                                                                                                                          time: 3.151000ms
                                                                                                                                                          stack: size: 7
                                                                                                                                                          • Init
                                                                                                                                                          • Prune
                                                                                                                                                          • Expand
                                                                                                                                                          • Prune
                                                                                                                                                          • Factor
                                                                                                                                                          • Prune
                                                                                                                                                          • Tidy

                                                                                                                                                          simplifyAssertEq(y'^i':diff(x'^pq'), zero)
                                                                                                                                                          ${\frac{\partial { y} ^i}{\partial {{ x} ^p} ^q}} = {0}$
                                                                                                                                                          GOOD
                                                                                                                                                          time: 0.725000ms
                                                                                                                                                          stack: size: 8
                                                                                                                                                          • Init
                                                                                                                                                          • Derivative:Prune:other
                                                                                                                                                          • Prune
                                                                                                                                                          • Expand
                                                                                                                                                          • Prune
                                                                                                                                                          • Factor
                                                                                                                                                          • Prune
                                                                                                                                                          • Tidy

                                                                                                                                                          simplifyAssertEq(y'^ij':diff(x), zero)
                                                                                                                                                          ${\frac{\partial {{ y} ^i} ^j}{\partial x}} = {0}$
                                                                                                                                                          GOOD
                                                                                                                                                          time: 0.613000ms
                                                                                                                                                          stack: size: 8
                                                                                                                                                          • Init
                                                                                                                                                          • Derivative:Prune:other
                                                                                                                                                          • Prune
                                                                                                                                                          • Expand
                                                                                                                                                          • Prune
                                                                                                                                                          • Factor
                                                                                                                                                          • Prune
                                                                                                                                                          • Tidy

                                                                                                                                                          simplifyAssertEq(y'^ij':diff(x'^p'), zero)
                                                                                                                                                          ${\frac{\partial {{ y} ^i} ^j}{\partial { x} ^p}} = {0}$
                                                                                                                                                          GOOD
                                                                                                                                                          time: 0.614000ms
                                                                                                                                                          stack: size: 8
                                                                                                                                                          • Init
                                                                                                                                                          • Derivative:Prune:other
                                                                                                                                                          • Prune
                                                                                                                                                          • Expand
                                                                                                                                                          • Prune
                                                                                                                                                          • Factor
                                                                                                                                                          • Prune
                                                                                                                                                          • Tidy

                                                                                                                                                          simplifyAssertEq(y'^ij':diff(x'^pq'), zero)
                                                                                                                                                          ${\frac{\partial {{ y} ^i} ^j}{\partial {{ x} ^p} ^q}} = {0}$
                                                                                                                                                          GOOD
                                                                                                                                                          time: 1.018000ms
                                                                                                                                                          stack: size: 8
                                                                                                                                                          • Init
                                                                                                                                                          • Derivative:Prune:other
                                                                                                                                                          • Prune
                                                                                                                                                          • Expand
                                                                                                                                                          • Prune
                                                                                                                                                          • Factor
                                                                                                                                                          • Prune
                                                                                                                                                          • Tidy

                                                                                                                                                          testing graph dependency z(y(x)), z depends on x

                                                                                                                                                          x = symmath.var'x'
                                                                                                                                                          GOOD time: 0.042000ms
                                                                                                                                                          stack: size: 0

                                                                                                                                                            y = symmath.var('y', {x})
                                                                                                                                                            GOOD time: 0.081000ms
                                                                                                                                                            stack: size: 0

                                                                                                                                                              z = symmath.var('z', {y})
                                                                                                                                                              GOOD time: 0.056000ms
                                                                                                                                                              stack: size: 0


                                                                                                                                                                assertEq(true, z:dependsOn(z))
                                                                                                                                                                ${true} = {true}$
                                                                                                                                                                GOOD
                                                                                                                                                                time: 0.179000ms
                                                                                                                                                                stack: size: 0

                                                                                                                                                                  assertEq(true, z:dependsOn(y))
                                                                                                                                                                  ${true} = {true}$
                                                                                                                                                                  GOOD
                                                                                                                                                                  time: 0.139000ms
                                                                                                                                                                  stack: size: 0
                                                                                                                                                                    hmm, how to handle graph dependencies ...
                                                                                                                                                                    I'm not going to evaluate them for now, because they cause
                                                                                                                                                                    (1) infinite loops (unless I track search state) and
                                                                                                                                                                    (2) {u,v} depends on {t,x} makes a graph search produce u depends on v ...
                                                                                                                                                                    assertEq(true, z:dependsOn(x))

                                                                                                                                                                    assertEq(false, y:dependsOn(z))
                                                                                                                                                                    ${false} = {false}$
                                                                                                                                                                    GOOD
                                                                                                                                                                    time: 0.346000ms
                                                                                                                                                                    stack: size: 0

                                                                                                                                                                      assertEq(true, y:dependsOn(y))
                                                                                                                                                                      ${true} = {true}$
                                                                                                                                                                      GOOD
                                                                                                                                                                      time: 0.154000ms
                                                                                                                                                                      stack: size: 0

                                                                                                                                                                        assertEq(true, y:dependsOn(x))
                                                                                                                                                                        ${true} = {true}$
                                                                                                                                                                        GOOD
                                                                                                                                                                        time: 0.133000ms
                                                                                                                                                                        stack: size: 0

                                                                                                                                                                          assertEq(false, x:dependsOn(z))
                                                                                                                                                                          ${false} = {false}$
                                                                                                                                                                          GOOD
                                                                                                                                                                          time: 0.158000ms
                                                                                                                                                                          stack: size: 0

                                                                                                                                                                            assertEq(false, x:dependsOn(y))
                                                                                                                                                                            ${false} = {false}$
                                                                                                                                                                            GOOD
                                                                                                                                                                            time: 0.142000ms
                                                                                                                                                                            stack: size: 0

                                                                                                                                                                              assertEq(true, x:dependsOn(x))
                                                                                                                                                                              ${true} = {true}$
                                                                                                                                                                              GOOD
                                                                                                                                                                              time: 0.158000ms
                                                                                                                                                                              stack: size: 0


                                                                                                                                                                                assertEq(false, z:dependsOn(z'^I'))
                                                                                                                                                                                ${false} = {false}$
                                                                                                                                                                                GOOD
                                                                                                                                                                                time: 0.297000ms
                                                                                                                                                                                stack: size: 0

                                                                                                                                                                                  assertEq(false, z:dependsOn(y'^I'))
                                                                                                                                                                                  ${false} = {false}$
                                                                                                                                                                                  GOOD
                                                                                                                                                                                  time: 0.314000ms
                                                                                                                                                                                  stack: size: 0

                                                                                                                                                                                    assertEq(false, z:dependsOn(x'^I'))
                                                                                                                                                                                    ${false} = {false}$
                                                                                                                                                                                    GOOD
                                                                                                                                                                                    time: 0.727000ms
                                                                                                                                                                                    stack: size: 0

                                                                                                                                                                                      assertEq(false, y:dependsOn(z'^I'))
                                                                                                                                                                                      ${false} = {false}$
                                                                                                                                                                                      GOOD
                                                                                                                                                                                      time: 0.160000ms
                                                                                                                                                                                      stack: size: 0

                                                                                                                                                                                        assertEq(false, y:dependsOn(y'^I'))
                                                                                                                                                                                        ${false} = {false}$
                                                                                                                                                                                        GOOD
                                                                                                                                                                                        time: 0.146000ms
                                                                                                                                                                                        stack: size: 0

                                                                                                                                                                                          assertEq(false, y:dependsOn(x'^I'))
                                                                                                                                                                                          ${false} = {false}$
                                                                                                                                                                                          GOOD
                                                                                                                                                                                          time: 0.188000ms
                                                                                                                                                                                          stack: size: 0

                                                                                                                                                                                            assertEq(false, x:dependsOn(z'^I'))
                                                                                                                                                                                            ${false} = {false}$
                                                                                                                                                                                            GOOD
                                                                                                                                                                                            time: 0.148000ms
                                                                                                                                                                                            stack: size: 0

                                                                                                                                                                                              assertEq(false, x:dependsOn(y'^I'))
                                                                                                                                                                                              ${false} = {false}$
                                                                                                                                                                                              GOOD
                                                                                                                                                                                              time: 0.185000ms
                                                                                                                                                                                              stack: size: 0

                                                                                                                                                                                                assertEq(false, x:dependsOn(x'^I'))
                                                                                                                                                                                                ${false} = {false}$
                                                                                                                                                                                                GOOD
                                                                                                                                                                                                time: 0.150000ms
                                                                                                                                                                                                stack: size: 0


                                                                                                                                                                                                  assertEq(false, z'^I':dependsOn(z))
                                                                                                                                                                                                  ${false} = {false}$
                                                                                                                                                                                                  GOOD
                                                                                                                                                                                                  time: 0.144000ms
                                                                                                                                                                                                  stack: size: 0

                                                                                                                                                                                                    assertEq(false, z'^I':dependsOn(y))
                                                                                                                                                                                                    ${false} = {false}$
                                                                                                                                                                                                    GOOD
                                                                                                                                                                                                    time: 0.118000ms
                                                                                                                                                                                                    stack: size: 0

                                                                                                                                                                                                      assertEq(false, z'^I':dependsOn(x))
                                                                                                                                                                                                      ${false} = {false}$
                                                                                                                                                                                                      GOOD
                                                                                                                                                                                                      time: 0.081000ms
                                                                                                                                                                                                      stack: size: 0

                                                                                                                                                                                                        assertEq(false, y'^I':dependsOn(z))
                                                                                                                                                                                                        ${false} = {false}$
                                                                                                                                                                                                        GOOD
                                                                                                                                                                                                        time: 0.087000ms
                                                                                                                                                                                                        stack: size: 0

                                                                                                                                                                                                          assertEq(false, y'^I':dependsOn(y))
                                                                                                                                                                                                          ${false} = {false}$
                                                                                                                                                                                                          GOOD
                                                                                                                                                                                                          time: 0.093000ms
                                                                                                                                                                                                          stack: size: 0

                                                                                                                                                                                                            assertEq(false, y'^I':dependsOn(x))
                                                                                                                                                                                                            ${false} = {false}$
                                                                                                                                                                                                            GOOD
                                                                                                                                                                                                            time: 0.192000ms
                                                                                                                                                                                                            stack: size: 0

                                                                                                                                                                                                              assertEq(false, x'^I':dependsOn(z))
                                                                                                                                                                                                              ${false} = {false}$
                                                                                                                                                                                                              GOOD
                                                                                                                                                                                                              time: 0.096000ms
                                                                                                                                                                                                              stack: size: 0

                                                                                                                                                                                                                assertEq(false, x'^I':dependsOn(y))
                                                                                                                                                                                                                ${false} = {false}$
                                                                                                                                                                                                                GOOD
                                                                                                                                                                                                                time: 0.090000ms
                                                                                                                                                                                                                stack: size: 0

                                                                                                                                                                                                                  assertEq(false, x'^I':dependsOn(x))
                                                                                                                                                                                                                  ${false} = {false}$
                                                                                                                                                                                                                  GOOD
                                                                                                                                                                                                                  time: 0.135000ms
                                                                                                                                                                                                                  stack: size: 0

                                                                                                                                                                                                                    by default
                                                                                                                                                                                                                    assertEq(true, z'^I':dependsOn(z'^I'))
                                                                                                                                                                                                                    ${true} = {true}$
                                                                                                                                                                                                                    GOOD
                                                                                                                                                                                                                    time: 0.306000ms
                                                                                                                                                                                                                    stack: size: 0

                                                                                                                                                                                                                      assertEq(false, z'^I':dependsOn(y'^I'))
                                                                                                                                                                                                                      ${false} = {false}$
                                                                                                                                                                                                                      GOOD
                                                                                                                                                                                                                      time: 0.170000ms
                                                                                                                                                                                                                      stack: size: 0

                                                                                                                                                                                                                        assertEq(false, z'^I':dependsOn(x'^I'))
                                                                                                                                                                                                                        ${false} = {false}$
                                                                                                                                                                                                                        GOOD
                                                                                                                                                                                                                        time: 0.228000ms
                                                                                                                                                                                                                        stack: size: 0

                                                                                                                                                                                                                          assertEq(false, y'^I':dependsOn(z'^I'))
                                                                                                                                                                                                                          ${false} = {false}$
                                                                                                                                                                                                                          GOOD
                                                                                                                                                                                                                          time: 0.246000ms
                                                                                                                                                                                                                          stack: size: 0
                                                                                                                                                                                                                            by default
                                                                                                                                                                                                                            assertEq(true, y'^I':dependsOn(y'^I'))
                                                                                                                                                                                                                            ${true} = {true}$
                                                                                                                                                                                                                            GOOD
                                                                                                                                                                                                                            time: 0.114000ms
                                                                                                                                                                                                                            stack: size: 0

                                                                                                                                                                                                                              assertEq(false, y'^I':dependsOn(x'^I'))
                                                                                                                                                                                                                              ${false} = {false}$
                                                                                                                                                                                                                              GOOD
                                                                                                                                                                                                                              time: 0.146000ms
                                                                                                                                                                                                                              stack: size: 0

                                                                                                                                                                                                                                assertEq(false, x'^I':dependsOn(z'^I'))
                                                                                                                                                                                                                                ${false} = {false}$
                                                                                                                                                                                                                                GOOD
                                                                                                                                                                                                                                time: 0.158000ms
                                                                                                                                                                                                                                stack: size: 0

                                                                                                                                                                                                                                  assertEq(false, x'^I':dependsOn(y'^I'))
                                                                                                                                                                                                                                  ${false} = {false}$
                                                                                                                                                                                                                                  GOOD
                                                                                                                                                                                                                                  time: 0.165000ms
                                                                                                                                                                                                                                  stack: size: 0
                                                                                                                                                                                                                                    by default
                                                                                                                                                                                                                                    assertEq(true, x'^I':dependsOn(x'^I'))
                                                                                                                                                                                                                                    ${true} = {true}$
                                                                                                                                                                                                                                    GOOD
                                                                                                                                                                                                                                    time: 0.413000ms
                                                                                                                                                                                                                                    stack: size: 0


                                                                                                                                                                                                                                      testing graph dependency z(y(x'^I')), z depends on x

                                                                                                                                                                                                                                      x = symmath.var'x'
                                                                                                                                                                                                                                      GOOD time: 0.034000ms
                                                                                                                                                                                                                                      stack: size: 0

                                                                                                                                                                                                                                        y = symmath.var'y'
                                                                                                                                                                                                                                        GOOD time: 0.059000ms
                                                                                                                                                                                                                                        stack: size: 0

                                                                                                                                                                                                                                          y:setDependentVars(x'^I')
                                                                                                                                                                                                                                          GOOD time: 0.309000ms
                                                                                                                                                                                                                                          stack: size: 0

                                                                                                                                                                                                                                            z = symmath.var'z'
                                                                                                                                                                                                                                            GOOD time: 0.041000ms
                                                                                                                                                                                                                                            stack: size: 0

                                                                                                                                                                                                                                              z:setDependentVars(y)
                                                                                                                                                                                                                                              GOOD time: 0.053000ms
                                                                                                                                                                                                                                              stack: size: 0


                                                                                                                                                                                                                                                assertEq(true, z:dependsOn(z))
                                                                                                                                                                                                                                                ${true} = {true}$
                                                                                                                                                                                                                                                GOOD
                                                                                                                                                                                                                                                time: 0.159000ms
                                                                                                                                                                                                                                                stack: size: 0

                                                                                                                                                                                                                                                  assertEq(true, z:dependsOn(y))
                                                                                                                                                                                                                                                  ${true} = {true}$
                                                                                                                                                                                                                                                  GOOD
                                                                                                                                                                                                                                                  time: 0.146000ms
                                                                                                                                                                                                                                                  stack: size: 0
                                                                                                                                                                                                                                                    same as above, not doing a graph search. should I?
                                                                                                                                                                                                                                                    assertEq(true, z:dependsOn(x'^I'))

                                                                                                                                                                                                                                                    assertEq(false, y:dependsOn(z))
                                                                                                                                                                                                                                                    ${false} = {false}$
                                                                                                                                                                                                                                                    GOOD
                                                                                                                                                                                                                                                    time: 0.146000ms
                                                                                                                                                                                                                                                    stack: size: 0

                                                                                                                                                                                                                                                      assertEq(true, y:dependsOn(y))
                                                                                                                                                                                                                                                      ${true} = {true}$
                                                                                                                                                                                                                                                      GOOD
                                                                                                                                                                                                                                                      time: 0.139000ms
                                                                                                                                                                                                                                                      stack: size: 0

                                                                                                                                                                                                                                                        assertEq(true, y:dependsOn(x'^I'))
                                                                                                                                                                                                                                                        ${true} = {true}$
                                                                                                                                                                                                                                                        GOOD
                                                                                                                                                                                                                                                        time: 0.280000ms
                                                                                                                                                                                                                                                        stack: size: 0

                                                                                                                                                                                                                                                          assertEq(false, x'^I':dependsOn(z))
                                                                                                                                                                                                                                                          ${false} = {false}$
                                                                                                                                                                                                                                                          GOOD
                                                                                                                                                                                                                                                          time: 0.159000ms
                                                                                                                                                                                                                                                          stack: size: 0

                                                                                                                                                                                                                                                            assertEq(false, x'^I':dependsOn(y))
                                                                                                                                                                                                                                                            ${false} = {false}$
                                                                                                                                                                                                                                                            GOOD
                                                                                                                                                                                                                                                            time: 0.151000ms
                                                                                                                                                                                                                                                            stack: size: 0

                                                                                                                                                                                                                                                              assertEq(true, x'^I':dependsOn(x'^I'))
                                                                                                                                                                                                                                                              ${true} = {true}$
                                                                                                                                                                                                                                                              GOOD
                                                                                                                                                                                                                                                              time: 0.170000ms
                                                                                                                                                                                                                                                              stack: size: 0


                                                                                                                                                                                                                                                                make definite variable objects in our scope so implicit variable creation doesn't replace them and reset their state
                                                                                                                                                                                                                                                                alright, I'm at an impass here ...
                                                                                                                                                                                                                                                                before I fixed chain dependencies, I had a good system where {u,v}:depends{t,x} would only produce du/dt du/dx dv/dt dv/dx
                                                                                                                                                                                                                                                                but now, with chain dependencies, I'm also getting dv/du, du/dv, dt/dx, dx/dt ... and this is incorrect

                                                                                                                                                                                                                                                                u,v,t,x,y,z = vars('u','v','t','x','y','z')
                                                                                                                                                                                                                                                                GOOD time: 0.070000ms
                                                                                                                                                                                                                                                                stack: size: 0

                                                                                                                                                                                                                                                                  u:setDependentVars(t,x)
                                                                                                                                                                                                                                                                  GOOD time: 0.053000ms
                                                                                                                                                                                                                                                                  stack: size: 0

                                                                                                                                                                                                                                                                    v:setDependentVars(t,x)
                                                                                                                                                                                                                                                                    GOOD time: 0.054000ms
                                                                                                                                                                                                                                                                    stack: size: 0

                                                                                                                                                                                                                                                                      t:setDependentVars(u,v)
                                                                                                                                                                                                                                                                      GOOD time: 0.040000ms
                                                                                                                                                                                                                                                                      stack: size: 0

                                                                                                                                                                                                                                                                        x:setDependentVars(u,v)
                                                                                                                                                                                                                                                                        GOOD time: 0.105000ms
                                                                                                                                                                                                                                                                        stack: size: 0

                                                                                                                                                                                                                                                                          allvars = table{u,v,t,x,y,z}
                                                                                                                                                                                                                                                                          GOOD time: 0.059000ms
                                                                                                                                                                                                                                                                          stack: size: 0

                                                                                                                                                                                                                                                                            all = Matrix(allvars):T()
                                                                                                                                                                                                                                                                            GOOD time: 0.265000ms
                                                                                                                                                                                                                                                                            stack: size: 0

                                                                                                                                                                                                                                                                              varofall = var('\\{'..allvars:mapi(function(v) return v.name end):concat','..'\\}')
                                                                                                                                                                                                                                                                              GOOD time: 0.296000ms
                                                                                                                                                                                                                                                                              stack: size: 0

                                                                                                                                                                                                                                                                                print(varofall:diff(varofall):eq(Matrix:lambda({#all,#all}, function(i,j) return allvars[i]:diff(allvars[j])() end)))
                                                                                                                                                                                                                                                                                ${\frac{\partial \{u,v,t,x,y,z\}}{\partial \{u,v,t,x,y,z\}}} = {\left[\begin{array}{cccccc} 1& 0& \frac{\partial u}{\partial t}& \frac{\partial u}{\partial x}& 0& 0\\ 0& 1& \frac{\partial v}{\partial t}& \frac{\partial v}{\partial x}& 0& 0\\ \frac{\partial t}{\partial u}& \frac{\partial t}{\partial v}& 1& 0& 0& 0\\ \frac{\partial x}{\partial u}& \frac{\partial x}{\partial v}& 0& 1& 0& 0\\ 0& 0& 0& 0& 1& 0\\ 0& 0& 0& 0& 0& 1\end{array}\right]}$ GOOD time: 19.244000ms
                                                                                                                                                                                                                                                                                stack: size: 8
                                                                                                                                                                                                                                                                                • Init
                                                                                                                                                                                                                                                                                • Derivative:Prune:self
                                                                                                                                                                                                                                                                                • Prune
                                                                                                                                                                                                                                                                                • Expand
                                                                                                                                                                                                                                                                                • Prune
                                                                                                                                                                                                                                                                                • Factor
                                                                                                                                                                                                                                                                                • Prune
                                                                                                                                                                                                                                                                                • Tidy