testing dependency


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

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

      assertEq(#y'^p':getDependentVars(), 0)
      ${0} = {0}$
      GOOD
      time: 0.066000ms
      stack: size: 0
        depends regardless of specification
        assertEq(true, y:dependsOn(y))
        ${true} = {true}$
        GOOD
        time: 0.047000ms
        stack: size: 0
          was not specified
          assertEq(false, y:dependsOn(y'^p'))
          ${false} = {false}$
          GOOD
          time: 0.026000ms
          stack: size: 0
            was not specified
            assertEq(false, y'^p':dependsOn(y))
            ${false} = {false}$
            GOOD
            time: 0.093000ms
            stack: size: 0
              depends regardless of specification
              assertEq(true, y'^p':dependsOn(y'^q'))
              ${true} = {true}$
              GOOD
              time: 0.051000ms
              stack: size: 0


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

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

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

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

                        assertEq(#y'^pq':getDependentVars(), 0)
                        ${0} = {0}$
                        GOOD
                        time: 0.024000ms
                        stack: size: 0
                          was not specified
                          assertEq(false, y'^p':dependsOn(x))
                          ${false} = {false}$
                          GOOD
                          time: 0.052000ms
                          stack: size: 0
                            was not specified
                            assertEq(false, y'^p':dependsOn(x'^q'))
                            ${false} = {false}$
                            GOOD
                            time: 0.152000ms
                            stack: size: 0
                              was specified
                              assertEq(true, y:dependsOn(x'^q'))
                              ${true} = {true}$
                              GOOD
                              time: 0.091000ms
                              stack: size: 0
                                was not specified
                                assertEq(false, y:dependsOn(x))
                                ${false} = {false}$
                                GOOD
                                time: 0.045000ms
                                stack: size: 0


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                                                                              assertEq(false, y'^ij':dependsOn(x'^pq'))
                                                                              ${false} = {false}$
                                                                              GOOD
                                                                              time: 0.039000ms
                                                                              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: 0.354000ms
                                                                                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: 0.413000ms
                                                                                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: 0.217000ms
                                                                                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: 0.258000ms
                                                                                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.176000ms
                                                                                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.207000ms
                                                                                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.202000ms
                                                                                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.263000ms
                                                                                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.228000ms
                                                                                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.331000ms
                                                                                stack: size: 8
                                                                                • Init
                                                                                • Derivative:Prune:other
                                                                                • Prune
                                                                                • Expand
                                                                                • Prune
                                                                                • Factor
                                                                                • Prune
                                                                                • Tidy

                                                                                simplifyAssertEq(y:diff(x,z), zero)
                                                                                ${\frac{\partial^ 2 y}{\partial x\partial z}} = {0}$
                                                                                GOOD
                                                                                time: 0.188000ms
                                                                                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: 0.797000ms
                                                                                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: 0.612000ms
                                                                                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: 0.428000ms
                                                                                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: 0.405000ms
                                                                                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: 1.415000ms
                                                                                stack: size: 8
                                                                                • Init
                                                                                • Prune
                                                                                • Expand
                                                                                • Prune
                                                                                • Factor
                                                                                • Prune
                                                                                • *:Tidy:apply
                                                                                • Tidy



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

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

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

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

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

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

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

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

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

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

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

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

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

                                                                                                          simplifyAssertEq(y:diff(x), zero)
                                                                                                          ${\frac{\partial y}{\partial x}} = {0}$
                                                                                                          GOOD
                                                                                                          time: 0.384000ms
                                                                                                          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: 0.924000ms
                                                                                                          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.179000ms
                                                                                                          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.071000ms
                                                                                                          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.154000ms
                                                                                                          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.197000ms
                                                                                                          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.100000ms
                                                                                                          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.140000ms
                                                                                                          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.140000ms
                                                                                                          stack: size: 8
                                                                                                          • Init
                                                                                                          • Derivative:Prune:other
                                                                                                          • Prune
                                                                                                          • Expand
                                                                                                          • Prune
                                                                                                          • Factor
                                                                                                          • Prune
                                                                                                          • Tidy


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

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

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

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

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

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

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

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

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

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

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

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

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

                                                                                                                                    simplifyAssertEq(y:diff(x), zero)
                                                                                                                                    ${\frac{\partial y}{\partial x}} = {0}$
                                                                                                                                    GOOD
                                                                                                                                    time: 0.102000ms
                                                                                                                                    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.072000ms
                                                                                                                                    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.150000ms
                                                                                                                                    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: 0.408000ms
                                                                                                                                    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: 0.077000ms
                                                                                                                                    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.152000ms
                                                                                                                                    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.094000ms
                                                                                                                                    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.070000ms
                                                                                                                                    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.084000ms
                                                                                                                                    stack: size: 8
                                                                                                                                    • Init
                                                                                                                                    • Derivative:Prune:other
                                                                                                                                    • Prune
                                                                                                                                    • Expand
                                                                                                                                    • Prune
                                                                                                                                    • Factor
                                                                                                                                    • Prune
                                                                                                                                    • Tidy


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

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

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

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

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

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

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

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

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

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

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

                                                                                                                                                          simplifyAssertEq(y:diff(x), zero)
                                                                                                                                                          ${\frac{\partial y}{\partial x}} = {0}$
                                                                                                                                                          GOOD
                                                                                                                                                          time: 0.082000ms
                                                                                                                                                          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.070000ms
                                                                                                                                                          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.060000ms
                                                                                                                                                          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.071000ms
                                                                                                                                                          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: 0.393000ms
                                                                                                                                                          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.077000ms
                                                                                                                                                          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.057000ms
                                                                                                                                                          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.063000ms
                                                                                                                                                          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.070000ms
                                                                                                                                                          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.005000ms
                                                                                                                                                          stack: size: 0

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

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


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

                                                                                                                                                                  assertEq(true, z:dependsOn(y))
                                                                                                                                                                  ${true} = {true}$
                                                                                                                                                                  GOOD
                                                                                                                                                                  time: 0.016000ms
                                                                                                                                                                  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.018000ms
                                                                                                                                                                    stack: size: 0

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

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

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

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

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


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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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


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

                                                                                                                                                                                                                                                  assertEq(true, z:dependsOn(y))
                                                                                                                                                                                                                                                  ${true} = {true}$
                                                                                                                                                                                                                                                  GOOD
                                                                                                                                                                                                                                                  time: 0.015000ms
                                                                                                                                                                                                                                                  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.013000ms
                                                                                                                                                                                                                                                    stack: size: 0

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

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

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

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

                                                                                                                                                                                                                                                              assertEq(true, x'^I':dependsOn(x'^I'))
                                                                                                                                                                                                                                                              ${true} = {true}$
                                                                                                                                                                                                                                                              GOOD
                                                                                                                                                                                                                                                              time: 0.021000ms
                                                                                                                                                                                                                                                              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.053000ms
                                                                                                                                                                                                                                                                stack: size: 0

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

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

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

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

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

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

                                                                                                                                                                                                                                                                              varofall = var('\\{'..allvars:mapi(function(v) return v.name end):concat','..'\\}')
                                                                                                                                                                                                                                                                              GOOD time: 0.012000ms
                                                                                                                                                                                                                                                                              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: 2.665000ms
                                                                                                                                                                                                                                                                                stack: size: 8
                                                                                                                                                                                                                                                                                • Init
                                                                                                                                                                                                                                                                                • Derivative:Prune:self
                                                                                                                                                                                                                                                                                • Prune
                                                                                                                                                                                                                                                                                • Expand
                                                                                                                                                                                                                                                                                • Prune
                                                                                                                                                                                                                                                                                • Factor
                                                                                                                                                                                                                                                                                • Prune
                                                                                                                                                                                                                                                                                • Tidy