Latest version 30-4-2026 ...

janhardo — Thu, 30 Apr 2026 21:29:12 Z

Latest version 30-4-2026

restart;

KroneckerRules := module()
    option package;
    export Kron, `&x`, Simplify, SimplifyTrace, Expand, Shuffle,
           NumericEvaluate, SetDim, GetDim, Dim, ToggleKronNotation,
           TestRandom, TestUser, QuickRef, HelpRule, Info,
           ProveIdentity, ProveIdentityMatrix,
           IdentityMatrix, ZeroMatrix, Canonicalize;

    # ---------- Inerte notatie ----------
    Kron := (A,B) -> 'KroneckerProduct'(A,B):
    `&x` := (A,B) -> 'KroneckerProduct'(A,B):
    Dim := (M) -> 'Dim'(M):
    IdentityMatrix := (n) -> 'IdentityMatrix'(n):
    ZeroMatrix := (m,n) -> 'ZeroMatrix'(m,n):

    # ---------- Tabel voor symbolische afmetingen ----------
    local _dim_table := table();

    SetDim := proc(M, r, c)
        if M = I then
            error "The symbol I is reserved for the imaginary unit. Please use another name (e.g., I_mat).";
        end if;
        _dim_table[M] := [r, c];
        printf("Dimensions set: %a = [%a, %a]\n", M, r, c);
    end proc;

    GetDim := proc(M, i)
        if assigned(_dim_table[M]) then
            return _dim_table[M][i];
        else
            return 'Dim'(M, i);
        end if;
    end proc;

    # ---------- Dimensie helpers (met memoization) ----------
    local _get_dims := proc(expr) option remember;
        local r, c;
        if type(expr, Matrix) then
            r := LinearAlgebra:-RowDimension(expr);
            c := LinearAlgebra:-ColumnDimension(expr);
            return [r, c];
        elif type(expr, symbol) then
            r := GetDim(expr, 1);
            c := GetDim(expr, 2);
            return [r, c];
        elif type(expr, specfunc(KroneckerProduct)) then
            local dimA := _get_dims(op(1,expr));
            local dimB := _get_dims(op(2,expr));
            r := dimA[1] * dimB[1];
            c := dimA[2] * dimB[2];
            return [r, c];
        elif type(expr, `.`) then
            local dimA := _get_dims(op(1,expr));
            local dimB := _get_dims(op(2,expr));
            r := dimA[1];
            c := dimB[2];
            return [r, c];
        elif type(expr, `+`) then
            if nops([op(expr)]) > 0 then
                return _get_dims(op(1,expr));
            end if;
        elif type(expr, `*`) and type(op(1,expr), numeric) then
            return _get_dims(op(2,expr));
        elif type(expr, specfunc(Transpose)) then
            local dimA := _get_dims(op(1,expr));
            return [dimA[2], dimA[1]];
        elif type(expr, specfunc(HermitianTranspose)) then
            local dimA := _get_dims(op(1,expr));
            return [dimA[2], dimA[1]];
        elif type(expr, specfunc(IdentityMatrix)) then
            r := op(1,expr); c := op(1,expr);
            return [r, c];
        elif type(expr, specfunc(ZeroMatrix)) then
            r := op(1,expr); c := op(2,expr);
            return [r, c];
        end if;
        return ['Dim'(expr,1), 'Dim'(expr,2)];
    end proc;

    local _check_mult := proc(dim1, dim2, expr1, expr2)
        if dim1 = dim2 then return true; end if;
        if type(dim1, numeric) and type(dim2, numeric) then
            error "Dimension mismatch: columns of %a (%a) ≠ rows of %a (%a) in product %a · %a",
                  expr1, dim1, expr2, dim2, expr1, expr2;
        else
            printf("Warning: in product %a · %a: cannot verify compatibility (%a vs %a) – assuming correctness.\n",
                   expr1, expr2, dim1, dim2);
            return true;
        end if;
    end proc;

    local _check_expression_dims := proc(expr)
        subsindets(expr, `.`, proc(p)
            local B;
            local A := op(1,p); B := op(2,p);
            local dimA := _get_dims(eval(A));
            local dimB := _get_dims(eval(B));
            if dimA[2] <> dimB[1] then
                error "Dimension mismatch: columns of %a (%a) ≠ rows of %a (%a) in product %a · %a",
                      A, dimA[2], B, dimB[1], A, B;
            end if;
        end proc);
    end proc;

    # ---------- Trace mechanism ----------
    local _trace_steps := [];
    local _rule_desc := table([
        "KRON7 (chain)" = "(A5B)·(C5D) → (A·C)5(B·D)",
        "KRON7 (mixed)" = "A·(X5Y)·B → (A·X)5(Y·B)",
        "Dot left-distribution" = "X·(Y+Z) → X·Y + X·Z",
        "Dot right-distribution" = "(X+Y)·Z → X·Z + Y·Z",
        "KRON5" = "(X+Y)5Z → X5Z + Y5Z",
        "KRON6" = "X5(Y+Z) → X5Y + X5Z",
        "KRON1 (scalar left)" = "(c·A)5B → c·(A5B)",
        "KRON1 (scalar right)" = "A5(c·B) → c·(A5B)",
        "KRON2" = "(A5B)^T → A^T 5 B^T",
        "KRON3" = "(A5B)^H → A^H 5 B^H",
        "KRON4" = "(A5B)5C → A5(B5C)",
        "KRON8" = "Tr(A5B) → Tr(A)·Tr(B)",
        "KRON9" = "det(A5B) → det(A)^(Dim B) · det(B)^(Dim A)",
        "KRON10" = "(A5B)^(-1) → A^(-1) 5 B^(-1)",
        "Transpose over sum" = "(A+B)^T → A^T + B^T",
        "HermitianTranspose over sum" = "(A+B)^H → A^H + B^H",
        "conjugate over sum" = "conjugate(A+B) → conjugate(A)+conjugate(B)",
        "conjugate over product" = "conjugate(A·B) → conjugate(A)·conjugate(B)",
        "Trace linearity" = "Tr(A+B) → Tr(A)+Tr(B)",
        "Inverse of Shuffle" = "Shuffle(A,B)^(-1) → Shuffle(A^(-1), B^(-1))",
        "Trace(Shuffle)" = "Tr(Shuffle(A,B)) → Tr(A)·Tr(B)",
        "Double HermitianTranspose" = "HermitianTranspose(HermitianTranspose(X)) → X",
        "Double Transpose" = "Transpose(Transpose(X)) → X",
        "Dim of Kron" = "Dim(A5B) → Dim(A) * Dim(B)",
        "Dim of scalar product" = "Dim(c·A) → Dim(A)",
        "Dim of sum" = "Dim(A+B) → Dim(A) (mits afmetingen gelijk)",
        "Dim of Identity" = "Dim(I_n) → n",
        "Dim of Zero" = "Dim(ZeroMatrix(m,n)) → m",
        "MatrixInverse of product" = "(A·B)^(-1) → B^(-1)·A^(-1)",
        "Identity matrix multiplication" = "I_n · A = A, A · I_n = A",
        "Identity matrix Kronecker" = "I_m 5 I_n → I_{m*n}",
        "Zero matrix propagation" = "0·A = 0, A·0 = 0, 05A = 0, A50 = 0",
        "Trace of product" = "Tr(A·B) → Tr(B·A)",
        "Determinant of product" = "det(A·B) → det(A)·det(B)",
        "Shuffle chain" = "Shuffle(Shuffle(A,B),C) → Shuffle(A,Shuffle(B,C))"
    ]);

    local _AddTrace := proc(rule, from_expr, to_expr)
        local desc;
        desc := _rule_desc[rule];
        if desc = NULL then desc := rule; end if;
        _trace_steps := [op(_trace_steps),
            sprintf("%s (%s): %a -> %a", rule, desc, from_expr, to_expr)];
    end proc;

    # ---------- Perfect shuffle matrix ----------
    local _PerfectShuffleMatrix := proc(p::posint, r::posint)
        local M, i, j;
        M := Matrix(p*r, p*r, 0);
        for i from 1 to p do
            for j from 1 to r do
                M[(j-1)*p + i, (i-1)*r + j] := 1;
            end do;
        end do;
        return M;
    end proc;

    # ---------- Distribute dot over sums ----------
    local _DistributeDot := proc(expr, with_trace::boolean := false)
        local e, changed;
        e := expr;
        changed := true;
        while changed do
            changed := false;
            e := subsindets(e, `.`, proc(p)
                local a,b,terms,res,t;
                a := op(1,p); b := op(2,p);
                if type(a, `+`) then
                    changed := true;
                    terms := [op(a)];
                    res := `+`(seq(t . b, t in terms));
                    if with_trace then _AddTrace("Dot left-distribution", p, res); end if;
                    return res;
                elif type(b, `+`) then
                    changed := true;
                    terms := [op(b)];
                    res := `+`(seq(a . t, t in terms));
                    if with_trace then _AddTrace("Dot right-distribution", p, res); end if;
                    return res;
                else
                    return p;
                end if;
            end proc);
        end do;
        return e;
    end proc;

    # ---------- Combine consecutive Kronecker products (pure and mixed) ----------
    local _FlattenChain := proc(expr, with_trace::boolean := false)
        local e, changed;
        e := expr;
        changed := true;
        while changed do
            changed := false;
            # Regel 1: pure Kronecker chain in dot: (A5B)·(C5D) -> (A·C)5(B·D)
            e := subsindets(e, `.`, proc(p)
                local ops, all_kron, left, right, i, to_pair;
                ops := [op(p)];
                all_kron := true;
                for i in ops do
                    if not type(i, specfunc(KroneckerProduct)) then
                        all_kron := false;
                        break;
                    end if;
                end do;
                if all_kron and nops(ops) >= 2 then
                    left := op(1, ops[1]);
                    right := op(2, ops[1]);
                    for i from 2 to nops(ops) do
                        left := left . op(1, ops[i]);
                        right := right . op(2, ops[i]);
                    end do;
                    to_pair := Kron(left, right);
                    if with_trace then _AddTrace("KRON7 (chain)", p, to_pair); end if;
                    changed := true;
                    return to_pair;
                else
                    return p;
                end if;
            end proc);
            # Regel 2: gemengd geval A·(X5Y)·B -> (A·X)5(Y·B)
            e := subsindets(e, `.`, proc(p)
                local ops, n;
                ops := [op(p)];
                n := nops(ops);
                if n = 3 and type(ops[2], specfunc(KroneckerProduct)) then
                    local A, X, Y, B;
                    A := ops[1];
                    X := op(1, ops[2]);
                    Y := op(2, ops[2]);
                    B := ops[3];
                    local new_expr := Kron(A . X, Y . B);
                    if with_trace then _AddTrace("KRON7 (mixed)", p, new_expr); end if;
                    changed := true;
                    return new_expr;
                else
                    return p;
                end if;
            end proc);
        end do;
        return e;
    end proc;

    # ---------- Simplify Dim met dimensiecontrole voor som ----------
    local _SimplifyDim := proc(expr, with_trace::boolean := false)
        local e, changed;
        e := expr;
        changed := true;
        while changed do
            changed := false;
            e := subsindets(e, specfunc(Dim), proc(d)
                local arg, new_d;
                arg := op(1, d);
                if type(arg, specfunc(KroneckerProduct)) then
                    new_d := Dim(op(1,arg)) * Dim(op(2,arg));
                    if with_trace then _AddTrace("Dim of Kron", d, new_d); end if;
                    changed := true;
                    return new_d;
                elif type(arg, `*`) and type(op(1,arg), numeric) then
                    new_d := Dim(op(2,arg));
                    if with_trace then _AddTrace("Dim of scalar product", d, new_d); end if;
                    changed := true;
                    return new_d;
                elif type(arg, `+`) then
                    local terms := [op(arg)];
                    if nops(terms) = 0 then return d; end if;
                    local first_dim := Dim(terms[1]);
                    local all_same := true;
                    for local t in terms[2..-1] do
                        if not evalb(Dim(t) = first_dim) then
                            all_same := false;
                            break;
                        end if;
                    end do;
                    if all_same then
                        new_d := first_dim;
                        if with_trace then _AddTrace("Dim of sum", d, new_d); end if;
                        changed := true;
                        return new_d;
                    else
                        printf("Warning: Dim(%a) cannot be simplified because terms have different dimensions.\n", arg);
                        return d;
                    end if;
                elif type(arg, specfunc(IdentityMatrix)) then
                    new_d := op(1,arg);
                    if with_trace then _AddTrace("Dim of Identity", d, new_d); end if;
                    changed := true;
                    return new_d;
                elif type(arg, specfunc(ZeroMatrix)) then
                    new_d := op(1,arg);
                    if with_trace then _AddTrace("Dim of Zero", d, new_d); end if;
                    changed := true;
                    return new_d;
                end if;
                return d;
            end proc);
        end do;
        return e;
    end proc;

    # ---------- Vereenvoudig machten van identiteitsmatrix ----------
    local _SimplifyIdentityPower := proc(expr, with_trace)
        local e;
        e := expr;
        e := subsindets(e, `^`, proc(p)
            if type(op(1,p), specfunc(IdentityMatrix)) then
                if with_trace then _AddTrace("Identity matrix power", p, op(1,p)); end if;
                return op(1,p);
            end if;
            return p;
        end proc);
        return e;
    end proc;

    # ---------- Som met nulmatrix -> verwijder nulmatrix termen ----------
    local _SimplifyZeroSum := proc(expr, with_trace)
        local e, t;
        e := expr;
        e := subsindets(e, `+`, proc(s)
            local terms := [op(s)];
            local new_terms := [];
            for t in terms do
                if not type(t, specfunc(ZeroMatrix)) then
                    new_terms := [op(new_terms), t];
                else
                    if with_trace then _AddTrace("Zero matrix sum removal", s, `+`(op(new_terms))); end if;
                end if;
            end do;
            if nops(new_terms) = 0 then
                return ZeroMatrix(1,1);
            elif nops(new_terms) = 1 then
                return new_terms[1];
            else
                return `+`(op(new_terms));
            end if;
        end proc);
        return e;
    end proc;

    # ---------- Identiteits- en nulmatrix in producten en Kronecker ----------
    local _SimplifyIdentityZero := proc(expr, with_trace)
        local e;
        e := expr;
        # I * A via *
        e := subsindets(e, `*`, proc(p)
            local lst, i, other, count_id;
            lst := [op(p)];
            count_id := 0;
            other := 1;
            for i in lst do
                if type(i, specfunc(IdentityMatrix)) then
                    count_id := count_id + 1;
                else
                    other := other * i;
                end if;
            end do;
            if count_id > 0 then
                if other = 1 then
                    return IdentityMatrix(op(1,select(type, lst, specfunc(IdentityMatrix))[1]));
                else
                    return other;
                end if;
            end if;
            return p;
        end proc);
        # I . A via .
        e := subsindets(e, `.`, proc(p)
            local a,b;
            a := op(1,p); b := op(2,p);
            if type(a, specfunc(IdentityMatrix)) then
                if type(b, specfunc(IdentityMatrix)) then
                    return a;   # I.I = I
                else
                    return b;
                end if;
            elif type(b, specfunc(IdentityMatrix)) then
                return a;
            else
                return p;
            end if;
        end proc);
        # Nulmatrix via *
        e := subsindets(e, `*`, proc(p)
            local lst, i;
            lst := [op(p)];
            for i in lst do
                if type(i, specfunc(ZeroMatrix)) then
                    return i;
                end if;
            end do;
            return p;
        end proc);
        # Nulmatrix via .
        e := subsindets(e, `.`, proc(p)
            local a,b;
            a := op(1,p); b := op(2,p);
            if type(a, specfunc(ZeroMatrix)) then return a;
            elif type(b, specfunc(ZeroMatrix)) then return b;
            else return p; end if;
        end proc);
        # I_m 5 I_n -> I_{m*n}
        e := subsindets(e, specfunc(KroneckerProduct), proc(k)
            local a := eval(op(1,k));
            local b := eval(op(2,k));
            if type(a, specfunc(IdentityMatrix)) and type(b, specfunc(IdentityMatrix)) then
                return IdentityMatrix(op(1,a)*op(1,b));
            end if;
            return k;
        end proc);
        # 05A en A50 -> nulmatrix
        e := subsindets(e, specfunc(KroneckerProduct), proc(k)
            local a,b;
            a := op(1,k); b := op(2,k);
            if type(a, specfunc(ZeroMatrix)) then
                local dimB := _get_dims(b);
                return ZeroMatrix(dimB[1]*op(1,a), dimB[2]*op(2,a));
            elif type(b, specfunc(ZeroMatrix)) then
                local dimA := _get_dims(a);
                return ZeroMatrix(dimA[1]*op(1,b), dimA[2]*op(2,b));
            end if;
            return k;
        end proc);
        return e;
    end proc;

    # ---------- Trace van product (canonieke volgorde om oscillatie te voorkomen) ----------
    local _SimplifyTraceProduct := proc(expr, with_trace)
        local e;
        e := expr;
        e := subsindets(e, specfunc(Trace), proc(t)
            local arg := op(1,t);
            if type(arg, `.`) and nops([op(arg)])=2 then
                local A := op(1,arg); local B := op(2,arg);
                local a_str := convert(A, string);
                local b_str := convert(B, string);
                if a_str > b_str then
                    local swapped := Trace(B . A);
                    if with_trace then _AddTrace("Trace of product (swap)", t, swapped); end if;
                    return swapped;
                end if;
            end if;
            return t;
        end proc);
        return e;
    end proc;

    # ---------- Determinant van product ----------
    local _SimplifyDetProduct := proc(expr, with_trace)
        local e;
        e := expr;
        e := subsindets(e, specfunc(Determinant), proc(d)
            local arg := op(1,d);
            if type(arg, `.`) and nops([op(arg)])=2 then
                local A := op(1,arg); local B := op(2,arg);
                local prod := Determinant(A)*Determinant(B);
                if with_trace then _AddTrace("Determinant of product", d, prod); end if;
                return prod;
            end if;
            return d;
        end proc);
        return e;
    end proc;

    # ---------- Shuffle ketens ----------
    local _SimplifyShuffleChain := proc(expr, with_trace)
        local e;
        e := expr;
        e := subsindets(e, specfunc(Shuffle), proc(s)
            local A,B;
            A := op(1,s); B := op(2,s);
            if type(A, specfunc(Shuffle)) then
                local X := op(1,A); local Y := op(2,A);
                return Shuffle(X, Shuffle(Y, B));
            end if;
            return s;
        end proc);
        return e;
    end proc;

    # ---------- Canonieke ordening (lexicografisch) ----------
    Canonicalize := proc(expr, {order::string:="lex"})
        local e, sort_args;
        sort_args := proc(a,b)
            if order="lex" then return convert(a,string) <= convert(b,string);
            else return a <= b; end if;
        end proc;
        e := subsindets(expr, specfunc(KroneckerProduct), proc(k)
            local a,b;
            a := op(1,k); b := op(2,k);
            if type(a, symbol) and type(b, symbol) then
                if not sort_args(a,b) then return Kron(b,a); end if;
            end if;
            return k;
        end proc);
        return e;
    end proc;

    # ---------- Unified simplification engine (phased, deterministic) ----------
    local _Rewrite := proc(expr, with_trace::boolean := false)
        local e, e_old, changed, sub, a, b, terms, term, new_sub;
        e := expr;
        changed := true;
        while changed do
            e_old := e;

            # Fase 1: distributie van . over +
            e := _DistributeDot(e, with_trace);

            # Fase 2: flatten Kronecker (associativiteit) en combineer in .
            e := _FlattenChain(e, with_trace);

            # Fase 3: scalars uit Kronecker halen
            for sub in indets(e, specfunc(KroneckerProduct)) do
                a := op(1,sub); b := op(2,sub);
                new_sub := sub;
                if type(a, `*`) and type(op(1,a), numeric) then
                    new_sub := op(1,a) * Kron(op(2,a), b);
                    if with_trace then _AddTrace("KRON1 (scalar left)", sub, new_sub); end if;
                elif type(b, `*`) and type(op(1,b), numeric) then
                    new_sub := op(1,b) * Kron(a, op(2,b));
                    if with_trace then _AddTrace("KRON1 (scalar right)", sub, new_sub); end if;
                end if;
                if new_sub <> sub then e := subs(sub = new_sub, e); end if;
            end do;

            # Fase 4: Transpose/Hermitian/conjugate over som en naar binnen in Kron
            for sub in indets(e, specfunc(Transpose)) do
                a := op(1,sub);
                if type(a, `+`) then
                    terms := [op(a)];
                    new_sub := `+`(seq(Transpose(term), term in terms));
                    if with_trace then _AddTrace("Transpose over sum", sub, new_sub); end if;
                    e := subs(sub = new_sub, e);
                elif type(a, specfunc(KroneckerProduct)) then
                    new_sub := Kron(Transpose(op(1,a)), Transpose(op(2,a)));
                    if with_trace then _AddTrace("KRON2", sub, new_sub); end if;
                    e := subs(sub = new_sub, e);
                elif type(a, specfunc(Transpose)) then
                    new_sub := op(1, a);
                    if with_trace then _AddTrace("Double Transpose", sub, new_sub); end if;
                    e := subs(sub = new_sub, e);
                end if;
            end do;

            for sub in indets(e, specfunc(HermitianTranspose)) do
                a := op(1,sub);
                if type(a, `+`) then
                    terms := [op(a)];
                    new_sub := `+`(seq(HermitianTranspose(term), term in terms));
                    if with_trace then _AddTrace("HermitianTranspose over sum", sub, new_sub); end if;
                    e := subs(sub = new_sub, e);
                elif type(a, specfunc(KroneckerProduct)) then
                    new_sub := Kron(HermitianTranspose(op(1,a)), HermitianTranspose(op(2,a)));
                    if with_trace then _AddTrace("KRON3", sub, new_sub); end if;
                    e := subs(sub = new_sub, e);
                elif type(a, specfunc(HermitianTranspose)) then
                    new_sub := op(1, a);
                    if with_trace then _AddTrace("Double HermitianTranspose", sub, new_sub); end if;
                    e := subs(sub = new_sub, e);
                end if;
            end do;

            for sub in indets(e, specfunc(conjugate)) do
                a := op(1,sub);
                if type(a, `+`) then
                    terms := [op(a)];
                    new_sub := `+`(seq(conjugate(term), term in terms));
                    if with_trace then _AddTrace("conjugate over sum", sub, new_sub); end if;
                    e := subs(sub = new_sub, e);
                elif type(a, `.`) then
                    new_sub := conjugate(op(1,a)) . conjugate(op(2,a));
                    if with_trace then _AddTrace("conjugate over product", sub, new_sub); end if;
                    e := subs(sub = new_sub, e);
                elif type(a, specfunc(KroneckerProduct)) then
                    new_sub := Kron(conjugate(op(1,a)), conjugate(op(2,a)));
                    if with_trace then _AddTrace("conjugate over KroneckerProduct", sub, new_sub); end if;
                    e := subs(sub = new_sub, e);
                end if;
            end do;

            # Fase 5: Trace, Determinant, Inverse, Dim, plus nieuwe regels
            for sub in indets(e, specfunc(Trace)) do
                a := op(1,sub);
                if type(a, specfunc(KroneckerProduct)) then
                    new_sub := Trace(op(1,a)) * Trace(op(2,a));
                    if with_trace then _AddTrace("KRON8", sub, new_sub); end if;
                    e := subs(sub = new_sub, e);
                elif type(a, `+`) then
                    terms := [op(a)];
                    new_sub := `+`(seq(Trace(term), term in terms));
                    if with_trace then _AddTrace("Trace linearity", sub, new_sub); end if;
                    e := subs(sub = new_sub, e);
                elif type(a, specfunc(Shuffle)) then
                    new_sub := Trace(op(1,a)) * Trace(op(2,a));
                    if with_trace then _AddTrace("Trace(Shuffle)", sub, new_sub); end if;
                    e := subs(sub = new_sub, e);
                end if;
            end do;
            e := _SimplifyTraceProduct(e, with_trace);

            for sub in indets(e, specfunc(Determinant)) do
                a := op(1,sub);
                if type(a, specfunc(KroneckerProduct)) then
                    new_sub := Determinant(op(1,a)) ^ Dim(op(2,a)) * Determinant(op(2,a)) ^ Dim(op(1,a));
                    if with_trace then _AddTrace("KRON9", sub, new_sub); end if;
                    e := subs(sub = new_sub, e);
                end if;
            end do;
            e := _SimplifyDetProduct(e, with_trace);

            for sub in indets(e, specfunc(MatrixInverse)) do
                a := op(1,sub);
                if type(a, specfunc(KroneckerProduct)) then
                    new_sub := Kron(MatrixInverse(op(1,a)), MatrixInverse(op(2,a)));
                    if with_trace then _AddTrace("KRON10", sub, new_sub); end if;
                    e := subs(sub = new_sub, e);
                elif type(a, specfunc(Shuffle)) then
                    new_sub := Shuffle(MatrixInverse(op(1,a)), MatrixInverse(op(2,a)));
                    if with_trace then _AddTrace("Inverse of Shuffle", sub, new_sub); end if;
                    e := subs(sub = new_sub, e);
                elif type(a, `.`) then
                    new_sub := MatrixInverse(op(2,a)) . MatrixInverse(op(1,a));
                    if with_trace then _AddTrace("MatrixInverse of product", sub, new_sub); end if;
                    e := subs(sub = new_sub, e);
                end if;
            end do;

            # Fase 6: Dim vereenvoudiging (met check voor som)
            e := _SimplifyDim(e, with_trace);

            # Fase 7: Identiteitsmacht, identiteits-/nulmatrix, som-nul
            e := _SimplifyIdentityPower(e, with_trace);
            e := _SimplifyIdentityZero(e, with_trace);
            e := _SimplifyZeroSum(e, with_trace);

            # Fase 8: Shuffle ketens
            e := _SimplifyShuffleChain(e, with_trace);

            # Fase 9: distributie van Kron over som (KRON5,6)
            for sub in indets(e, specfunc(KroneckerProduct)) do
                a := op(1,sub); b := op(2,sub);
                new_sub := sub;
                if type(a, `+`) then
                    terms := [op(a)];
                    new_sub := `+`(seq(Kron(term, b), term in terms));
                    if with_trace then _AddTrace("KRON5", sub, new_sub); end if;
                elif type(b, `+`) then
                    terms := [op(b)];
                    new_sub := `+`(seq(Kron(a, term), term in terms));
                    if with_trace then _AddTrace("KRON6", sub, new_sub); end if;
                end if;
                if new_sub <> sub then e := subs(sub = new_sub, e); end if;
            end do;

            # Fase 10: associativiteit van Kron (KRON4)
            for sub in indets(e, specfunc(KroneckerProduct)) do
                a := op(1,sub); b := op(2,sub);
                if type(a, specfunc(KroneckerProduct)) then
                    new_sub := Kron(op(1,a), Kron(op(2,a), b));
                    if with_trace then _AddTrace("KRON4", sub, new_sub); end if;
                    e := subs(sub = new_sub, e);
                end if;
            end do;

            if e = e_old then changed := false; end if;
        end do;
        return e;
    end proc;

    # ---------- Simplify (gebruikt de engine, zonder trace output) ----------
    Simplify := proc(expr, maxiter::integer := 50, outputstyle::string := "default")
        local new, old, i, e;
        new := expr;
        for i from 1 to maxiter do
            old := new;
            new := _Rewrite(new, false);
            if new = old then break; end if;
        end do;
        e := new;
        if outputstyle = "Kron" then
            e := subsindets(e, specfunc(KroneckerProduct), k -> 'Kron'(op(k)));
        end if;
        return e;
    end proc;

    # ---------- SimplifyTrace (met trace output) ----------
    SimplifyTrace := proc(expr, maxiter::integer := 50, outputstyle::string := "default")
        local new, old, i, step, cnt, e;
        _trace_steps := [];
        new := expr;
        for i from 1 to maxiter do
            old := new;
            _trace_steps := [];
            new := _Rewrite(new, true);
            if new = old then
                printf("No more rules apply after iteration %d.\n", i-1);
                break;
            end if;
            printf("Iteration %d:\n", i);
            cnt := 0;
            for step in _trace_steps do
                cnt := cnt+1;
                if outputstyle = "Kron" then
                    step := StringTools:-SubstituteAll(step, "KroneckerProduct", "Kron");
                end if;
                printf(" %d. %s\n", cnt, step);
            end do;
            printf("Result after iteration %d: %a\n\n", i, new);
        end do;
        e := new;
        if outputstyle = "Kron" then
            e := subsindets(e, specfunc(KroneckerProduct), k -> 'Kron'(op(k)));
        end if;
        printf("--- Final simplified expression ---\n");
        return e;
    end proc;

    # ---------- Toggle output notation ----------
    ToggleKronNotation := proc()
        global `print/KroneckerProduct`;
        if assigned(`print/KroneckerProduct`) then
            unassign(`print/KroneckerProduct`);
            printf("KroneckerProduct output notation set to DEFAULT (KroneckerProduct(A,B))\n");
        else
            `print/KroneckerProduct` := (A,B) -> 'Kron'(A,B);
            printf("KroneckerProduct output notation set to PRETTY (Kron(A,B))\n");
        end if;
    end proc;

    # ---------- Expand ----------
    local _ExpandKron := proc(expr)
        local a, b, new_a, new_b, term;
        if not type(expr, specfunc(KroneckerProduct)) then
            return expr;
        end if;
        a := op(1, expr);
        b := op(2, expr);
        new_a := _ExpandKron(a);
        new_b := _ExpandKron(b);
        if type(new_a, `+`) then
            return `+`(seq(Kron(term, new_b), term in [op(new_a)]));
        elif type(new_b, `+`) then
            return `+`(seq(Kron(new_a, term), term in [op(new_b)]));
        else
            return Kron(new_a, new_b);
        end if;
    end proc;

    Expand := proc(expr)
        local e, new_e;
        e := expr;
        while true do
            new_e := subsindets(e, specfunc(KroneckerProduct), _ExpandKron);
            if new_e = e then break; end if;
            e := new_e;
        end do;
        return e;
    end proc;

    # ---------- Shuffle ----------
    Shuffle := proc(A, B)
        local p, q, r, s, S1, S2;
        try
            p := LinearAlgebra:-RowDimension(A);
            q := LinearAlgebra:-ColumnDimension(A);
            r := LinearAlgebra:-RowDimension(B);
            s := LinearAlgebra:-ColumnDimension(B);
        catch:
            return 'Shuffle'(A, B);
        end try;
        if not (type(p, posint) and type(q, posint) and type(r, posint) and type(s, posint)) then
            return 'Shuffle'(A, B);
        end if;
        S1 := _PerfectShuffleMatrix(p, r);
        S2 := _PerfectShuffleMatrix(q, s);
        return S1 . LinearAlgebra:-KroneckerProduct(A, B) . LinearAlgebra:-Transpose(S2);
    end proc;

    # ---------- Activation for numeric evaluation (gecorrigeerd: eerst Identity/Zero) ----------
    local Activate := proc(expr)
        subs([ 'Determinant' = LinearAlgebra:-Determinant,
               'Trace' = LinearAlgebra:-Trace,
               'MatrixInverse' = LinearAlgebra:-MatrixInverse,
               'Transpose' = LinearAlgebra:-Transpose,
               'HermitianTranspose' = LinearAlgebra:-HermitianTranspose,
               'Dim' = proc(M) if type(M,Matrix) then LinearAlgebra:-RowDimension(M) else 'Dim'(M) end if end proc,
               'IdentityMatrix' = proc(n) LinearAlgebra:-IdentityMatrix(n) end proc,
               'ZeroMatrix' = proc(m,n) LinearAlgebra:-ZeroMatrix(m,n) end proc,
               'KroneckerProduct' = LinearAlgebra:-KroneckerProduct
             ], expr);
    end proc;

    NumericEvaluate := proc(expr)
        local e, res;
        e := expr;
        try
            e := subsindets(e, specfunc(IdentityMatrix), id -> LinearAlgebra:-IdentityMatrix(op(id)));
            e := subsindets(e, specfunc(ZeroMatrix), zm -> LinearAlgebra:-ZeroMatrix(op(zm)));
            e := subsindets(e, specfunc(KroneckerProduct), k -> LinearAlgebra:-KroneckerProduct(op(k)));
            e := subsindets(e, specfunc(MatrixInverse), m -> LinearAlgebra:-MatrixInverse(op(m)));
            e := subsindets(e, specfunc(Transpose), t -> LinearAlgebra:-Transpose(op(t)));
            e := subsindets(e, specfunc(HermitianTranspose), h -> LinearAlgebra:-HermitianTranspose(op(h)));
            e := subsindets(e, specfunc(conjugate), c -> conjugate(op(c)));
            e := subsindets(e, specfunc(Shuffle), s -> LinearAlgebra:-KroneckerProduct(op(2,s), op(1,s)));
            e := subsindets(e, specfunc(Determinant), d -> LinearAlgebra:-Determinant(op(d)));
            e := subsindets(e, specfunc(Trace), t -> LinearAlgebra:-Trace(op(t)));
            e := subsindets(e, specfunc(Dim), d -> if type(op(d),Matrix) then LinearAlgebra:-RowDimension(op(d)) else 'Dim'(op(d)) end if);
            res := eval(e);
            return res;
        catch:
            if StringTools:-Search("Matrix", lastexception) > 0 then
                error "NumericEvaluate failed due to dimension mismatch or invalid matrix operation. Check your matrices.";
            else
                error "NumericEvaluate failed: %s", lastexception;
            end if;
        end try;
    end proc;

    # ---------- TestRandom ----------
    TestRandom := proc(expr::uneval, {n::posint := 2, samples::posint := 5, visual::boolean := false, showall::boolean := false})
        printf("TestRandom: Uses random SQUARE matrices (size %d x %d).\n", n, n);
        printf("   For non‑square matrices, use TestUser with your own matrices.\n");
        local e, syms, i, subs_set, gen, simp_expr, val_simp, orig_expr, val_orig, ok, a;
        e := eval(expr);
        syms := indets(e, symbol) minus {Kron, Determinant, Trace, MatrixInverse, KroneckerProduct,
                                         'Kron', 'Determinant', 'Trace', 'MatrixInverse', 'KroneckerProduct',
                                         dim, 'dim', `&x`, Shuffle, Expand, Transpose, HermitianTranspose, conjugate, Dim,
                                         IdentityMatrix, ZeroMatrix};
        if syms = {} then error "No symbolic variables found. Use symbolic names like A,B,..."; end if;
        gen := proc() local M; do M := LinearAlgebra:-RandomMatrix(n, n, generator=-5..5); until LinearAlgebra:-Determinant(M) <> 0; return M; end proc;
        ok := true;
        for i from 1 to samples do
            subs_set := map(s -> s = gen(), syms);
            simp_expr := Simplify(e);
            simp_expr := Activate(simp_expr);
            val_simp := eval(eval(simp_expr, subs_set));
            orig_expr := subs('Kron' = KroneckerProduct, `&x` = KroneckerProduct, e);
            orig_expr := Activate(orig_expr);
            val_orig := eval(eval(orig_expr, subs_set));
            if visual and (showall or i = samples or (i = 1 and not ok)) then
                printf("Sample %d:\n", i);
                printf("Substitutions:\n");
                for a in subs_set do printf(" %a\n", a); end do;
                printf("Direct:\n"); print(val_orig);
                printf("Simplified:\n"); print(val_simp);
                printf("\n");
            end if;
            if type(val_orig, Matrix) and val_simp = 0 then
                if LinearAlgebra:-Norm(val_orig, infinity) <> 0 then ok := false; break; end if;
            elif type(val_simp, Matrix) and val_orig = 0 then
                if LinearAlgebra:-Norm(val_simp, infinity) <> 0 then ok := false; break; end if;
            elif type(val_orig, Matrix) and type(val_simp, Matrix) then
                if not LinearAlgebra:-Equal(val_orig, val_simp) then ok := false; break; end if;
            else
                if evalb(val_orig <> val_simp) then ok := false; break; end if;
            end if;
        end do;
        if visual then
            if ok then printf("All samples OK (only last sample shown).\n"); else printf("Mismatch found in sample %d.\n", i); end if;
        end if;
        return ok;
    end proc;

    # ---------- TestUser ----------
    TestUser := proc(expr, {visual::boolean := false})
        printf("TestUser: Comparing Simplify(expr) with direct evaluation using current concrete matrices.\n");
        local simp, direct, syms, M, ok;
        syms := indets(expr, symbol) minus {Kron, Determinant, Trace, MatrixInverse, KroneckerProduct,
                                            'Kron', 'Determinant', 'Trace', 'MatrixInverse', 'KroneckerProduct',
                                            dim, 'dim', `&x`, Shuffle, Expand, Transpose, HermitianTranspose, conjugate, Dim,
                                            IdentityMatrix, ZeroMatrix};
        for M in syms do
            if not type(eval(M), Matrix) then
                error "Symbol %a is not assigned a concrete matrix. Use %a := Matrix(...) first.", M, M;
            end if;
        end do;
        try
            _check_expression_dims(expr);
        catch:
            error "%s", lastexception;
        end try;
        simp := Simplify(expr);
        simp := NumericEvaluate(simp);
        direct := NumericEvaluate(expr);
        if visual then
            printf("Direct calculation:\n"); print(direct);
            printf("Simplified calculation:\n"); print(simp);
        end if;
        if type(simp, Matrix) and type(direct, Matrix) then
            if LinearAlgebra:-Equal(simp, direct) then
                printf("Results are IDENTICAL.\n");
                return true;
            else
                printf("ERROR – results differ.\n");
                return false;
            end if;
        else
            if evalb(simp = direct) then
                printf("Results are IDENTICAL.\n");
                return true;
            else
                printf("ERROR – results differ.\n");
                return false;
            end if;
        end if;
    end proc;

    # ---------- ProveIdentity ----------
    ProveIdentity := proc(expr1, expr2, {outputstyle::string := "Kron", trace::boolean := false})
        local diff, res;
        diff := expr1 - expr2;
        if trace then
            res := SimplifyTrace(diff, outputstyle);
        else
            res := Simplify(diff, outputstyle);
        end if;
        if res = 0 then
            printf("Identity PROVEN: difference simplifies to 0.\n");
            return true, 0;
        elif type(res, Matrix) and LinearAlgebra:-IsZero(res) then
            printf("Identity PROVEN: difference simplifies to a zero matrix.\n");
            return true, res;
        else
            printf("Identity NOT proven. Simplified difference:\n");
            print(res);
            return false, res;
        end if;
    end proc;

    # ---------- ProveIdentityMatrix ----------
    ProveIdentityMatrix := proc(expr1, expr2, {visual::boolean := false})
        local lhs, rhs;
        if visual then
            printf("Left expression:\n"); print(expr1);
            printf("Right expression:\n"); print(expr2);
        end if;
        lhs := NumericEvaluate(expr1);
        rhs := NumericEvaluate(expr2);
        if visual then
            printf("Numeric left:\n"); print(lhs);
            printf("Numeric right:\n"); print(rhs);
        end if;
        if type(lhs, Matrix) and type(rhs, Matrix) then
            if LinearAlgebra:-Equal(lhs, rhs) then
                printf("Identity PROVED numerically.\n");
                return true;
            else
                printf("Identity NOT proved numerically.\n");
                return false;
            end if;
        else
            if evalb(lhs = rhs) then
                printf("Identity PROVED numerically.\n");
                return true;
            else
                printf("Identity NOT proved numerically.\n");
                return false;
            end if;
        end if;
    end proc;

    # ---------- Quick reference per rule (uitgebreid) ----------
    HelpRule := proc(ruleName::string)
        if ruleName = "KRON1" then
            printf("KRON1: (c·A)5B = A5(c·B) = c·(A5B)\n");
            printf("Example: (3*A) &x B -> 3*(A &x B)\n");
        elif ruleName = "KRON2" then
            printf("KRON2: (A5B)^T = A^T 5 B^T\n");
            printf("Example: Transpose(A &x B) -> Transpose(A) &x Transpose(B)\n");
        elif ruleName = "KRON3" then
            printf("KRON3: (A5B)^H = A^H 5 B^H\n");
            printf("Example: HermitianTranspose(A &x B) -> HermitianTranspose(A) &x HermitianTranspose(B)\n");
        elif ruleName = "KRON4" then
            printf("KRON4: (A5B)5C = A5(B5C)\n");
            printf("Example: (A &x B) &x C -> A &x (B &x C)\n");
        elif ruleName = "KRON5" then
            printf("KRON5: (A+B)5C = A5C + B5C\n");
            printf("Example: (A+B) &x C -> A&x C + B&x C\n");
        elif ruleName = "KRON6" then
            printf("KRON6: A5(B+C) = A5B + A5C\n");
            printf("Example: A &x (B+C) -> A&x B + A&x C\n");
        elif ruleName = "KRON7" then
            printf("KRON7: (A5B)·(C5D) = (A·C)5(B·D) and A·(X5Y)·B = (A·X)5(Y·B)\n");
            printf("Example: (A&x B) . (C&x D) -> (A.C) &x (B.D)\n");
            printf("Example: A . (X&x Y) . B -> (A.X) &x (Y.B)\n");
        elif ruleName = "KRON8" then
            printf("KRON8: Tr(A5B) = Tr(A)·Tr(B)\n");
            printf("Example: Trace(A &x B) -> Trace(A)*Trace(B)\n");
        elif ruleName = "KRON9" then
            printf("KRON9: det(A5B) = det(A)^(dim(B)) · det(B)^(dim(A))\n");
            printf("Example: Determinant(A &x B) -> Determinant(A)^Dim(B) * Determinant(B)^Dim(A)\n");
        elif ruleName = "KRON10" then
            printf("KRON10: (A5B)^(-1) = A^(-1) 5 B^(-1)\n");
            printf("Example: MatrixInverse(A &x B) -> MatrixInverse(A) &x MatrixInverse(B)\n");
        elif ruleName = "KRON11" then
            printf("KRON11: Shuffle(A,B) = S·(A5B)·S^T (permutation matrix S) gives B5A\n");
            printf("Example: Shuffle(A,B) -> (permuted Kronecker product)\n");
        elif ruleName = "Double HermitianTranspose" then
            printf("Double HermitianTranspose: HermitianTranspose(HermitianTranspose(X)) → X\n");
            printf("Example: HermitianTranspose(HermitianTranspose(A)) -> A\n");
        elif ruleName = "Double Transpose" then
            printf("Double Transpose: Transpose(Transpose(X)) → X\n");
            printf("Example: Transpose(Transpose(A)) -> A\n");
        elif ruleName = "Dim" then
            printf("Dim rules: Dim(A5B)=Dim(A)*Dim(B), Dim(c·A)=Dim(A), Dim(A+B)=Dim(A) (if same dims), Dim(I_n)=n, Dim(Zero)=m\n");
            printf("Example: Dim(A &x B) -> Dim(A)*Dim(B)\n");
        elif ruleName = "MatrixInverse of product" then
            printf("MatrixInverse of product: (A·B)^(-1) → B^(-1)·A^(-1)\n");
            printf("Example: MatrixInverse(A . B) -> MatrixInverse(B) . MatrixInverse(A)\n");
        elif ruleName = "Identity matrix multiplication" then
            printf("I_n · A = A, A · I_n = A, I_n · I_n = I_n\n");
        elif ruleName = "Identity matrix Kronecker" then
            printf("I_m 5 I_n = I_{m*n}\n");
        elif ruleName = "Zero matrix propagation" then
            printf("0·A = 0, A·0 = 0, 05A = 0, A50 = 0\n");
        elif ruleName = "Trace of product" then
            printf("Tr(A·B) = Tr(B·A)\n");
        elif ruleName = "Determinant of product" then
            printf("det(A·B) = det(A)·det(B)\n");
        elif ruleName = "Shuffle chain" then
            printf("Shuffle(Shuffle(A,B),C) = Shuffle(A,Shuffle(B,C))\n");
        else
            printf("No help available for rule '%s'.\n", ruleName);
        end if;
    end proc;

    QuickRef := proc()
        printf("================================================================\n");
        printf("QUICK REFERENCE OF RULES (with examples)\n");
        printf("================================================================\n");
        HelpRule("KRON1");
        HelpRule("KRON2");
        HelpRule("KRON3");
        HelpRule("KRON4");
        HelpRule("KRON5");
        HelpRule("KRON6");
        HelpRule("KRON7");
        HelpRule("KRON8");
        HelpRule("KRON9");
        HelpRule("KRON10");
        HelpRule("KRON11");
        HelpRule("Double HermitianTranspose");
        HelpRule("Double Transpose");
        HelpRule("Dim");
        HelpRule("MatrixInverse of product");
        HelpRule("Identity matrix multiplication");
        HelpRule("Identity matrix Kronecker");
        HelpRule("Zero matrix propagation");
        HelpRule("Trace of product");
        HelpRule("Determinant of product");
        HelpRule("Shuffle chain");
        printf("================================================================\n");
    end proc;

    Info := proc()
        printf("================================================================\n");
        printf("KRONECKERRULES PACKAGE – COMPLETE USER GUIDE\n");
        printf("================================================================\n\n");
        printf("1. PURPOSE\n");
        printf("   Simplify symbolic expressions involving Kronecker products (5),\n");
        printf("   matrix multiplication (.), addition (+), subtraction (-), transpose (^T),\n");
        printf("   Hermitian transpose (^H), inverse, determinant, trace, and shuffle.\n\n");
        printf("2. INERT NOTATION\n");
        printf("   Kron(A,B) or A &x B -> inert KroneckerProduct(A,B).\n");
        printf("   IdentityMatrix(n) -> inert identity matrix.\n");
        printf("   ZeroMatrix(m,n) -> inert zero matrix.\n\n");
        printf("3. MAIN COMMANDS\n");
        printf("   Simplify(expr)                     – apply all rules iteratively.\n");
        printf("   Simplify(expr, \"Kron\")            – same with short Kron notation.\n");
        printf("   Simplify(expr, maxiter)            – set max iterations (default 50).\n");
        printf("   SimplifyTrace(expr)                – show steps.\n");
        printf("   Expand(expr)                       – distribute 5 over sums.\n");
        printf("   Shuffle(A,B)                       – realize B5A via permutation.\n");
        printf("   Canonicalize(expr)                 – sort symbols in 5 lexicographically.\n");
        printf("   ToggleKronNotation()               – switch output notation.\n");
        printf("   SetDim(A, r, c)                    – set symbolic dimensions.\n");
        printf("   GetDim(A, i)                       – retrieve dimension.\n");
        printf("   HelpRule(ruleName)                 – show example for a rule.\n");
        printf("   QuickRef()                         – list all rules.\n");
        printf("   Info()                             – this manual.\n\n");
        printf("4. VERIFICATION\n");
        printf("   TestRandom(expr)                   – test with random square matrices.\n");
        printf("   TestUser(expr)                     – test with user-supplied concrete matrices.\n");
        printf("   ProveIdentity(expr1, expr2)        – prove identity symbolically.\n");
        printf("   ProveIdentityMatrix(expr1, expr2) – prove identity numerically.\n\n");
        printf("5. EXAMPLES\n");
        printf("   with(KroneckerRules):\n");
        printf("   SetDim(A,2,2); I2:=IdentityMatrix(2); I3:=IdentityMatrix(3);\n");
        printf("   Simplify(I2 . A);               -> A\n");
        printf("   Simplify(I2 &x I3);              -> IdentityMatrix(6)\n");
        printf("   Simplify(Trace(A . B));          -> Trace(B·A)\n");
        printf("   Simplify(Determinant(A . B));    -> det(A)*det(B)\n");
        printf("   Simplify(Shuffle(Shuffle(A,B),C)); -> Shuffle(A,Shuffle(B,C))\n");
        printf("   Simplify(ZeroMatrix(2,2) + A);   -> A\n");
        printf("================================================================\n");
    end proc;

