**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[])}):({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}))
Func sig: (T:b[*], U:b[*]) to ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(0)<0> [] },
    {   U: Ten<bool>(0)<0> [] },
    { Dot: Ten<bool>()<> [false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[])}):({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}))
Func sig: (T:b[*], U:b[*]) to ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(0)<0> [] },
    {   U: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] },
    { Dot: Ten<bool>()<> [false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*])}):({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]}))
Func sig: (T:b[*], U:b[*,*]) to ({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(0)<0> [] },
    {   U: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    },
    { Dot: Ten<bool>(4)<0> [false, false, false, false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*])}):({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]}))
Func sig: (T:b[*], U:b[*,*]) to ({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(0)<0> [] },
    {   U: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    },
    { Dot: Ten<bool>(3)<0> [false, false, false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[*], U:b[*,*,*]) to ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(0)<0> [] },
    {   U: Ten<bool>(1,0,1)<0,0,0> [] },
    { Dot: Ten<bool>(1,1)<0,0>
          [[false]]
    })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[*], U:b[*,*,*]) to ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(0)<0> [] },
    {   U: Ten<bool>(3,1,0)<0,0,0> [] },
    { Dot: Ten<bool>(3,0)<0,0> [] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*])}):({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]}))
Func sig: (T:b[*], U:b[]) to ({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(0)<0> [] },
    {   U: Ten<bool>()<> [true ] },
    { Dot: Ten<bool>(0)<0> [] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[])}):({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}))
Func sig: (T:b[*], U:b[*]) to ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(0)<0> [] },
    {   U: Ten<bool>(3)<0> [true , true , true ] },
    { Dot: Ten<bool>()<> [false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*])}):({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]}))
Func sig: (T:b[*], U:b[]) to ({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(0)<0> [] },
    {   U: Ten<bool>()<> [false] },
    { Dot: Ten<bool>(0)<0> [] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[])}):({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}))
Func sig: (T:b[*], U:b[*]) to ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(0)<0> [] },
    {   U: Ten<bool>(0)<0> [] },
    { Dot: Ten<bool>()<> [false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[*], U:b[*,*,*]) to ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(0)<0> [] },
    {   U: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    },
    { Dot: Ten<bool>(4,3)<0,0>
          [[false, false, false]
           [false, false, false]
           [false, false, false]
           [false, false, false]]
    })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[*], U:b[*,*,*]) to ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(0)<0> [] },
    {   U: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    },
    { Dot: Ten<bool>(5,6)<0,0>
          [[false, false, false, false, false, false]
           [false, false, false, false, false, false]
           [false, false, false, false, false, false]
           [false, false, false, false, false, false]
           [false, false, false, false, false, false]]
    })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[])}):({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}))
Func sig: (T:b[*], U:b[*]) to ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(0)<0> [] },
    {   U: Ten<bool>(4)<0> [false, false, false, false] },
    { Dot: Ten<bool>()<> [false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[])}):({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}))
Func sig: (T:b[*], U:b[*]) to ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] },
    {   U: Ten<bool>(0)<0> [] },
    { Dot: Ten<bool>()<> [false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[])}):({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}))
Func sig: (T:b[*], U:b[*]) to ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] },
    {   U: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] },
    { Dot: Ten<bool>()<> [false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*])}):({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]}))
Func sig: (T:b[*], U:b[*,*]) to ({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] },
    {   U: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    },
    { Dot: Ten<bool>(4)<1> [false, false, false, false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*])}):({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]}))
Func sig: (T:b[*], U:b[*,*]) to ({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] },
    {   U: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    },
    { Dot: Ten<bool>(3)<1> [false, false, false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[*], U:b[*,*,*]) to ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] },
    {   U: Ten<bool>(1,0,1)<0,0,0> [] },
    { Dot: Ten<bool>(1,1)<0,0>
          [[false]]
    })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[*], U:b[*,*,*]) to ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] },
    {   U: Ten<bool>(3,1,0)<0,0,0> [] },
    { Dot: Ten<bool>(3,0)<0,0> [] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*])}):({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]}))
Func sig: (T:b[*], U:b[]) to ({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] },
    {   U: Ten<bool>()<> [true ] },
    { Dot: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[])}):({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}))
Func sig: (T:b[*], U:b[*]) to ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] },
    {   U: Ten<bool>(3)<0> [true , true , true ] },
    { Dot: Ten<bool>()<> [false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*])}):({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]}))
Func sig: (T:b[*], U:b[]) to ({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] },
    {   U: Ten<bool>()<> [false] },
    { Dot: Ten<bool>(12)<0> [false, false, false, false, false, false, false, false, false, false, false, false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[])}):({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}))
Func sig: (T:b[*], U:b[*]) to ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] },
    {   U: Ten<bool>(0)<0> [] },
    { Dot: Ten<bool>()<> [false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[*], U:b[*,*,*]) to ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] },
    {   U: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    },
    { Dot: Ten<bool>(4,3)<0,0>
          [[false, false, false]
           [false, false, false]
           [false, false, false]
           [false, false, false]]
    })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[*], U:b[*,*,*]) to ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] },
    {   U: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    },
    { Dot: Ten<bool>(5,6)<0,0>
          [[false, false, false, false, false, false]
           [false, false, false, false, false, false]
           [false, false, false, false, false, false]
           [false, false, false, false, false, false]
           [false, false, false, false, false, false]]
    })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[])}):({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}))
Func sig: (T:b[*], U:b[*]) to ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] },
    {   U: Ten<bool>(4)<0> [false, false, false, false] },
    { Dot: Ten<bool>()<> [false] })
###

**** New definitions: T, type: b[*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*])}):({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]}))
Func sig: (T:b[*,*], U:b[*]) to ({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    },
    {   U: Ten<bool>(0)<0> [] },
    { Dot: Ten<bool>(3)<0> [false, false, false] })
###

**** New definitions: T, type: b[*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*])}):({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]}))
Func sig: (T:b[*,*], U:b[*]) to ({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    },
    {   U: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] },
    { Dot: Ten<bool>(3)<1> [false, false, false] })
###

