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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

           [[false, true ]
            [true , true ]]]
    },
    { Max: Ten<bool>(3,2,2)<4,2,1>
          [[[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 }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':b[*,*]}, {'  U':b[*]}, {Add:b[*,*]}, {Sub:b[*,*]}, {Mul:b[*,*]}, {Div:b[*,*]}, {Min:b[*,*]}, {Max:b[*,*]})
BndKind:Tuple, Type:({'  T':b[*,*]}, {'  U':b[*]}, {Add:b[*,*]}, {Sub:b[*,*]}, {Mul:b[*,*]}, {Div:b[*,*]}, {Min:b[*,*]}, {Max:b[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):b[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):b[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):b[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):b[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):b[*,*])}):({'  T':b[*,*]}, {'  U':b[*]}, {Add:b[*,*]}, {Sub:b[*,*]}, {Mul:b[*,*]}, {Div:b[*,*]}, {Min:b[*,*]}, {Max:b[*,*]}))
Func sig: (T:b[*,*], U:b[*]) to ({'  T':b[*,*]}, {'  U':b[*]}, {Add:b[*,*]}, {Sub:b[*,*]}, {Mul:b[*,*]}, {Div:b[*,*]}, {Min:b[*,*]}, {Max:b[*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>},{Ten<bool>},{Ten<bool>},{Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(2,2)<0,0>
          [[true , true ]
           [true , true ]]
    },
    {   U: Ten<bool>(0)<0> [] },
    { Add: Ten<bool>(2,0)<0,0> [] },
    { Sub: Ten<bool>(2,0)<0,0> [] },
    { Mul: Ten<bool>(2,0)<0,0> [] },
    { Div: Ten<bool>(2,0)<0,0> [] },
    { Min: Ten<bool>(2,0)<0,0> [] },
    { Max: Ten<bool>(2,0)<0,0> [] })
###

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

           [[false, true ]
            [true , true ]]]
    },
    { Max: Ten<bool>(3,2,2)<4,2,1>
          [[[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 }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Add:b[*,*,*]}, {Sub:b[*,*,*]}, {Mul:b[*,*,*]}, {Div:b[*,*,*]}, {Min:b[*,*,*]}, {Max:b[*,*,*]})
BndKind:Tuple, Type:({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Add:b[*,*,*]}, {Sub:b[*,*,*]}, {Mul:b[*,*,*]}, {Div:b[*,*,*]}, {Min:b[*,*,*]}, {Max:b[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):b[*,*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):b[*,*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):b[*,*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):b[*,*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):b[*,*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):b[*,*,*])}):({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Add:b[*,*,*]}, {Sub:b[*,*,*]}, {Mul:b[*,*,*]}, {Div:b[*,*,*]}, {Min:b[*,*,*]}, {Max:b[*,*,*]}))
Func sig: (T:b[*,*,*], U:b[*,*]) to ({'  T':b[*,*,*]}, {'  U':b[*,*]}, {Add:b[*,*,*]}, {Sub:b[*,*,*]}, {Mul:b[*,*,*]}, {Div:b[*,*,*]}, {Min:b[*,*,*]}, {Max:b[*,*,*]})
Type: ({Ten<bool>},{Ten<bool>},{Ten<bool>},{Ten<bool>},{Ten<bool>},{Ten<bool>},{Ten<bool>},{Ten<bool>}), Value: (
    {   T: Ten<bool>(3,2,2)<4,2,1>
          [[[false, false]
            [false, true ]]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

           [[false, true ]
            [true , true ]]]
    },
    {   U: Ten<bool>(0)<0> [] },
    { Add: Ten<bool>(3,2,0)<0,0,0> [] },
    { Sub: Ten<bool>(3,2,0)<0,0,0> [] },
    { Mul: Ten<bool>(3,2,0)<0,0,0> [] },
    { Div: Ten<bool>(3,2,0)<0,0,0> [] },
    { Min: Ten<bool>(3,2,0)<0,0,0> [] },
    { Max: Ten<bool>(3,2,0)<0,0,0> [] })
###

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

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

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

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

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

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

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

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

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

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

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

           [[false, true ]
            [true , true ]]]
    },
    { Add: Ten<bool>(3,2,0)<0,0,0> [] },
    { Sub: Ten<bool>(3,2,0)<0,0,0> [] },
    { Mul: Ten<bool>(3,2,0)<0,0,0> [] },
    { Div: Ten<bool>(3,2,0)<0,0,0> [] },
    { Min: Ten<bool>(3,2,0)<0,0,0> [] },
    { Max: Ten<bool>(3,2,0)<0,0,0> [] })
###

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

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