end module:

#restart;
# Veronderstel dat de KroneckerRules-module hier is geladen (eerst uitvoeren)
with(KroneckerRules):

print("======================================================================");
print(" ULTIMATE TESTSUITE FOR KRONECKERRULES");
print("======================================================================");

(1.1)

>	# ===== 1. DIMENSIES INSTELLEN ===== print("1. DIMENSIES INSTELLEN"); SetDim(A,2,2); SetDim(B,2,2); SetDim(C,2,2); SetDim(P,2,3); SetDim(Q,3,2); # rechthoekig SetDim(X,2,2); SetDim(Y,3,3); # voor somtest SetDim(U,4,4); SetDim(V,4,4);

Dimensions set: A = [2, 2]
Dimensions set: B = [2, 2]
Dimensions set: C = [2, 2]
Dimensions set: P = [2, 3]
Dimensions set: Q = [3, 2]
Dimensions set: X = [2, 2]
Dimensions set: Y = [3, 3]
Dimensions set: U = [4, 4]
Dimensions set: V = [4, 4]

# ===== 2. IDENTITEITSMATRIX =====
print("2. IDENTITEITSMATRIX");
Id2 := IdentityMatrix(2);
Id3 := IdentityMatrix(3);
Id4 := IdentityMatrix(4);
Simplify(Id2 . A);                     # A
Simplify(A . Id2);                     # A
Simplify(Id2 . Id2);                   # Id2
Simplify(Id2 &x Id3);                  # Id6
Simplify(Id2 &x A);                    # Id25A
Simplify((Id2 &x A) . (B &x Id2));     # B5A
Simplify((Id2 &x A) . (Id2 &x B));     # (Id2·Id2)5(A·B) = Id25(A·B)
Simplify(Transpose(Id2));              # Id2
Simplify(MatrixInverse(Id2));          # Id2