**** New definitions: T, type: b[*,*]
**** New definitions: U, type: b[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*]}, {'  U':b[*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*]}, {'  U':b[*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*]}, {'  U':b[*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*], U:b[*,*]) to ({'  T':b[*,*]}, {'  U':b[*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    },
    {   U: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    },
    { Dot: Ten<bool>(3,4)<4,1>
          [[false, false, false, false]
           [false, false, false, false]
           [false, false, false, false]]
    })
###

**** New definitions: T, type: b[*,*]
**** New definitions: U, type: b[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*]}, {'  U':b[*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*]}, {'  U':b[*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*]}, {'  U':b[*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*], U:b[*,*]) to ({'  T':b[*,*]}, {'  U':b[*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    },
    {   U: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    },
    { Dot: Ten<bool>(3,3)<3,1>
          [[false, false, false]
           [false, false, false]
           [false, false, false]]
    })
###

**** New definitions: T, type: b[*,*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*])}):({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}))
Func sig: (T:b[*,*], U:b[*,*,*]) to ({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    },
    {   U: Ten<bool>(1,0,1)<0,0,0> [] },
    { Dot: Ten<bool>(3,1,1)<0,0,0>
          [[[false]]

           [[false]]

           [[false]]]
    })
###

**** New definitions: T, type: b[*,*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*])}):({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}))
Func sig: (T:b[*,*], U:b[*,*,*]) to ({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    },
    {   U: Ten<bool>(3,1,0)<0,0,0> [] },
    { Dot: Ten<bool>(3,3,0)<0,0,0> [] })
###

**** New definitions: T, type: b[*,*]
**** New definitions: U, type: b[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*]}, {'  U':b[]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*]}, {'  U':b[]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*]}, {'  U':b[]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*], U:b[]) to ({'  T':b[*,*]}, {'  U':b[]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    },
    {   U: Ten<bool>()<> [true ] },
    { Dot: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    })
###

**** New definitions: T, type: b[*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*])}):({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]}))
Func sig: (T:b[*,*], U:b[*]) to ({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    },
    {   U: Ten<bool>(3)<0> [true , true , true ] },
    { Dot: Ten<bool>(3)<1> [false, false, false] })
###

**** New definitions: T, type: b[*,*]
**** New definitions: U, type: b[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*]}, {'  U':b[]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*]}, {'  U':b[]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*]}, {'  U':b[]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*], U:b[]) to ({'  T':b[*,*]}, {'  U':b[]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    },
    {   U: Ten<bool>()<> [false] },
    { Dot: Ten<bool>(3,4)<0,0>
          [[false, false, false, false]
           [false, false, false, false]
           [false, false, false, false]]
    })
###

**** New definitions: T, type: b[*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*])}):({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]}))
Func sig: (T:b[*,*], U:b[*]) to ({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    },
    {   U: Ten<bool>(0)<0> [] },
    { Dot: Ten<bool>(3)<0> [false, false, false] })
###

**** New definitions: T, type: b[*,*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*])}):({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}))
Func sig: (T:b[*,*], U:b[*,*,*]) to ({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    },
    {   U: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    },
    { Dot: Ten<bool>(3,4,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]
            [false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]
            [false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]
            [false, false, false]
            [false, false, false]]]
    })
###

**** New definitions: T, type: b[*,*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*])}):({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}))
Func sig: (T:b[*,*], U:b[*,*,*]) to ({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    },
    {   U: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    },
    { Dot: Ten<bool>(3,5,6)<1,0,0>
          [[[false, false, false, false, false, false]
            [false, false, false, false, false, false]
            [false, false, false, false, false, false]
            [false, false, false, false, false, false]
            [false, false, false, false, false, false]]

           [[false, false, false, false, false, false]
            [false, false, false, false, false, false]
            [false, false, false, false, false, false]
            [false, false, false, false, false, false]
            [false, false, false, false, false, false]]

           [[false, false, false, false, false, false]
            [false, false, false, false, false, false]
            [false, false, false, false, false, false]
            [false, false, false, false, false, false]
            [false, false, false, false, false, false]]]
    })
###

**** New definitions: T, type: b[*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*])}):({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]}))
Func sig: (T:b[*,*], U:b[*]) to ({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    },
    {   U: Ten<bool>(4)<0> [false, false, false, false] },
    { Dot: Ten<bool>(3)<0> [false, false, false] })
###

**** New definitions: T, type: b[*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*])}):({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]}))
Func sig: (T:b[*,*], U:b[*]) to ({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    },
    {   U: Ten<bool>(0)<0> [] },
    { Dot: Ten<bool>(4)<0> [false, false, false, false] })
###

**** New definitions: T, type: b[*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*])}):({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]}))
Func sig: (T:b[*,*], U:b[*]) to ({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    },
    {   U: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] },
    { Dot: Ten<bool>(4)<1> [false, false, false, false] })
###

**** New definitions: T, type: b[*,*]
**** New definitions: U, type: b[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*]}, {'  U':b[*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*]}, {'  U':b[*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*]}, {'  U':b[*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*], U:b[*,*]) to ({'  T':b[*,*]}, {'  U':b[*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    },
    {   U: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    },
    { Dot: Ten<bool>(4,4)<4,1>
          [[false, false, false, false]
           [true , false, true , false]
           [false, false, false, false]
           [true , false, true , false]]
    })
###

**** New definitions: T, type: b[*,*]
**** New definitions: U, type: b[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*]}, {'  U':b[*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*]}, {'  U':b[*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*]}, {'  U':b[*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*], U:b[*,*]) to ({'  T':b[*,*]}, {'  U':b[*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    },
    {   U: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    },
    { Dot: Ten<bool>(4,3)<3,1>
          [[false, false, false]
           [false, true , false]
           [false, false, false]
           [false, true , false]]
    })
###

**** New definitions: T, type: b[*,*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*])}):({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}))
Func sig: (T:b[*,*], U:b[*,*,*]) to ({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    },
    {   U: Ten<bool>(1,0,1)<0,0,0> [] },
    { Dot: Ten<bool>(4,1,1)<0,0,0>
          [[[false]]

           [[false]]

           [[false]]

           [[false]]]
    })
###

**** New definitions: T, type: b[*,*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*])}):({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}))
Func sig: (T:b[*,*], U:b[*,*,*]) to ({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    },
    {   U: Ten<bool>(3,1,0)<0,0,0> [] },
    { Dot: Ten<bool>(4,3,0)<0,0,0> [] })
###

**** New definitions: T, type: b[*,*]
**** New definitions: U, type: b[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*]}, {'  U':b[]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*]}, {'  U':b[]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*]}, {'  U':b[]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*], U:b[]) to ({'  T':b[*,*]}, {'  U':b[]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    },
    {   U: Ten<bool>()<> [true ] },
    { Dot: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    })
###

**** New definitions: T, type: b[*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*])}):({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]}))
Func sig: (T:b[*,*], U:b[*]) to ({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    },
    {   U: Ten<bool>(3)<0> [true , true , true ] },
    { Dot: Ten<bool>(4)<1> [false, true , false, true ] })
###

**** New definitions: T, type: b[*,*]
**** New definitions: U, type: b[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*]}, {'  U':b[]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*]}, {'  U':b[]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*]}, {'  U':b[]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*], U:b[]) to ({'  T':b[*,*]}, {'  U':b[]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    },
    {   U: Ten<bool>()<> [false] },
    { Dot: Ten<bool>(4,3)<0,0>
          [[false, false, false]
           [false, false, false]
           [false, false, false]
           [false, false, false]]
    })
###

**** New definitions: T, type: b[*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*])}):({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]}))
Func sig: (T:b[*,*], U:b[*]) to ({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    },
    {   U: Ten<bool>(0)<0> [] },
    { Dot: Ten<bool>(4)<0> [false, false, false, false] })
###

**** New definitions: T, type: b[*,*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*])}):({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}))
Func sig: (T:b[*,*], U:b[*,*,*]) to ({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    },
    {   U: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    },
    { Dot: Ten<bool>(4,4,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]
            [false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]
            [false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]
            [false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]
            [false, false, false]
            [false, false, false]]]
    })
###

**** New definitions: T, type: b[*,*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*])}):({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}))
Func sig: (T:b[*,*], U:b[*,*,*]) to ({'  T':b[*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    },
    {   U: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    },
    { Dot: Ten<bool>(4,5,6)<1,0,0>
          [[[false, false, false, false, false, false]
            [false, false, false, false, false, false]
            [false, false, false, false, false, false]
            [false, false, false, false, false, false]
            [false, false, false, false, false, false]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[false, false, false, false, false, false]
            [false, false, false, false, false, false]
            [false, false, false, false, false, false]
            [false, false, false, false, false, false]
            [false, false, false, false, false, false]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    })
###

**** New definitions: T, type: b[*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*])}):({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]}))
Func sig: (T:b[*,*], U:b[*]) to ({'  T':b[*,*]}, {'  U':b[*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    },
    {   U: Ten<bool>(4)<0> [false, false, false, false] },
    { Dot: Ten<bool>(4)<0> [false, false, false, false] })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*,*], U:b[*]) to ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(1,0,1)<0,0,0> [] },
    {   U: Ten<bool>(0)<0> [] },
    { Dot: Ten<bool>(1,0)<0,0> [] })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*,*], U:b[*]) to ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(1,0,1)<0,0,0> [] },
    {   U: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] },
    { Dot: Ten<bool>(1,0)<0,0> [] })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]}))
Func sig: (T:b[*,*,*], U:b[*,*]) to ({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(1,0,1)<0,0,0> [] },
    {   U: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    },
    { Dot: Ten<bool>(1,0,4)<0,0,0> [] })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]}))
Func sig: (T:b[*,*,*], U:b[*,*]) to ({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(1,0,1)<0,0,0> [] },
    {   U: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    },
    { Dot: Ten<bool>(1,0,3)<0,0,0> [] })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}))
Func sig: (T:b[*,*,*], U:b[*,*,*]) to ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(1,0,1)<0,0,0> [] },
    {   U: Ten<bool>(1,0,1)<0,0,0> [] },
    { Dot: Ten<bool>(1,0,1,1)<0,0,0,0> [] })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}))
Func sig: (T:b[*,*,*], U:b[*,*,*]) to ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(1,0,1)<0,0,0> [] },
    {   U: Ten<bool>(3,1,0)<0,0,0> [] },
    { Dot: Ten<bool>(1,0,3,0)<0,0,0,0> [] })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]}))
Func sig: (T:b[*,*,*], U:b[]) to ({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(1,0,1)<0,0,0> [] },
    {   U: Ten<bool>()<> [true ] },
    { Dot: Ten<bool>(1,0,1)<0,0,0> [] })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*,*], U:b[*]) to ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(1,0,1)<0,0,0> [] },
    {   U: Ten<bool>(3)<0> [true , true , true ] },
    { Dot: Ten<bool>(1,0)<0,0> [] })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]}))
Func sig: (T:b[*,*,*], U:b[]) to ({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(1,0,1)<0,0,0> [] },
    {   U: Ten<bool>()<> [false] },
    { Dot: Ten<bool>(1,0,1)<0,0,0> [] })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*,*], U:b[*]) to ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(1,0,1)<0,0,0> [] },
    {   U: Ten<bool>(0)<0> [] },
    { Dot: Ten<bool>(1,0)<0,0> [] })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}))
Func sig: (T:b[*,*,*], U:b[*,*,*]) to ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(1,0,1)<0,0,0> [] },
    {   U: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    },
    { Dot: Ten<bool>(1,0,4,3)<0,0,0,0> [] })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}))
Func sig: (T:b[*,*,*], U:b[*,*,*]) to ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(1,0,1)<0,0,0> [] },
    {   U: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    },
    { Dot: Ten<bool>(1,0,5,6)<0,0,0,0> [] })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*,*], U:b[*]) to ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(1,0,1)<0,0,0> [] },
    {   U: Ten<bool>(4)<0> [false, false, false, false] },
    { Dot: Ten<bool>(1,0)<0,0> [] })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*,*], U:b[*]) to ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3,1,0)<0,0,0> [] },
    {   U: Ten<bool>(0)<0> [] },
    { Dot: Ten<bool>(3,1)<0,0>
          [[false]
           [false]
           [false]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*,*], U:b[*]) to ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3,1,0)<0,0,0> [] },
    {   U: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] },
    { Dot: Ten<bool>(3,1)<0,0>
          [[false]
           [false]
           [false]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]}))
Func sig: (T:b[*,*,*], U:b[*,*]) to ({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3,1,0)<0,0,0> [] },
    {   U: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    },
    { Dot: Ten<bool>(3,1,4)<0,0,0>
          [[[false, false, false, false]]

           [[false, false, false, false]]

           [[false, false, false, false]]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]}))
Func sig: (T:b[*,*,*], U:b[*,*]) to ({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3,1,0)<0,0,0> [] },
    {   U: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    },
    { Dot: Ten<bool>(3,1,3)<0,0,0>
          [[[false, false, false]]

           [[false, false, false]]

           [[false, false, false]]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}))
Func sig: (T:b[*,*,*], U:b[*,*,*]) to ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3,1,0)<0,0,0> [] },
    {   U: Ten<bool>(1,0,1)<0,0,0> [] },
    { Dot: Ten<bool>(3,1,1,1)<0,0,0,0>
          [[[[false]]]


           [[[false]]]


           [[[false]]]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}))
Func sig: (T:b[*,*,*], U:b[*,*,*]) to ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3,1,0)<0,0,0> [] },
    {   U: Ten<bool>(3,1,0)<0,0,0> [] },
    { Dot: Ten<bool>(3,1,3,0)<0,0,0,0> [] })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]}))