(1.2)

# ===== 3. NULMATRIX =====
print("3. NULMATRIX");
Null22 := ZeroMatrix(2,2);
Null23 := ZeroMatrix(2,3);
Null32 := ZeroMatrix(3,2);
Simplify(Null22 . A);                  # Null22
Simplify(A . Null22);                  # Null22
Simplify(Null22 &x B);                 # ZeroMatrix(2*Dim(B,1), 2*Dim(B,2))
Simplify(A &x Null22);                 # ZeroMatrix(Dim(A,1)*2, Dim(A,2)*2)
Simplify(Null23 . Q);                  # Null23 (zolang Q 3x2 is? Null23·Q = Null23? eigenlijk 2x3 * 3x2 = 2x2 nul, maar module geeft Null23? Oude regel: geeft Null23. Accepteer.)
Simplify(Transpose(Null22));           # Null22 (getransponeerd blijft nul)
Simplify(Null22 + A);                  # A (nul plus iets)

(1.3)

>	# ===== 4. KRON1: SCALAIR ===== print("4. KRON1 - SCALAR UIT KRONECKER"); expr := (5A) &x B; Simplify(expr); # 5(A5B) expr := A &x (6B); Simplify(expr); # 6(A5B)

(1.4)

# ===== 5. KRON2, KRON3, TRANSPOSE, HERMITIAN, CONJUGATE =====
print("5. TRANSPOSE, HERMITIAN, CONJUGATE");
expr := Transpose(A &x B);
Simplify(expr);                        # Transpose(A) 5 Transpose(B)
expr := HermitianTranspose(A &x B);
Simplify(expr);                        # HermitianTranspose(A) 5 HermitianTranspose(B)
expr := conjugate(A &x B);
Simplify(expr);                        # conjugate(A) 5 conjugate(B)
expr := Transpose(A+B);
Simplify(expr);                        # Transpose(A)+Transpose(B)
expr := HermitianTranspose(A+B);
Simplify(expr);                        # HermitianTranspose(A)+HermitianTranspose(B)
expr := conjugate(A+B);
Simplify(expr);                        # conjugate(A)+conjugate(B)
expr := Transpose(Transpose(A));
Simplify(expr);                        # A
expr := HermitianTranspose(HermitianTranspose(A));
Simplify(expr);                        # A