Func sig: (T:b[*,*,*], U:b[]) to ({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3,1,0)<0,0,0> [] },
    {   U: Ten<bool>()<> [true ] },
    { Dot: Ten<bool>(3,1,0)<0,0,0> [] })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*,*], U:b[*]) to ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3,1,0)<0,0,0> [] },
    {   U: Ten<bool>(3)<0> [true , true , true ] },
    { Dot: Ten<bool>(3,1)<0,0>
          [[false]
           [false]
           [false]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]}))
Func sig: (T:b[*,*,*], U:b[]) to ({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3,1,0)<0,0,0> [] },
    {   U: Ten<bool>()<> [false] },
    { Dot: Ten<bool>(3,1,0)<0,0,0> [] })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*,*], U:b[*]) to ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3,1,0)<0,0,0> [] },
    {   U: Ten<bool>(0)<0> [] },
    { Dot: Ten<bool>(3,1)<0,0>
          [[false]
           [false]
           [false]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}))
Func sig: (T:b[*,*,*], U:b[*,*,*]) to ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3,1,0)<0,0,0> [] },
    {   U: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    },
    { Dot: Ten<bool>(3,1,4,3)<0,0,0,0>
          [[[[false, false, false]
             [false, false, false]
             [false, false, false]
             [false, false, false]]]


           [[[false, false, false]
             [false, false, false]
             [false, false, false]
             [false, false, false]]]


           [[[false, false, false]
             [false, false, false]
             [false, false, false]
             [false, false, false]]]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}))
Func sig: (T:b[*,*,*], U:b[*,*,*]) to ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3,1,0)<0,0,0> [] },
    {   U: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    },
    { Dot: Ten<bool>(3,1,5,6)<0,0,0,0>
          [[[[false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]]]


           [[[false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]]]


           [[[false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]]]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*,*], U:b[*]) to ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3,1,0)<0,0,0> [] },
    {   U: Ten<bool>(4)<0> [false, false, false, false] },
    { Dot: Ten<bool>(3,1)<0,0>
          [[false]
           [false]
           [false]]
    })
###

**** New definitions: T, type: b[]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*])}):({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]}))
Func sig: (T:b[], U:b[*]) to ({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>()<> [true ] },
    {   U: Ten<bool>(0)<0> [] },
    { Dot: Ten<bool>(0)<0> [] })
###

**** New definitions: T, type: b[]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*])}):({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]}))
Func sig: (T:b[], U:b[*]) to ({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>()<> [true ] },
    {   U: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] },
    { Dot: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] })
###

**** New definitions: T, type: b[]
**** New definitions: U, type: b[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[]}, {'  U':b[*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[]}, {'  U':b[*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*,*])}):({'  T':b[]}, {'  U':b[*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[], U:b[*,*]) to ({'  T':b[]}, {'  U':b[*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>()<> [true ] },
    {   U: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    },
    { Dot: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    })
###

**** New definitions: T, type: b[]
**** New definitions: U, type: b[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[]}, {'  U':b[*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[]}, {'  U':b[*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*,*])}):({'  T':b[]}, {'  U':b[*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[], U:b[*,*]) to ({'  T':b[]}, {'  U':b[*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>()<> [true ] },
    {   U: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    },
    { Dot: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    })
###

**** New definitions: T, type: b[]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*,*,*])}):({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}))
Func sig: (T:b[], U:b[*,*,*]) to ({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>()<> [true ] },
    {   U: Ten<bool>(1,0,1)<0,0,0> [] },
    { Dot: Ten<bool>(1,0,1)<0,0,0> [] })
###

**** New definitions: T, type: b[]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*,*,*])}):({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}))
Func sig: (T:b[], U:b[*,*,*]) to ({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>()<> [true ] },
    {   U: Ten<bool>(3,1,0)<0,0,0> [] },
    { Dot: Ten<bool>(3,1,0)<0,0,0> [] })
###

**** New definitions: T, type: b[]
**** New definitions: U, type: b[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[]}, {'  U':b[]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[]}, {'  U':b[]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[])}):({'  T':b[]}, {'  U':b[]}, {Dot:b[]}))
Func sig: (T:b[], U:b[]) to ({'  T':b[]}, {'  U':b[]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>()<> [true ] },
    {   U: Ten<bool>()<> [true ] },
    { Dot: Ten<bool>()<> [true ] })
###

**** New definitions: T, type: b[]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*])}):({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]}))
Func sig: (T:b[], U:b[*]) to ({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>()<> [true ] },
    {   U: Ten<bool>(3)<0> [true , true , true ] },
    { Dot: Ten<bool>(3)<0> [true , true , true ] })
###

**** New definitions: T, type: b[]
**** New definitions: U, type: b[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[]}, {'  U':b[]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[]}, {'  U':b[]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[])}):({'  T':b[]}, {'  U':b[]}, {Dot:b[]}))
Func sig: (T:b[], U:b[]) to ({'  T':b[]}, {'  U':b[]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>()<> [true ] },
    {   U: Ten<bool>()<> [false] },
    { Dot: Ten<bool>()<> [false] })
###

**** New definitions: T, type: b[]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*])}):({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]}))
Func sig: (T:b[], U:b[*]) to ({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>()<> [true ] },
    {   U: Ten<bool>(0)<0> [] },
    { Dot: Ten<bool>(0)<0> [] })
###

**** New definitions: T, type: b[]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*,*,*])}):({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}))
Func sig: (T:b[], U:b[*,*,*]) to ({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>()<> [true ] },
    {   U: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    },
    { Dot: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    })
###

**** New definitions: T, type: b[]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*,*,*])}):({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}))
Func sig: (T:b[], U:b[*,*,*]) to ({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>()<> [true ] },
    {   U: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    },
    { Dot: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    })
###

**** New definitions: T, type: b[]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*])}):({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]}))
Func sig: (T:b[], U:b[*]) to ({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>()<> [true ] },
    {   U: Ten<bool>(4)<0> [false, false, false, false] },
    { Dot: Ten<bool>(4)<0> [false, false, false, false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[])}):({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}))
Func sig: (T:b[*], U:b[*]) to ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3)<0> [true , true , true ] },
    {   U: Ten<bool>(0)<0> [] },
    { Dot: Ten<bool>()<> [false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[])}):({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}))
Func sig: (T:b[*], U:b[*]) to ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3)<0> [true , true , true ] },
    {   U: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] },
    { Dot: Ten<bool>()<> [false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*])}):({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]}))