(1.5)

>	# ===== 6. KRON4: ASSOCIATIVITEIT ===== print("6. KRON4 - ASSOCIATIVITEIT"); expr := (A &x B) &x C; Simplify(expr); # A5(B5C)

(1.6)

>	# ===== 7. KRON5, KRON6: DISTRIBUTIE OVER SOM ===== print("7. KRON5, KRON6 - DISTRIBUTIE"); expr := (A + B) &x C; Simplify(expr); # A5C + B5C expr := A &x (B + C); Simplify(expr); # A5B + A5C

(1.7)

# ===== 8. KRON7: PRODUCT VAN KRONECKER-PRODUCTEN =====
print("8. KRON7 - PRODUCTREGELS");
expr := (A &x B) . (C &x D);
Simplify(expr);                        # (A·C) 5 (B·D)
expr := A . (X &x Y) . B;
Simplify(expr);                        # (A·X) 5 (Y·B)
expr := (A &x B) . (C &x D) . (E &x F);
Simplify(expr);                        # (A·C·E) 5 (B·D·F)
# met identiteit erin
expr := (Id2 &x A) . (B &x Id3);
Simplify(expr);                        # B 5 A

(1.8)

>	# ===== 9. KRON8: SPOOR ===== print("9. KRON8 - SPOOR"); expr := Trace(A &x B); Simplify(expr); # Trace(A) * Trace(B) expr := Trace(A + B); Simplify(expr); # Trace(A)+Trace(B)

(1.9)

>	# ===== 10. KRON9: DETERMINANT ===== print("10. KRON9 - DETERMINANT"); expr := Determinant(A &x B); Simplify(expr); # det(A)^Dim(B) * det(B)^Dim(A)

(1.10)

>	# ===== 11. KRON10: INVERSE ===== print("11. KRON10 - INVERSE"); expr := MatrixInverse(A &x B); Simplify(expr); # inv(A) 5 inv(B)

(1.11)

>	# ===== 12. TRACE VAN PRODUCT (Tr(AB)=Tr(BA)) =====##### BLIJFT HANGEN F6 print("12. TRACE TR(AB)=TR(BA)"); expr := Trace(A . B); Simplify(expr); # Trace(B·A) expr := Trace(A . B . C); # blijft staan (alleen 2 factoren)

(1.12)

>	# ===== 13. DETERMINANT VAN PRODUCT ===== print("13. DETERMINANT det(AB)=det(A)det(B)"); expr := Determinant(A . B); Simplify(expr); # det(A)*det(B)

(1.13)

>	# ===== 14. INVERSE VAN PRODUCT ===== print("14. INVERSE (AB)^{-1} = B^{-1} A^{-1}"); expr := MatrixInverse(A . B); Simplify(expr); # inv(B) . inv(A)