Func sig: (T:b[*], U:b[*,*]) to ({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3)<0> [true , true , true ] },
    {   U: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    },
    { Dot: Ten<bool>(4)<1> [true , false, true , false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*])}):({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]}))
Func sig: (T:b[*], U:b[*,*]) to ({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3)<0> [true , true , true ] },
    {   U: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    },
    { Dot: Ten<bool>(3)<1> [false, true , false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[*], U:b[*,*,*]) to ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3)<0> [true , true , true ] },
    {   U: Ten<bool>(1,0,1)<0,0,0> [] },
    { Dot: Ten<bool>(1,1)<0,0>
          [[false]]
    })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[*], U:b[*,*,*]) to ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3)<0> [true , true , true ] },
    {   U: Ten<bool>(3,1,0)<0,0,0> [] },
    { Dot: Ten<bool>(3,0)<0,0> [] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*])}):({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]}))
Func sig: (T:b[*], U:b[]) to ({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3)<0> [true , true , true ] },
    {   U: Ten<bool>()<> [true ] },
    { Dot: Ten<bool>(3)<0> [true , true , true ] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[])}):({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}))
Func sig: (T:b[*], U:b[*]) to ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3)<0> [true , true , true ] },
    {   U: Ten<bool>(3)<0> [true , true , true ] },
    { Dot: Ten<bool>()<> [true ] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*])}):({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]}))
Func sig: (T:b[*], U:b[]) to ({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3)<0> [true , true , true ] },
    {   U: Ten<bool>()<> [false] },
    { Dot: Ten<bool>(3)<0> [false, false, false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[])}):({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}))
Func sig: (T:b[*], U:b[*]) to ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3)<0> [true , true , true ] },
    {   U: Ten<bool>(0)<0> [] },
    { Dot: Ten<bool>()<> [false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[*], U:b[*,*,*]) to ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3)<0> [true , true , true ] },
    {   U: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    },
    { Dot: Ten<bool>(4,3)<0,0>
          [[false, false, false]
           [false, false, false]
           [false, false, false]
           [false, false, false]]
    })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[*], U:b[*,*,*]) to ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3)<0> [true , true , true ] },
    {   U: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    },
    { Dot: Ten<bool>(5,6)<0,0>
          [[true , true , true , true , true , true ]
           [true , true , true , true , true , true ]
           [true , true , true , true , true , true ]
           [true , true , true , true , true , true ]
           [true , true , true , true , true , true ]]
    })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[])}):({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}))
Func sig: (T:b[*], U:b[*]) to ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3)<0> [true , true , true ] },
    {   U: Ten<bool>(4)<0> [false, false, false, false] },
    { Dot: Ten<bool>()<> [false] })
###

**** New definitions: T, type: b[]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*])}):({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]}))
Func sig: (T:b[], U:b[*]) to ({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>()<> [false] },
    {   U: Ten<bool>(0)<0> [] },
    { Dot: Ten<bool>(0)<0> [] })
###

**** New definitions: T, type: b[]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*])}):({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]}))
Func sig: (T:b[], U:b[*]) to ({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>()<> [false] },
    {   U: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] },
    { Dot: Ten<bool>(12)<0> [false, false, false, false, false, false, false, false, false, false, false, false] })
###

**** New definitions: T, type: b[]
**** New definitions: U, type: b[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[]}, {'  U':b[*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[]}, {'  U':b[*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*,*])}):({'  T':b[]}, {'  U':b[*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[], U:b[*,*]) to ({'  T':b[]}, {'  U':b[*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>()<> [false] },
    {   U: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    },
    { Dot: Ten<bool>(3,4)<0,0>
          [[false, false, false, false]
           [false, false, false, false]
           [false, false, false, false]]
    })
###

**** New definitions: T, type: b[]
**** New definitions: U, type: b[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[]}, {'  U':b[*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[]}, {'  U':b[*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*,*])}):({'  T':b[]}, {'  U':b[*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[], U:b[*,*]) to ({'  T':b[]}, {'  U':b[*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>()<> [false] },
    {   U: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    },
    { Dot: Ten<bool>(4,3)<0,0>
          [[false, false, false]
           [false, false, false]
           [false, false, false]
           [false, false, false]]
    })
###

**** New definitions: T, type: b[]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*,*,*])}):({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}))
Func sig: (T:b[], U:b[*,*,*]) to ({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>()<> [false] },
    {   U: Ten<bool>(1,0,1)<0,0,0> [] },
    { Dot: Ten<bool>(1,0,1)<0,0,0> [] })
###

**** New definitions: T, type: b[]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*,*,*])}):({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}))
Func sig: (T:b[], U:b[*,*,*]) to ({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>()<> [false] },
    {   U: Ten<bool>(3,1,0)<0,0,0> [] },
    { Dot: Ten<bool>(3,1,0)<0,0,0> [] })
###

**** New definitions: T, type: b[]
**** New definitions: U, type: b[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[]}, {'  U':b[]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[]}, {'  U':b[]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[])}):({'  T':b[]}, {'  U':b[]}, {Dot:b[]}))
Func sig: (T:b[], U:b[]) to ({'  T':b[]}, {'  U':b[]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>()<> [false] },
    {   U: Ten<bool>()<> [true ] },
    { Dot: Ten<bool>()<> [false] })
###

**** New definitions: T, type: b[]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*])}):({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]}))
Func sig: (T:b[], U:b[*]) to ({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>()<> [false] },
    {   U: Ten<bool>(3)<0> [true , true , true ] },
    { Dot: Ten<bool>(3)<0> [false, false, false] })
###

**** New definitions: T, type: b[]
**** New definitions: U, type: b[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[]}, {'  U':b[]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[]}, {'  U':b[]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[])}):({'  T':b[]}, {'  U':b[]}, {Dot:b[]}))
Func sig: (T:b[], U:b[]) to ({'  T':b[]}, {'  U':b[]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>()<> [false] },
    {   U: Ten<bool>()<> [false] },
    { Dot: Ten<bool>()<> [false] })
###

**** New definitions: T, type: b[]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*])}):({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]}))
Func sig: (T:b[], U:b[*]) to ({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>()<> [false] },
    {   U: Ten<bool>(0)<0> [] },
    { Dot: Ten<bool>(0)<0> [] })
###

**** New definitions: T, type: b[]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*,*,*])}):({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}))
Func sig: (T:b[], U:b[*,*,*]) to ({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>()<> [false] },
    {   U: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    },
    { Dot: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    })
###

**** New definitions: T, type: b[]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*,*,*])}):({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]}))
Func sig: (T:b[], U:b[*,*,*]) to ({'  T':b[]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>()<> [false] },
    {   U: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    },
    { Dot: Ten<bool>(5,3,6)<0,0,0>
          [[[false, false, false, false, false, false]
            [false, false, false, false, false, false]
            [false, false, false, false, false, false]]

           [[false, false, false, false, false, false]
            [false, false, false, false, false, false]
            [false, false, false, false, false, false]]

           [[false, false, false, false, false, false]
            [false, false, false, false, false, false]
            [false, false, false, false, false, false]]

           [[false, false, false, false, false, false]
            [false, false, false, false, false, false]
            [false, false, false, false, false, false]]

           [[false, false, false, false, false, false]
            [false, false, false, false, false, false]
            [false, false, false, false, false, false]]]
    })
###

**** New definitions: T, type: b[]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*])}):({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]}))
Func sig: (T:b[], U:b[*]) to ({'  T':b[]}, {'  U':b[*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>()<> [false] },
    {   U: Ten<bool>(4)<0> [false, false, false, false] },
    { Dot: Ten<bool>(4)<0> [false, false, false, false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[])}):({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}))
Func sig: (T:b[*], U:b[*]) to ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(0)<0> [] },
    {   U: Ten<bool>(0)<0> [] },
    { Dot: Ten<bool>()<> [false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[])}):({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}))
Func sig: (T:b[*], U:b[*]) to ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(0)<0> [] },
    {   U: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] },
    { Dot: Ten<bool>()<> [false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*])}):({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]}))
Func sig: (T:b[*], U:b[*,*]) to ({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(0)<0> [] },
    {   U: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    },
    { Dot: Ten<bool>(4)<0> [false, false, false, false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*])}):({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]}))
Func sig: (T:b[*], U:b[*,*]) to ({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(0)<0> [] },
    {   U: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    },
    { Dot: Ten<bool>(3)<0> [false, false, false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[*], U:b[*,*,*]) to ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(0)<0> [] },
    {   U: Ten<bool>(1,0,1)<0,0,0> [] },
    { Dot: Ten<bool>(1,1)<0,0>
          [[false]]
    })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[*], U:b[*,*,*]) to ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(0)<0> [] },
    {   U: Ten<bool>(3,1,0)<0,0,0> [] },
    { Dot: Ten<bool>(3,0)<0,0> [] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*])}):({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]}))
Func sig: (T:b[*], U:b[]) to ({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(0)<0> [] },
    {   U: Ten<bool>()<> [true ] },
    { Dot: Ten<bool>(0)<0> [] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[])}):({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}))
Func sig: (T:b[*], U:b[*]) to ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(0)<0> [] },
    {   U: Ten<bool>(3)<0> [true , true , true ] },
    { Dot: Ten<bool>()<> [false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*])}):({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]}))
Func sig: (T:b[*], U:b[]) to ({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(0)<0> [] },
    {   U: Ten<bool>()<> [false] },
    { Dot: Ten<bool>(0)<0> [] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[])}):({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}))
Func sig: (T:b[*], U:b[*]) to ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(0)<0> [] },
    {   U: Ten<bool>(0)<0> [] },
    { Dot: Ten<bool>()<> [false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[*], U:b[*,*,*]) to ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(0)<0> [] },
    {   U: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    },
    { Dot: Ten<bool>(4,3)<0,0>
          [[false, false, false]
           [false, false, false]
           [false, false, false]
           [false, false, false]]
    })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[*], U:b[*,*,*]) to ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(0)<0> [] },
    {   U: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    },
    { Dot: Ten<bool>(5,6)<0,0>
          [[false, false, false, false, false, false]
           [false, false, false, false, false, false]
           [false, false, false, false, false, false]
           [false, false, false, false, false, false]
           [false, false, false, false, false, false]]
    })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[])}):({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}))
Func sig: (T:b[*], U:b[*]) to ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(0)<0> [] },
    {   U: Ten<bool>(4)<0> [false, false, false, false] },
    { Dot: Ten<bool>()<> [false] })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*,*], U:b[*]) to ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    },
    {   U: Ten<bool>(0)<0> [] },
    { Dot: Ten<bool>(4,2)<0,0>
          [[false, false]
           [false, false]
           [false, false]
           [false, false]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*,*], U:b[*]) to ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    },
    {   U: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] },
    { Dot: Ten<bool>(4,2)<0,0>
          [[false, false]
           [false, false]
           [false, false]
           [false, false]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]}))
Func sig: (T:b[*,*,*], U:b[*,*]) to ({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    },
    {   U: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    },
    { Dot: Ten<bool>(4,2,4)<0,0,0>
          [[[false, false, false, false]
            [false, false, false, false]]

           [[false, false, false, false]
            [false, false, false, false]]

           [[false, false, false, false]
            [false, false, false, false]]

           [[false, false, false, false]
            [false, false, false, false]]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]}))
Func sig: (T:b[*,*,*], U:b[*,*]) to ({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    },
    {   U: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    },
    { Dot: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}))
Func sig: (T:b[*,*,*], U:b[*,*,*]) to ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    },
    {   U: Ten<bool>(1,0,1)<0,0,0> [] },
    { Dot: Ten<bool>(4,2,1,1)<0,0,0,0>
          [[[[false]]

            [[false]]]


           [[[false]]

            [[false]]]


           [[[false]]

            [[false]]]


           [[[false]]

            [[false]]]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}))
Func sig: (T:b[*,*,*], U:b[*,*,*]) to ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    },
    {   U: Ten<bool>(3,1,0)<0,0,0> [] },
    { Dot: Ten<bool>(4,2,3,0)<0,0,0,0> [] })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]}))
Func sig: (T:b[*,*,*], U:b[]) to ({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    },
    {   U: Ten<bool>()<> [true ] },
    { Dot: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*,*], U:b[*]) to ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    },
    {   U: Ten<bool>(3)<0> [true , true , true ] },
    { Dot: Ten<bool>(4,2)<0,0>
          [[false, false]
           [false, false]
           [false, false]
           [false, false]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]}))
Func sig: (T:b[*,*,*], U:b[]) to ({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    },
    {   U: Ten<bool>()<> [false] },
    { Dot: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*,*], U:b[*]) to ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    },
    {   U: Ten<bool>(0)<0> [] },
    { Dot: Ten<bool>(4,2)<0,0>
          [[false, false]
           [false, false]
           [false, false]
           [false, false]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}))