(1.14)

# ===== 15. DIM VEREENVOUDIGING =====
print("15. DIM VEREENVOUDIGING");
Simplify(Dim(A &x B));                 # Dim(A)*Dim(B)
Simplify(Dim(3*A));                    # Dim(A)
Simplify(Dim(Id2));                    # 2
Simplify(Dim(ZeroMatrix(4,5)));        # 4
# Som metzelfde dimensies
Simplify(Dim(X+X));                    # 2 (of Dim(X) indien symbolisch)
# Som met verschillende: waarschuwing
Simplify(Dim(X+Y));                    # waarschuwing + Dim(X+Y)

Warning: Dim(X+Y) cannot be simplified because terms have different dimensions.

(1.15)

# ===== 16. SHUFFLE KETENS =====
print("16. SHUFFLE KETENS");
expr := Shuffle(Shuffle(A,B), C);
Simplify(expr); # Shuffle(A, Shuffle(B,C))
# Numerieke shuffle met concrete matrices (vierkant)
M1 := Matrix(2,2,[[1,2],[3,4]]);
M2 := Matrix(2,2,[[0,1],[1,0]]);
S12 := Simplify(Shuffle(M1, M2)); # concrete 4x4 permutatiematrix, check compatibel
# (geen fout, gewoon weergeven)

(1.16)

# ===== 17. CANONICALIZE =====
print("17. CANONICALIZE (lexicografisch)");
expr := B &x A;
Canonicalize(expr);                    # A5B
expr := C &x B &x A;                   # alleen top-level Kronecker
Canonicalize(expr);                    # C5B5A (geen diepe sortering)
expr := (B &x A) &x C;                 # moeilijker: blijft (B5A)5C, want Canonicalize werkt alleen op specfunc(KroneckerProduct) zonder deep.
Canonicalize(expr);                    # (B5A)5C (geen verandering)

(1.17)

>	# ===== 18. EXPAND (distributie Kron over +) ===== print("18. EXPAND - DISTRIBUTIE"); expr := (A + B) &x (C + D); Expand(expr); # A5C + A5D + B5C + B5D expr := Expand((A+B)&x C); # A5C + B5C

(1.18)

# ===== 19. NUMERIEKE TESTEN (TestRandom, TestUser) =====
print("19. TESTRANDOM (willekeurige vierkante matrices)");
TestRandom( (X &x Y) . (Z &x W) ); # moet true geven
TestRandom( Determinant(X &x Y) - Determinant(X)^Dim(Y)*Determinant(Y)^Dim(X) ); # 0
TestRandom( Trace(X &x Y) - Trace(X)*Trace(Y) );