Func sig: (T:b[*,*,*], U:b[*,*,*]) to ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    },
    {   U: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    },
    { Dot: Ten<bool>(4,2,4,3)<0,0,0,0>
          [[[[false, false, false]
             [false, false, false]
             [false, false, false]
             [false, false, false]]

            [[false, false, false]
             [false, false, false]
             [false, false, false]
             [false, false, false]]]


           [[[false, false, false]
             [false, false, false]
             [false, false, false]
             [false, false, false]]

            [[false, false, false]
             [false, false, false]
             [false, false, false]
             [false, false, false]]]


           [[[false, false, false]
             [false, false, false]
             [false, false, false]
             [false, false, false]]

            [[false, false, false]
             [false, false, false]
             [false, false, false]
             [false, false, false]]]


           [[[false, false, false]
             [false, false, false]
             [false, false, false]
             [false, false, false]]

            [[false, false, false]
             [false, false, false]
             [false, false, false]
             [false, false, false]]]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}))
Func sig: (T:b[*,*,*], U:b[*,*,*]) to ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    },
    {   U: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    },
    { Dot: Ten<bool>(4,2,5,6)<0,0,0,0>
          [[[[false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]]

            [[false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]]]


           [[[false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]]

            [[false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]]]


           [[[false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]]

            [[false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]]]


           [[[false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, false, false, false, false]
             [false, false, ...]]]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*,*], U:b[*]) to ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    },
    {   U: Ten<bool>(4)<0> [false, false, false, false] },
    { Dot: Ten<bool>(4,2)<0,0>
          [[false, false]
           [false, false]
           [false, false]
           [false, false]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*,*], U:b[*]) to ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    },
    {   U: Ten<bool>(0)<0> [] },
    { Dot: Ten<bool>(5,3)<0,0>
          [[false, false, false]
           [false, false, false]
           [false, false, false]
           [false, false, false]
           [false, false, false]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*,*], U:b[*]) to ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    },
    {   U: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] },
    { Dot: Ten<bool>(5,3)<0,0>
          [[true , true , true ]
           [true , true , true ]
           [true , true , true ]
           [true , true , true ]
           [true , true , true ]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]}))
Func sig: (T:b[*,*,*], U:b[*,*]) to ({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    },
    {   U: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    },
    { Dot: Ten<bool>(5,3,4)<0,0,1>
          [[[true , false, true , false]
            [true , false, true , false]
            [true , false, true , false]]

           [[true , false, true , false]
            [true , false, true , false]
            [true , false, true , false]]

           [[true , false, true , false]
            [true , false, true , false]
            [true , false, true , false]]

           [[true , false, true , false]
            [true , false, true , false]
            [true , false, true , false]]

           [[true , false, true , false]
            [true , false, true , false]
            [true , false, true , false]]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]}))
Func sig: (T:b[*,*,*], U:b[*,*]) to ({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    },
    {   U: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    },
    { Dot: Ten<bool>(5,3,3)<0,0,1>
          [[[false, false, false]
            [false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]
            [false, false, false]]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}))
Func sig: (T:b[*,*,*], U:b[*,*,*]) to ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    },
    {   U: Ten<bool>(1,0,1)<0,0,0> [] },
    { Dot: Ten<bool>(5,3,1,1)<0,0,0,0>
          [[[[false]]

            [[false]]

            [[false]]]


           [[[false]]

            [[false]]

            [[false]]]


           [[[false]]

            [[false]]

            [[false]]]


           [[[false]]

            [[false]]

            [[false]]]


           [[[false]]

            [[false]]

            [[false]]]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}))
Func sig: (T:b[*,*,*], U:b[*,*,*]) to ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    },
    {   U: Ten<bool>(3,1,0)<0,0,0> [] },
    { Dot: Ten<bool>(5,3,3,0)<0,0,0,0> [] })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]}))
Func sig: (T:b[*,*,*], U:b[]) to ({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    },
    {   U: Ten<bool>()<> [true ] },
    { Dot: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*,*], U:b[*]) to ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    },
    {   U: Ten<bool>(3)<0> [true , true , true ] },
    { Dot: Ten<bool>(5,3)<0,0>
          [[true , true , true ]
           [true , true , true ]
           [true , true , true ]
           [true , true , true ]
           [true , true , true ]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]}))
Func sig: (T:b[*,*,*], U:b[]) to ({'  T':b[*,*,*]}, {'  U':b[]}, {Dot:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    },
    {   U: Ten<bool>()<> [false] },
    { Dot: Ten<bool>(5,3,6)<0,0,0>
          [[[false, false, false, false, false, false]
            [false, false, false, false, false, false]
            [false, false, false, false, false, false]]

           [[false, false, false, false, false, false]
            [false, false, false, false, false, false]
            [false, false, false, false, false, false]]

           [[false, false, false, false, false, false]
            [false, false, false, false, false, false]
            [false, false, false, false, false, false]]

           [[false, false, false, false, false, false]
            [false, false, false, false, false, false]
            [false, false, false, false, false, false]]

           [[false, false, false, false, false, false]
            [false, false, false, false, false, false]
            [false, false, false, false, false, false]]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*,*], U:b[*]) to ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    },
    {   U: Ten<bool>(0)<0> [] },
    { Dot: Ten<bool>(5,3)<0,0>
          [[false, false, false]
           [false, false, false]
           [false, false, false]
           [false, false, false]
           [false, false, false]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}))
Func sig: (T:b[*,*,*], U:b[*,*,*]) to ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    },
    {   U: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    },
    { Dot: Ten<bool>(5,3,4,3)<0,0,0,0>
          [[[[false, false, false]
             [false, false, false]
             [false, false, false]
             [false, false, false]]

            [[false, false, false]
             [false, false, false]
             [false, false, false]
             [false, false, false]]

            [[false, false, false]
             [false, false, false]
             [false, false, false]
             [false, false, false]]]


           [[[false, false, false]
             [false, false, false]
             [false, false, false]
             [false, false, false]]

            [[false, false, false]
             [false, false, false]
             [false, false, false]
             [false, false, false]]

            [[false, false, false]
             [false, false, false]
             [false, false, false]
             [false, false, false]]]


           [[[false, false, false]
             [false, false, false]
             [false, false, false]
             [false, false, false]]

            [[false, false, false]
             [false, false, false]
             [false, false, false]
             [false, false, false]]

            [[false, false, false]
             [false, false, false]
             [false, false, false]
             [false, false, false]]]


           [[[false, false, false]
             [false, false, false]
             [false, false, false]
             [false, false, false]]

            [[false, false, false]
             [false, false, false]
             [false, false, false]
             [false, false, false]]

            [[false, false, false]
             [false, false, false]
             [false, false, false]
             [false, false, false]]]


           [[[false, false, false]
             [false, false, false]
             [false, false, false]
             [false, false, false]]

            [[false, false, false]
             [false, false, false]
             [false, false, false]
             [false, false, false]]

            [[false, false, false]
             [false, false, false]
             [false, false, false]
             [false, false, false]]]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]}))