TestRandom: Uses random SQUARE matrices (size 2 x 2).
For non‑square matrices, use TestUser with your own matrices.

(1.19)

print("20. TESTUSER (concrete matrices)");
# Definieer concrete matrices
Amat := Matrix(2,2,[[1,2],[3,4]]);
Bmat := Matrix(2,2,[[0,1],[1,0]]);
Cmat := IdentityMatrix(2);
Dmat := Matrix(2,2,[[2,0],[0,3]]);
# TestUser vergelijkt Simplify(expr) met directe evaluatie
exprTest := (Amat &x Bmat) . (Cmat &x Dmat);
TestUser(exprTest, visual=true); # moet identiek zijn aan directe berekening
exprTest2 := Trace(Amat . Bmat) - Trace(Bmat . Amat);
TestUser(exprTest2, visual=true); # moet 0 zijn

TestUser: Comparing Simplify(expr) with direct evaluation using current concrete matrices.
Direct calculation:

Simplified calculation:

ERROR – results differ.

TestUser: Comparing Simplify(expr) with direct evaluation using current concrete matrices.
Direct calculation:

Simplified calculation:

Results are IDENTICAL.

(1.20)

>	# ===== 21. PROVEIDENTITY (symbolisch) ===== print("21. PROVEIDENTITY SYMBOLISCH"); exprL := (R &x S) . (T &x U) . (V &x W); exprR := (R.T.V) &x (S.U.W); ProveIdentity(exprL, exprR, trace=true); # verschil reduceert tot 0

Iteration 1:
1. KRON7 (chain) ((A5B)·(C5D) → (A·C)5(B·D)): Kron(R,S) . Kron(T,U) . Kron(V,W) -> Kron(R . T . V,S . U . W)
Result after iteration 1: 0

No more rules apply after iteration 1.
--- Final simplified expression ---
Identity PROVEN: difference simplifies to 0.

(1.21)

>	# ===== 22. PROVEIDENTITYMATRIX (numeriek) ===== print("22. PROVEIDENTITYMATRIX NUMERIEK"); # Gebruik dezelfde symbolen met concrete matrices R := Amat; S := Bmat; T := Cmat; U := Dmat; V := Amat; W := Bmat; ProveIdentityMatrix(exprL, exprR, visual=true);

Left expression:

Right expression:

Numeric left:

Numeric right:

Identity NOT proved numerically.

(1.22)

>	# ===== 23. NOTATIE WISSELEN ===== print("23. TOGGLEKRONNOTATION"); ToggleKronNotation(); # naar Kron(A,B) Simplify(A &x B); # toont Kron(A,B) ToggleKronNotation(); # terug naar KroneckerProduct(A,B) Simplify(A &x B); # toont KroneckerProduct(A,B)

KroneckerProduct output notation set to PRETTY (Kron(A,B))

KroneckerProduct output notation set to DEFAULT (KroneckerProduct(A,B))

(1.23)

>	# ===== 24. PRESTATIE (memoization) ===== print("24. PRESTATIE - MEMOIZATION"); # Herhaald ophalen van dimensies st := time(); for i from 1 to 1000 do _dummy := GetDim(A,1); end do; printf("Tijd voor 1000 GetDim(A,1): %f seconden (zou snel moeten zijn)\n", time()-st);

Tijd voor 1000 GetDim(A,1): 0.984000 seconden (zou snel moeten zijn)

>	# ===== 25. DIMENSIE MISMATCH SIGNALERING ===== print("25. DIMENSIE MISMATCH (waarschuwingen)"); SetDim(P,2,3); SetDim(Q,3,2); Simplify(Dim(P+Q)); # waarschuwing: verschillende dimensies -> Dim(P+Q) blijft # Hierna eventueel product: P . Q is 2x2, zou moeten werken Simplify(Dim(P.Q)); # Dim(P) = 2

Dimensions set: P = [2, 3]
Dimensions set: Q = [3, 2]
Warning: Dim(P+Q) cannot be simplified because terms have different dimensions.

(1.24)

# ===== 26. GEINTEGREERDE GROTE EXPRESSIE ===== ################ blijft hangen : F6
print("26. COMPLEXE EXPRESSIE MET ALLE REGELS");
exprAll := (Id2 &x A) . (B &x Id3) + ZeroMatrix(2,2) &x C - Transpose(A &x B) + Trace(A . B) - Trace(B . A);
Simplify(exprAll); # mooie vereenvoudiging: (B5A) - (A^T5B^T) + 0
# Verwachte uitkomst: (B5A) - (Transpose(A)5Transpose(B))

(1.25)

>	print("======================================================================"); print(" ALLE TESTS VOLTOOID"); print("======================================================================");

(1.26)

with(KroneckerRules):
SetDim(A,2,2); SetDim(B,2,2);
Id2 := IdentityMatrix(2);
Id3 := IdentityMatrix(3);

Simplify(Id2 . A);               # A
Simplify(A . Id2);               # A
Simplify(Id2 . Id2);             # IdentityMatrix(2)
Simplify(Id2 &x Id3);            # IdentityMatrix(6)
Simplify((Id2 &x A) . (B &x Id3)); # B5A
Simplify(ZeroMatrix(2,2) + A);   # A
Simplify(Trace(A . B));          # Trace(B·A)
Simplify(Determinant(A . B));    # Determinant(A)*Determinant(B)
Simplify(Shuffle(Shuffle(A,B),C)); # Shuffle(A,Shuffle(B,C))
Canonicalize(B &x A);            # A5B

Dimensions set: A = [2, 2]
Dimensions set: B = [2, 2]

(1.27)

SetStyle := proc(style::nonnegint)# werktt nog niet externe procedure voor de notatieuitvoer ..uitzoeken
    if style = 0 then
        `print/KroneckerProduct` := (A,B) -> 'KroneckerProduct'(A,B);
        printf("Notatie: default (KroneckerProduct)\n");
    elif style = 1 then
        `print/KroneckerProduct` := (A,B) -> 'Kron'(A,B);
        printf("Notatie: short (Kron)\n");
    else
        `print/KroneckerProduct` := proc(A,B)
            local a,b;
            a := `if`(type(A, specfunc(KroneckerProduct)), sprintf("(%a)", A), sprintf("%a", A));
            b := `if`(type(B, specfunc(KroneckerProduct)), sprintf("(%a)", B), sprintf("%a", B));
            cat(a, " 5 ", b);
        end proc;
        printf("Notatie: pretty (5 met haakjes)\n");
    end if;
end proc:

Warning, (in SetStyle) `print/KroneckerProduct` is implicitly declared local

>	SetStyle(2); Simplify(A &x B &x C); # A 5 (B 5 C) SetStyle(0); Simplify(A &x B &x C); # KroneckerProduct(A, KroneckerProduct(B,C))

Notatie: pretty (5 met haakjes)

Notatie: default (KroneckerProduct)

(1.28)

Download kroneckerproducts_module_next_level__30-4-2026.mw

MaplePrimes - Newest Comments

Maple Worksheet - Error Failed to load the wor...

Latest version 30-4-2026 ...

Maple 2026.1 Update

Moderation

bol_waaruit_intrisiek_iets_wordt_afgeleid_17-7-202...

@C_R ...