Func sig: (T:b[*,*,*], U:b[*,*,*]) to ({'  T':b[*,*,*]}, {'  U':b[*,*,*]}, {Dot:b[*,*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    },
    {   U: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    },
    { Dot: Ten<bool>(5,3,5,6)<0,0,0,0>
          [[[[true , true , true , true , true , true ]
             [true , true , true , true , true , true ]
             [true , true , true , true , true , true ]
             [true , true , true , true , true , true ]
             [true , true , true , true , true , true ]]

            [[true , true , true , true , true , true ]
             [true , true , true , true , true , true ]
             [true , true , true , true , true , true ]
             [true , true , true , true , true , true ]
             [true , true , true , true , true , true ]]

            [[true , true , true , true , true , true ]
             [true , true , true , true , true , true ]
             [true , true , true , true , true , true ]
             [true , true , true , true , true , true ]
             [true , true , true , true , true , true ]]]


           [[[true , true , true , true , true , true ]
             [true , true , true , true , true , true ]
             [true , true , true , true , true , true ]
             [true , true , true , true , true , true ]
             [true , true , true , true , true , true ]]

            [[true , true , true , true , true , true ]
             [true , true , true , true , true , true ]
             [true , true , true , true , true , true ]
             [true , true , true , true , true , true ]
             [true , true , true , true , true , true ]]

            [[true , true , true , true , true , true ]
             [true , true , true , true , true , true ]
             [true , true , true , true , true , true ]
             [true , true , true , true , true , true ]
             [true , true , true , true , true , true ]]]


           [[[true , true , true , true , true , true ]
             [true , true , true , true , true , true ]
             [true , true , true , true , true , true ]
             [true , true , ...]]]]
    })
###

**** New definitions: T, type: b[*,*,*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]}))
Func sig: (T:b[*,*,*], U:b[*]) to ({'  T':b[*,*,*]}, {'  U':b[*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    },
    {   U: Ten<bool>(4)<0> [false, false, false, false] },
    { Dot: Ten<bool>(5,3)<0,0>
          [[false, false, false]
           [false, false, false]
           [false, false, false]
           [false, false, false]
           [false, false, false]]
    })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[])}):({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}))
Func sig: (T:b[*], U:b[*]) to ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4)<0> [false, false, false, false] },
    {   U: Ten<bool>(0)<0> [] },
    { Dot: Ten<bool>()<> [false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[])}):({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}))
Func sig: (T:b[*], U:b[*]) to ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4)<0> [false, false, false, false] },
    {   U: Ten<bool>(12)<1> [true , false, true , false, true , false, true , false, true , false, true , false] },
    { Dot: Ten<bool>()<> [false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*])}):({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]}))
Func sig: (T:b[*], U:b[*,*]) to ({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4)<0> [false, false, false, false] },
    {   U: Ten<bool>(3,4)<4,1>
          [[true , false, true , false]
           [true , false, true , false]
           [true , false, true , false]]
    },
    { Dot: Ten<bool>(4)<0> [false, false, false, false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*])}):({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]}))
Func sig: (T:b[*], U:b[*,*]) to ({'  T':b[*]}, {'  U':b[*,*]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4)<0> [false, false, false, false] },
    {   U: Ten<bool>(4,3)<3,1>
          [[true , false, true ]
           [false, true , false]
           [true , false, true ]
           [false, true , false]]
    },
    { Dot: Ten<bool>(3)<0> [false, false, false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[*], U:b[*,*,*]) to ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4)<0> [false, false, false, false] },
    {   U: Ten<bool>(1,0,1)<0,0,0> [] },
    { Dot: Ten<bool>(1,1)<0,0>
          [[false]]
    })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[*], U:b[*,*,*]) to ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4)<0> [false, false, false, false] },
    {   U: Ten<bool>(3,1,0)<0,0,0> [] },
    { Dot: Ten<bool>(3,0)<0,0> [] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*])}):({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]}))
Func sig: (T:b[*], U:b[]) to ({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4)<0> [false, false, false, false] },
    {   U: Ten<bool>()<> [true ] },
    { Dot: Ten<bool>(4)<0> [false, false, false, false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[])}):({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}))
Func sig: (T:b[*], U:b[*]) to ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4)<0> [false, false, false, false] },
    {   U: Ten<bool>(3)<0> [true , true , true ] },
    { Dot: Ten<bool>()<> [false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*])}):({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]}))
Func sig: (T:b[*], U:b[]) to ({'  T':b[*]}, {'  U':b[]}, {Dot:b[*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4)<0> [false, false, false, false] },
    {   U: Ten<bool>()<> [false] },
    { Dot: Ten<bool>(4)<0> [false, false, false, false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[])}):({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}))
Func sig: (T:b[*], U:b[*]) to ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4)<0> [false, false, false, false] },
    {   U: Ten<bool>(0)<0> [] },
    { Dot: Ten<bool>()<> [false] })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[*], U:b[*,*,*]) to ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4)<0> [false, false, false, false] },
    {   U: Ten<bool>(4,2,3)<0,0,0>
          [[[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]

           [[false, false, false]
            [false, false, false]]]
    },
    { Dot: Ten<bool>(4,3)<0,0>
          [[false, false, false]
           [false, false, false]
           [false, false, false]
           [false, false, false]]
    })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[*,*])}):({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]}))
Func sig: (T:b[*], U:b[*,*,*]) to ({'  T':b[*]}, {'  U':b[*,*,*]}, {Dot:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4)<0> [false, false, false, false] },
    {   U: Ten<bool>(5,3,6)<0,0,0>
          [[[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]

           [[true , true , true , true , true , true ]
            [true , true , true , true , true , true ]
            [true , true , true , true , true , true ]]]
    },
    { Dot: Ten<bool>(5,6)<0,0>
          [[false, false, false, false, false, false]
           [false, false, false, false, false, false]
           [false, false, false, false, false, false]
           [false, false, false, false, false, false]
           [false, false, false, false, false, false]]
    })
###

**** New definitions: T, type: b[*]
**** New definitions: U, type: b[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
BndKind:Tuple, Type:({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):b[])}):({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]}))
Func sig: (T:b[*], U:b[*]) to ({'  T':b[*]}, {'  U':b[*]}, {Dot:b[]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(4)<0> [false, false, false, false] },
    {   U: Ten<bool>(4)<0> [false, false, false, false] },
    { Dot: Ten<bool>()<> [false] })
###
