KrausOp.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# API"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import *\n",
    "from sympy.physics.quantum import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n1,n2,n3=symbols('n_1,n_2,n_3')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g={i:Operator('\\gamma_{}'.format(i)) for i in range(1,5)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gb={i:Operator(r'\\bar{{\\gamma}}_{}'.format(i)) for i in range(1,5)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c={i:Operator(r'c_{}'.format(i)) for i in range(1,5)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cd={i:Dagger(Operator(r'c_{}'.format(i))) for i in range(1,5)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ea(n1,n2,n3):\n",
    "    return ((1+n1)/(1-n1))**(1/4)* ((n2-I*n3)/sqrt(n2**2+n3**2))**(1/2)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def K(n1,n2,n3,op1,op2):\n",
    "    expa=N(ea(n1,n2,n3))\n",
    "    expma=1/expa\n",
    "    return (1-n1**2)**(1/4)*( (expa+ expma)/2)- ((1-n1**2)**(1/4)*(expa-expma)/2  *I* op1 * op2 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "selfjoint=[(Dagger(gi),gi) for gi in g.values()]+[(Dagger(gi),gi) for gi in gb.values()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "squareone=[(gi**2,1) for gi in g.values()]+[(gi**2,1) for gi in gb.values()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "normalorder=[gi[i] for i in range(1,len(g)+1) for gi in [g, gb]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "normalorder2=[(normalorder[j]*normalorder[i],-normalorder[i]*normalorder[j]) for i in range(len(normalorder)) for j in range(i+1,len(normalorder))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g2c=[(g[i],(c[i]+Dagger(c[i]))) for i in range(1,len(g)+1)]+[(gb[i],(Dagger(c[i])-c[i])/(I)) for i in range(1,len(gb)+1)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "squarezero=[(ci**2,0) for ci in c.values()] +[(Dagger(ci)**2,0) for ci in c.values()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "normalorder_C=[Dagger(ci) for ci in c.values()]+[ci for ci in c.values()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def delta(i,j):\n",
    "    return 1 if i%(len(normalorder_C)//2)==j%(len(normalorder_C)//2) else 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "normalorder2_C=[(normalorder_C[j]*normalorder_C[i],0 if i==j else delta(i,j)-normalorder_C[i]*normalorder_C[j]) for i in range(len(normalorder_C)) for j in range(i,len(normalorder_C))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def recursiveapply(expr,subs):\n",
    "    expr1=expr.subs(subs)\n",
    "    while not expr1== expr:\n",
    "        expr=expr1\n",
    "        expr1=expr.subs(subs).expand()\n",
    "    return expr1"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Op"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Kn=(K(0,0,1,g[1],gb[1]))\n",
    "# Kn=(K(0,1/sqrt(2),1/sqrt(2),gb[1],g[2]))\n",
    "# Kn=K(0,.1,sqrt(1-0.1**2),gb[1],g[2])\n",
    "# Kn=K(.9,0,sqrt(1-0.9**2),gb[1],g[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Kn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "expval=[(Dagger(ci)*ci,1) for ci in c.values()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(Dagger(Kn)*Kn).expand().subs(selfjoint).subs(squareone).subs(normalorder2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(Kn).expand()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(gb[1]).subs(g2c).expand().subs(normalorder2_C).expand()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(I* g[1]* gb[1]).subs(g2c).expand().subs(normalorder2_C).expand()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(Kn).expand().subs(g2c).expand().subs(normalorder2_C).expand()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Op"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Kn=(K(0.9,sqrt(1-0.9**2),0,gb[1],g[2])) *(K(0.9,sqrt(1-0.9**2),0,gb[2],g[3]))\n",
    "# Kn=(K(0,1/sqrt(2),1/sqrt(2),gb[1],g[2]))\n",
    "Kn=(K(0.1,sqrt(1-0.1**2)*sin(pi/4),sqrt(1-0.1**2)*cos(pi/4),gb[1],g[2]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Kn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((Dagger(Kn)*Kn).subs(g2c).expand(),normalorder2_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((Dagger(Kn)*(I*g[1]*gb[1])*Kn).expand().subs(g2c).expand(),normalorder2_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((Dagger(Kn)*(I*g[1]*g[2])*Kn).expand().subs(g2c).expand(),normalorder2_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((Dagger(Kn)*(I*g[1]*gb[2])*Kn).expand().subs(g2c).expand(),normalorder2_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((Dagger(Kn)*(I*gb[1]*g[2])*Kn).expand().subs(g2c).expand(),normalorder2_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((Dagger(Kn)*(I*gb[1]*gb[2])*Kn).expand().subs(g2c).expand(),normalorder2_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((Dagger(Kn)*(I*g[2]*gb[2])*Kn).expand().subs(g2c).expand(),normalorder2_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((Dagger(Kn)*(I*g[1]*g[3])*Kn).expand().subs(g2c).expand(),normalorder2_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((Dagger(Kn)*(I*g[1]*gb[3])*Kn).expand().subs(g2c).expand(),normalorder2_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((Dagger(Kn)*(I*g[2]*gb[3])*Kn).expand().subs(g2c).expand(),normalorder2_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((Dagger(Kn)*(I*gb[2]*g[3])*Kn).expand().subs(g2c).expand(),normalorder2_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((Dagger(Kn)*(I*g[3]*gb[3])*Kn).expand().subs(g2c).expand(),normalorder2_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Kn.subs(g2c).expand().subs(squarezero).subs(normalorder2_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(Dagger(Kn)*(I*g[1]*gb[1])*Kn).expand().subs(g2c).expand().subs(normalorder2_C).subs(normalorder2_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(Dagger(Kn)*(I*g[1]*g[2])*Kn).expand().subs(g2c).expand().subs(normalorder2_C).subs(normalorder2_C).subs(normalorder2_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(Dagger(Kn)*(I*g[1]*gb[2])*Kn).expand().subs(g2c).expand().subs(normalorder2_C).subs(normalorder2_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "N((1+I)**(0.5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "N(ea(0,1/sqrt(2),1/sqrt(2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "N(exp(I*pi/8))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Initial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# s=Dagger(c[1]-c[2])/sqrt(2)\n",
    "s=(1-Dagger(c[1])*Dagger(c[2]))/sqrt(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((Dagger(s)*s).expand().subs(g2c).expand(),normalorder2_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((Dagger(s)*I*g[1]*gb[1]*s).expand().subs(g2c).expand(),normalorder2_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((Dagger(s)*I*g[1]*g[2]*s).expand().subs(g2c).expand(),normalorder2_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((Dagger(s)*I*g[1]*gb[2]*s).expand().subs(g2c).expand(),normalorder2_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((Dagger(s)*I*gb[1]*g[2]*s).expand().subs(g2c).expand(),normalorder2_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((Dagger(s)*I*gb[1]*gb[2]*s).expand().subs(g2c).expand(),normalorder2_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((Dagger(s)*I*g[2]*gb[2]*s).expand().subs(g2c).expand(),normalorder2_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s0=Dagger(c[1]-c[2])/sqrt(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((Dagger(s0)*s0).expand().subs(g2c).expand(),normalorder2_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((Dagger(s0)*I*g[1]*gb[1]*s0).expand().subs(g2c).expand(),normalorder2_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((Dagger(s0)*I*g[1]*g[2]*s0).expand().subs(g2c).expand(),normalorder2_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((Dagger(s0)*I*g[1]*gb[2]*s0).expand().subs(g2c).expand(),normalorder2_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((g[1]*g[2]*(I*gb[1]*I*gb[2])).expand().subs(g2c).expand(),normalorder2_C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Class A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f={i:Operator(r'f_{}'.format(i)) for i in range(1,5)}\n",
    "fd={i:Dagger(Operator(r'f_{}'.format(i))) for i in range(1,5)}\n",
    "g={i:Operator(r'g_{}'.format(i)) for i in range(1,5)}\n",
    "gd={i:Dagger(Operator(r'g_{}'.format(i))) for i in range(1,5)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "normalorder_f=[list(op.values()) for op in [fd,gd,f,g]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "normalorder_f_linear=[normalorder_f[i][j] for i in range(len(normalorder_f)) for j in range(len(normalorder_f[0]))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def delta(i,j):\n",
    "    return 1 if (i%(len(normalorder_f_linear)//2))==(j%(len(normalorder_f_linear)//2)) else 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "normalorder2_f=[(normalorder_f_linear[j]*normalorder_f_linear[i],0 if i==j else delta(i,j)-normalorder_f_linear[i]*normalorder_f_linear[j]) for i in range(len(normalorder_f_linear)) for j in range(i,len(normalorder_f_linear))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def recursiveapply(expr,subs):\n",
    "    expr1=expr.subs(subs)\n",
    "    while not expr1== expr:\n",
    "        expr=expr1\n",
    "        expr1=expr.subs(subs).expand()\n",
    "    return expr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def commutator(op1,op2,):\n",
    "    return op1*op2-op2*op1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply(commutator(fd[1]*f[2]+fd[2]*f[1],fd[1]*f[1]+fd[2]*f[2]).expand().subs(normalorder2_f),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply(commutator(I*fd[1]*f[2]-I*fd[2]*f[1],fd[1]*f[1]+fd[2]*f[2]).expand().subs(normalorder2_f),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply(commutator(fd[1]*f[1]-fd[2]*f[2],fd[1]*f[1]+fd[2]*f[2]).expand().subs(normalorder2_f),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alpha,beta,gamma=symbols('\\\\alpha,\\\\beta,\\\\gamma',real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Dagger(alpha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=alpha*(fd[1]*f[2]+fd[2]*f[1])\n",
    "# x=(fd[1]*f[2]+fd[2]*f[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y=beta*(-I*fd[1]*f[2]+I*fd[2]*f[1])\n",
    "# y=(-I*fd[1]*f[2]+I*fd[2]*f[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z=I*gamma*(fd[1]*f[1]-fd[2]*f[2])\n",
    "# z=(fd[1]*f[1]-fd[2]*f[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xyz=(alpha-I*beta)*fd[1]*f[2]+(alpha+I*beta)*fd[2]*f[1]+I*gamma*(fd[1]*f[1]-fd[2]*f[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((xyz**1).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((xyz**2).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((xyz**3).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "((alpha-I*beta)**3).expand()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "((alpha-1)*(alpha**2+alpha+1)).expand()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a11,a22,a12,a21,b=symbols('a_11,a_22,a_12,a_21,b',real=True)\n",
    "A11,A22,A12,A21,B=symbols('A_11,A_22,A_12,A_21,B',real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rc=recursiveapply(((a11*fd[1]*f[1]+a22*fd[2]*f[2]+a12*fd[1]*f[2]+a21*fd[2]*f[1]+b*(fd[1]*fd[2]*f[1]*f[2]))*(A11*fd[1]*f[1]+A22*fd[2]*f[2]+A12*fd[1]*f[2]+A21*fd[2]*f[1])).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((xyz**4).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tm=Matrix([[A11,A21,0,0,0],[A12,A22,0,0,0],[0,0,A11,A21,0],[0,0,A12,A22,0],[-A22,A21,A12,-A11,A11+A22]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "init=Matrix([[a11,a12,a21,a22,b]]).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "((tm@init).dot(basis)-rc).expand()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rho,phi=symbols('\\\\rho,\\\\phi',real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "woU_init=[(a11,0),(a22,0),(a12,rho*exp(-I*phi)),(a21,rho*exp(I*phi)),(b,0)]\n",
    "woU_M=[(A11,0),(A22,0),(A12,rho*exp(-I*phi)),(A21,rho*exp(I*phi))]\n",
    "wU_init=[(a11,I*gamma),(a22,-I*gamma),(a12,rho*exp(-I*phi)),(a21,rho*exp(I*phi)),(b,0)]\n",
    "wU_M=[(A11,I*gamma),(A22,-I*gamma),(A12,rho*exp(-I*phi)),(A21,rho*exp(I*phi))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(init).subs(woU_init+woU_M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(tm@init).subs(woU_init+woU_M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(tm@tm@init).subs(woU_init+woU_M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(tm**3@init).subs(woU_init+woU_M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(tm**4@init).subs(woU_init+woU_M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s1=init.subs(wU_init+wU_M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s2=(tm@s1).subs(wU_init+wU_M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s3=(tm@s2).subs(wU_init+wU_M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s4=((tm@s3).subs(wU_init+wU_M))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "factor(s4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s5=((tm@s4).subs(wU_init+wU_M))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "abs(1+I)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Ap=sqrt(gamma**2+2*gamma*im(sqrt(rho**2-gamma**2))+abs(rho**2-gamma**2)+rho**2)\n",
    "Am=sqrt(gamma**2-2*gamma*im(sqrt(rho**2-gamma**2))+abs(rho**2-gamma**2)+rho**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Ap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Am"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "theta=symbols('\\\\theta',real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cp=1/sqrt(2)*(exp(-I*phi)*(sech(theta)+I*tanh(theta))*f[1]+f[2])\n",
    "cp_d=1/sqrt(2)*(exp(I*phi)*(sech(theta)-I*tanh(theta))*fd[1]+fd[2])\n",
    "cm=1/sqrt(2)*(exp(-I*phi)*(sech(theta)-I*tanh(theta))*f[1]+f[2])\n",
    "cm_d=1/sqrt(2)*(exp(I*phi)*(sech(theta)+I*tanh(theta))*fd[1]+fd[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((cp_d*cp-cm_d*cm).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(cp_d*cp-cm_d*cm).expand()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((cp_d*cp-cm_d*cm).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eye(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pm={0:eye(2),1:Matrix([[0,1],[1,0]]),2:Matrix([[0,-I],[I,0]]),3:Matrix([[1,0],[0,-1]])}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TensorProduct(pm[1],pm[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Matrix([fd[1],fd[2],gd[1],gd[2]]).T@TensorProduct(pm[1],pm[0])@Matrix([f[1],f[2],g[1],g[2]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Matrix([fd[1],fd[2],gd[1],gd[2]]).T@TensorProduct(pm[3],pm[0])@Matrix([f[1],f[2],g[1],g[2]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = {(i, j): symbols(f'a_{{{i}{j}}}',real=True) for i in range(4) for j in range(4)}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 393,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_subs=[(val,np.random.rand()) for key,val in a.items()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 384,
   "metadata": {},
   "outputs": [],
   "source": [
    "coef={(i,j):a[i,j] if i in [1,2] else I*a[i,j] for i in range(4) for j in range(4)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "exp_sigma=[coef[i,j]*TensorProduct(pm[i],pm[j]) for i in range(4) for j in range(4)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 391,
   "metadata": {},
   "outputs": [],
   "source": [
    "exp_sigma_nU=[coef[i,j]*TensorProduct(pm[i],pm[j]) for i in range(4) for j in range(4) if i in [1,2]]\n",
    "exp_sigma_U=[coef[i,j]*TensorProduct(pm[i],pm[j]) for i in range(4) for j in range(4) if i in [0,3]]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 395,
   "metadata": {},
   "outputs": [],
   "source": [
    "sigmaU=scipy.linalg.expm(np.array((Add(*exp_sigma_U).subs(a_subs)).tolist()).astype(complex))@scipy.linalg.expm(np.array((Add(*exp_sigma_nU).subs(a_subs)).tolist()).astype(complex))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 366,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sigmaU=scipy.linalg.expm(np.array((Add(*exp_sigma).subs(a_subs)).tolist()).astype(complex))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 396,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.+0.j, -0.+0.j, -0.+0.j,  0.-0.j],\n",
       "       [-0.-0.j,  1.+0.j, -0.-0.j,  0.-0.j],\n",
       "       [-0.-0.j, -0.+0.j, -1.+0.j,  0.+0.j],\n",
       "       [ 0.+0.j,  0.+0.j,  0.+0.j, -1.+0.j]])"
      ]
     },
     "execution_count": 396,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.round(sigmaU.T.conj()@np.kron(np.diag([1,-1]),np.eye(2))@sigmaU,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sigmaU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "exp(sigmaU).H"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(exp(sigmaU).H@TensorProduct(pm[0],pm[3])@exp(sigmaU))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 397,
   "metadata": {},
   "outputs": [],
   "source": [
    "# exp_herm=[coef[i,j]*(Matrix([fd[1],fd[2],gd[1],gd[2]]).T@TensorProduct(pm[i],pm[j])@Matrix([f[1],f[2],g[1],g[2]]))[0,0] for i in range(4) for j in range(4)]\n",
    "exp_herm=[coef[i,j]*(Matrix([fd[1],fd[2],gd[1],gd[2]]).T@TensorProduct(pm[i],pm[j])@Matrix([f[1],f[2],g[1],g[2]]))[0,0] for i in range(4) for j in range(4) if i in [1,2]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 399,
   "metadata": {},
   "outputs": [],
   "source": [
    "exp_herm_simp=simplify(sum(exp_herm).expand())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 400,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a_{10} f_{1}^{\\dagger} g_{1} + a_{10} f_{2}^{\\dagger} g_{2} + a_{10} g_{1}^{\\dagger} f_{1} + a_{10} g_{2}^{\\dagger} f_{2} + a_{11} f_{1}^{\\dagger} g_{2} + a_{11} f_{2}^{\\dagger} g_{1} + a_{11} g_{1}^{\\dagger} f_{2} + a_{11} g_{2}^{\\dagger} f_{1} - i a_{12} f_{1}^{\\dagger} g_{2} + i a_{12} f_{2}^{\\dagger} g_{1} - i a_{12} g_{1}^{\\dagger} f_{2} + i a_{12} g_{2}^{\\dagger} f_{1} + a_{13} f_{1}^{\\dagger} g_{1} - a_{13} f_{2}^{\\dagger} g_{2} + a_{13} g_{1}^{\\dagger} f_{1} - a_{13} g_{2}^{\\dagger} f_{2} - i a_{20} f_{1}^{\\dagger} g_{1} - i a_{20} f_{2}^{\\dagger} g_{2} + i a_{20} g_{1}^{\\dagger} f_{1} + i a_{20} g_{2}^{\\dagger} f_{2} - i a_{21} f_{1}^{\\dagger} g_{2} - i a_{21} f_{2}^{\\dagger} g_{1} + i a_{21} g_{1}^{\\dagger} f_{2} + i a_{21} g_{2}^{\\dagger} f_{1} - a_{22} f_{1}^{\\dagger} g_{2} + a_{22} f_{2}^{\\dagger} g_{1} + a_{22} g_{1}^{\\dagger} f_{2} - a_{22} g_{2}^{\\dagger} f_{1} - i a_{23} f_{1}^{\\dagger} g_{1} + i a_{23} f_{2}^{\\dagger} g_{2} + i a_{23} g_{1}^{\\dagger} f_{1} - i a_{23} g_{2}^{\\dagger} f_{2}$"
      ],
      "text/plain": [
       "a_{10}*Dagger(f_1)*g_1 + a_{10}*Dagger(f_2)*g_2 + a_{10}*Dagger(g_1)*f_1 + a_{10}*Dagger(g_2)*f_2 + a_{11}*Dagger(f_1)*g_2 + a_{11}*Dagger(f_2)*g_1 + a_{11}*Dagger(g_1)*f_2 + a_{11}*Dagger(g_2)*f_1 - I*a_{12}*Dagger(f_1)*g_2 + I*a_{12}*Dagger(f_2)*g_1 - I*a_{12}*Dagger(g_1)*f_2 + I*a_{12}*Dagger(g_2)*f_1 + a_{13}*Dagger(f_1)*g_1 - a_{13}*Dagger(f_2)*g_2 + a_{13}*Dagger(g_1)*f_1 - a_{13}*Dagger(g_2)*f_2 - I*a_{20}*Dagger(f_1)*g_1 - I*a_{20}*Dagger(f_2)*g_2 + I*a_{20}*Dagger(g_1)*f_1 + I*a_{20}*Dagger(g_2)*f_2 - I*a_{21}*Dagger(f_1)*g_2 - I*a_{21}*Dagger(f_2)*g_1 + I*a_{21}*Dagger(g_1)*f_2 + I*a_{21}*Dagger(g_2)*f_1 - a_{22}*Dagger(f_1)*g_2 + a_{22}*Dagger(f_2)*g_1 + a_{22}*Dagger(g_1)*f_2 - a_{22}*Dagger(g_2)*f_1 - I*a_{23}*Dagger(f_1)*g_1 + I*a_{23}*Dagger(f_2)*g_2 + I*a_{23}*Dagger(g_1)*f_1 - I*a_{23}*Dagger(g_2)*f_2"
      ]
     },
     "execution_count": 400,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exp_herm_simp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 401,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(a_{10} - a_{13} - i a_{20} + i a_{23}\\right) f_{2}^{\\dagger} g_{2} + \\left(a_{10} - a_{13} + i a_{20} - i a_{23}\\right) g_{2}^{\\dagger} f_{2} + \\left(a_{10} + a_{13} - i a_{20} - i a_{23}\\right) f_{1}^{\\dagger} g_{1} + \\left(a_{10} + a_{13} + i a_{20} + i a_{23}\\right) g_{1}^{\\dagger} f_{1} + \\left(a_{11} - i a_{12} - i a_{21} - a_{22}\\right) f_{1}^{\\dagger} g_{2} + \\left(a_{11} - i a_{12} + i a_{21} + a_{22}\\right) g_{1}^{\\dagger} f_{2} + \\left(a_{11} + i a_{12} - i a_{21} + a_{22}\\right) f_{2}^{\\dagger} g_{1} + \\left(a_{11} + i a_{12} + i a_{21} - a_{22}\\right) g_{2}^{\\dagger} f_{1}$"
      ],
      "text/plain": [
       "(a_{10} - a_{13} - I*a_{20} + I*a_{23})*Dagger(f_2)*g_2 + (a_{10} - a_{13} + I*a_{20} - I*a_{23})*Dagger(g_2)*f_2 + (a_{10} + a_{13} - I*a_{20} - I*a_{23})*Dagger(f_1)*g_1 + (a_{10} + a_{13} + I*a_{20} + I*a_{23})*Dagger(g_1)*f_1 + (a_{11} - I*a_{12} - I*a_{21} - a_{22})*Dagger(f_1)*g_2 + (a_{11} - I*a_{12} + I*a_{21} + a_{22})*Dagger(g_1)*f_2 + (a_{11} + I*a_{12} - I*a_{21} + a_{22})*Dagger(f_2)*g_1 + (a_{11} + I*a_{12} + I*a_{21} - a_{22})*Dagger(g_2)*f_1"
      ]
     },
     "execution_count": 401,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "collect_coeff(exp_herm_simp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 403,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}0 & 0 & a_{10} + a_{13} - i a_{20} - i a_{23} & a_{11} - i a_{12} - i a_{21} - a_{22}\\\\0 & 0 & a_{11} + i a_{12} - i a_{21} + a_{22} & a_{10} - a_{13} - i a_{20} + i a_{23}\\\\a_{10} + a_{13} + i a_{20} + i a_{23} & a_{11} - i a_{12} + i a_{21} + a_{22} & 0 & 0\\\\a_{11} + i a_{12} + i a_{21} - a_{22} & a_{10} - a_{13} + i a_{20} - i a_{23} & 0 & 0\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[                                    0,                                     0, a_{10} + a_{13} - I*a_{20} - I*a_{23}, a_{11} - I*a_{12} - I*a_{21} - a_{22}],\n",
       "[                                    0,                                     0, a_{11} + I*a_{12} - I*a_{21} + a_{22}, a_{10} - a_{13} - I*a_{20} + I*a_{23}],\n",
       "[a_{10} + a_{13} + I*a_{20} + I*a_{23}, a_{11} - I*a_{12} + I*a_{21} + a_{22},                                     0,                                     0],\n",
       "[a_{11} + I*a_{12} + I*a_{21} - a_{22}, a_{10} - a_{13} + I*a_{20} - I*a_{23},                                     0,                                     0]])"
      ]
     },
     "execution_count": 403,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Add(*exp_sigma_nU)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def collect_coeff(expr):\n",
    "    assert expr.func==Add, 'Only support addition'\n",
    "    # Assume the order is always (commutative, non-commutative)\n",
    "    terms={}\n",
    "\n",
    "    for arg in expr.args:\n",
    "        for i in range(0,len(arg.args)):\n",
    "            if not arg.args[i].is_commutative:\n",
    "                break\n",
    "        commutative = Mul(*arg.args[:i]) if i >0 else 1\n",
    "        noncommutative = Mul(*arg.args[i:])\n",
    "        if noncommutative in terms:\n",
    "            terms[noncommutative]+=commutative\n",
    "        else:\n",
    "            terms[noncommutative]=commutative\n",
    "    rs=0\n",
    "    for key,val in terms.items():\n",
    "        rs+=val*key\n",
    "    return rs\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "exp_herm[7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cp=(exp(-I*phi)*(I*gamma+sqrt(rho**2-gamma**2))*f[1]+rho*f[2])\n",
    "cp_d=(exp(I*phi)*(-I*gamma+conjugate(sqrt(rho**2-gamma**2)))*fd[1]+rho*fd[2])\n",
    "cm=(exp(-I*phi)*(I*gamma-sqrt(rho**2-gamma**2))*f[1]+rho*f[2])\n",
    "cm_d=(exp(I*phi)*(-I*gamma-conjugate(sqrt(rho**2-gamma**2)))*fd[1]+rho*fd[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cp=1/Ap*(exp(-I*phi)*(I*gamma+sqrt(rho**2-gamma**2))*f[1]+rho*f[2])\n",
    "cp_d=1/Ap*(exp(I*phi)*(-I*gamma+conjugate(sqrt(rho**2-gamma**2)))*fd[1]+rho*fd[2])\n",
    "cm=1/Am*(exp(-I*phi)*(I*gamma-sqrt(rho**2-gamma**2))*f[1]+rho*f[2])\n",
    "cm_d=1/Am*(exp(I*phi)*(-I*gamma-conjugate(sqrt(rho**2-gamma**2)))*fd[1]+rho*fd[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cp_d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cm_d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lp=sqrt(rho**2-gamma**2)\n",
    "lm=-sqrt(rho**2-gamma**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((cp_d*cp).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply(commutator(cp_d*cp,cm_d*cm).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lp*cp_d*cp+lm*cm_d*cm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((lp*cp_d*cp+lm*cm_d*cm).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "basis=Matrix([(fd[1]*f[1]),(fd[1]*f[2]),(fd[2]*f[1]),(fd[2]*f[2]),(fd[1]*fd[2]*f[1]*f[2])])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "basis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "phi=Symbol(r'\\phi',real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fp_d=1/sqrt(2)*(fd[1]+exp(-I*phi)*fd[2])\n",
    "fp=1/sqrt(2)*(f[1]+exp(I*phi)*f[2])\n",
    "fm_d=1/sqrt(2)*(fd[1]-exp(-I*phi)*fd[2])\n",
    "fm=1/sqrt(2)*(f[1]-exp(I*phi)*f[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(fp_d*fp+fm_d*fm).expand()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply(commutator(fp_d*fp,fm_d*fm).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply(((fp_d*fp)**2-(fp_d*fp)).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def group_noncommutative(expr, op):\n",
    "    # Ensure the expression is expanded so we can iterate through terms\n",
    "    expr = expr.expand()\n",
    "    \n",
    "    # Separate the terms involving the operator `op`\n",
    "    op_terms = [term for term in expr.args if op in term.free_symbols]\n",
    "    \n",
    "    # Separate the terms not involving the operator `op`\n",
    "    other_terms = [term for term in expr.args if op not in term.free_symbols]\n",
    "    \n",
    "    # Sum the coefficients of the terms involving `op`\n",
    "    op_coeff = sum(term.coeff(op) for term in op_terms)\n",
    "    \n",
    "    # Reconstruct the grouped expression\n",
    "    grouped_expr = op_coeff*op + Add(*other_terms)\n",
    "    \n",
    "    return grouped_expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "group_noncommutative(alpha*f[1]+beta*f[1]+ gamma*Dagger(f[1]), f[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply(commutator(x,y).expand()-2*I*z,normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply(commutator(y,z).expand()-2*I*x,normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply(commutator(z,x).expand()-2*I*y,normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xy=recursiveapply(commutator(x+y+z,x+y-z).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(x+y + (xy/2).simplify())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xy3=recursiveapply(commutator(x-y,xy).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xy3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x+y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x.subs()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply(commutator(x,y).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply(commutator(fd[1]*f[1]-fd[2]*f[2],fd[1]*f[1]+fd[2]*f[2]).expand().subs(normalorder2_f),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply(((fd[1]+gd[1])*f[1]*fd[1]*g[1]*gd[1]*(f[1]+g[1])).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply(((fd[1]-gd[1])*f[1]*fd[1]*g[1]*gd[1]*(f[1]-g[1])).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply(((1+fd[1]*gd[1])*f[1]*fd[1]*g[1]*gd[1]*(1+g[1]*f[1])).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply(((1-fd[1]*gd[1])*f[1]*fd[1]*g[1]*gd[1]*(1-g[1]*f[1])).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((gd[1]*f[1]+fd[1]*g[1]).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply(((gd[1]*f[1]+fd[1]*g[1])**2).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply(((gd[1]*f[1]+fd[1]*g[1])**3).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply(((gd[1]*f[1]+fd[1]*g[1])**4).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "((gd[1]*f[1]+fd[1]*g[1])**2).expand()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "((gd[1]*f[1]+fd[1]*g[1])**3).expand()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply(((-I*gd[1]*f[1]+I*fd[1]*g[1])*(gd[1]*f[1]+fd[1]*g[1])- (gd[1]*f[1]+fd[1]*g[1])*(-I*gd[1]*f[1]+I*fd[1]*g[1])).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((-I*gd[1]*f[1]+I*fd[1]*g[1]).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply(((-I*gd[1]*f[1]+I*fd[1]*g[1])**2).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply(((-I*gd[1]*f[1]+I*fd[1]*g[1])**3).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply(((-I*gd[1]*f[1]+I*fd[1]*g[1])**4).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alpha,beta,=symbols(r'\\alpha,\\beta')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alpha"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "exp1=(1+(cosh(alpha)-1)*(2*fd[1]*gd[1]*f[1]*g[1]+fd[1]*f[1]+gd[1]*g[1])+sinh(alpha)*(fd[1]*g[1]+gd[1]*f[1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "exp2=(1+(cosh(beta)-1)*(2*fd[1]*gd[1]*f[1]*g[1]+fd[1]*f[1]+gd[1]*g[1])+sinh(beta)*(I*fd[1]*g[1]-I*gd[1]*f[1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((exp1*exp2).expand(),normalorder2_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((exp1*exp2).expand(),normalorder2_f).simplify()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Gamma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import *\n",
    "from sympy.physics.quantum import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "g={i:Operator('\\gamma_{}'.format(i)) for i in range(2)}\n",
    "eta={i:Operator('\\eta_{}'.format(i)) for i in range(2)}\n",
    "xi={i:Operator(r'\\xi_{}'.format(i)) for i in range(2)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=Symbol('n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "selfjoint=[(Dagger(gi),gi) for gi in list(g.values())+list(eta.values())+list(xi.values())]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "squareone=[(gi**2,1) for gi in list(g.values())+list(eta.values())+list(xi.values())]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "normalorder=[gi[i] for gi in [xi,eta,g] for i in range(len(g))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "normalorder2=[(normalorder[j]*normalorder[i],-normalorder[i]*normalorder[j])  if j>i else (normalorder[j]*normalorder[i],1) for i in range(len(normalorder)) for j in range(i,len(normalorder))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "ket0=(g[0]-I*g[1])/2\n",
    "bra0=(eta[0]+I*eta[1])/2\n",
    "ket1=(g[0]+I*g[1])/2\n",
    "bra1=(eta[0]-I*eta[1])/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "tensor=(1+I*xi[0]*xi[1])/2*(1-I*eta[0]*eta[1])/2*(1+I*g[0]*g[1])/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "tensor0=(1-I*eta[0]*eta[1])/2*(1+I*g[0]*g[1])/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "tensor0_p=(1+I*eta[0]*eta[1])/2*(1+I*g[0]*g[1])/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "p=(1+I*g[0]*eta[0])/2 * (1+I*g[1]*eta[1])/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{i}{4} - \\frac{i \\eta_{0} \\eta_{1} \\gamma_{0} \\gamma_{1}}{4} - \\frac{\\eta_{0} \\gamma_{0}}{4} - \\frac{\\eta_{1} \\gamma_{1}}{4}$"
      ],
      "text/plain": [
       "-I/4 - I*\\eta_0*\\eta_1*\\gamma_0*\\gamma_1/4 - \\eta_0*\\gamma_0/4 - \\eta_1*\\gamma_1/4"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursiveapply((p*(ket0+ket1)*(bra0+bra1)).expand(),normalorder2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [],
   "source": [
    "identity=(((xi[0]-I*xi[1]))*((eta[0]+I*eta[1])) *1/2+((xi[0]+I*xi[1]))*((eta[0]-I*eta[1]))*1/2)/sqrt(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\sqrt{2} \\xi_{0} \\eta_{0}}{2} + \\frac{\\sqrt{2} \\xi_{1} \\eta_{1}}{2}$"
      ],
      "text/plain": [
       "sqrt(2)*\\xi_0*\\eta_0/2 + sqrt(2)*\\xi_1*\\eta_1/2"
      ]
     },
     "execution_count": 211,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "identity.expand()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [],
   "source": [
    "rho=recursiveapply((identity*Dagger(identity)).expand().subs(selfjoint),normalorder2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "(unicode error) 'unicodeescape' codec can't decode bytes in position 2-3: truncated \\xXX escape (1627185929.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"/tmp/ipykernel_6461/1627185929.py\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    c_xi=Symbol('c_\\xi')\u001b[0m\n\u001b[0m                ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m (unicode error) 'unicodeescape' codec can't decode bytes in position 2-3: truncated \\xXX escape\n"
     ]
    }
   ],
   "source": [
    "c_xi=Symbol('c_\\xi')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(1+c_xi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1 + \\xi_{0} \\xi_{1} \\eta_{0} \\eta_{1}$"
      ],
      "text/plain": [
       "1 + \\xi_0*\\xi_1*\\eta_0*\\eta_1"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rho"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{i \\xi_{0}}{16} - \\frac{\\xi_{0} \\eta_{0} \\eta_{1}}{16} + \\frac{i \\xi_{0} \\eta_{0} \\eta_{1} \\gamma_{0} \\gamma_{1}}{16} + \\frac{\\xi_{0} \\eta_{0} \\gamma_{0}}{16} - \\frac{i \\xi_{0} \\eta_{0} \\gamma_{1}}{16} + \\frac{i \\xi_{0} \\eta_{1} \\gamma_{0}}{16} + \\frac{\\xi_{0} \\eta_{1} \\gamma_{1}}{16} + \\frac{\\xi_{0} \\gamma_{0} \\gamma_{1}}{16} + \\frac{\\xi_{1}}{16} + \\frac{i \\xi_{1} \\eta_{0} \\eta_{1}}{16} + \\frac{\\xi_{1} \\eta_{0} \\eta_{1} \\gamma_{0} \\gamma_{1}}{16} - \\frac{i \\xi_{1} \\eta_{0} \\gamma_{0}}{16} - \\frac{\\xi_{1} \\eta_{0} \\gamma_{1}}{16} + \\frac{\\xi_{1} \\eta_{1} \\gamma_{0}}{16} - \\frac{i \\xi_{1} \\eta_{1} \\gamma_{1}}{16} - \\frac{i \\xi_{1} \\gamma_{0} \\gamma_{1}}{16}$"
      ],
      "text/plain": [
       "I*\\xi_0/16 - \\xi_0*\\eta_0*\\eta_1/16 + I*\\xi_0*\\eta_0*\\eta_1*\\gamma_0*\\gamma_1/16 + \\xi_0*\\eta_0*\\gamma_0/16 - I*\\xi_0*\\eta_0*\\gamma_1/16 + I*\\xi_0*\\eta_1*\\gamma_0/16 + \\xi_0*\\eta_1*\\gamma_1/16 + \\xi_0*\\gamma_0*\\gamma_1/16 + \\xi_1/16 + I*\\xi_1*\\eta_0*\\eta_1/16 + \\xi_1*\\eta_0*\\eta_1*\\gamma_0*\\gamma_1/16 - I*\\xi_1*\\eta_0*\\gamma_0/16 - \\xi_1*\\eta_0*\\gamma_1/16 + \\xi_1*\\eta_1*\\gamma_0/16 - I*\\xi_1*\\eta_1*\\gamma_1/16 - I*\\xi_1*\\gamma_0*\\gamma_1/16"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursiveapply((p*identity*ket0).expand(),normalorder2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{i \\xi_{0}}{16} + \\frac{\\xi_{0} \\eta_{0} \\eta_{1}}{16} + \\frac{i \\xi_{0} \\eta_{0} \\eta_{1} \\gamma_{0} \\gamma_{1}}{16} + \\frac{\\xi_{0} \\eta_{0} \\gamma_{0}}{16} + \\frac{i \\xi_{0} \\eta_{0} \\gamma_{1}}{16} - \\frac{i \\xi_{0} \\eta_{1} \\gamma_{0}}{16} + \\frac{\\xi_{0} \\eta_{1} \\gamma_{1}}{16} - \\frac{\\xi_{0} \\gamma_{0} \\gamma_{1}}{16} - \\frac{\\xi_{1}}{16} + \\frac{i \\xi_{1} \\eta_{0} \\eta_{1}}{16} - \\frac{\\xi_{1} \\eta_{0} \\eta_{1} \\gamma_{0} \\gamma_{1}}{16} + \\frac{i \\xi_{1} \\eta_{0} \\gamma_{0}}{16} - \\frac{\\xi_{1} \\eta_{0} \\gamma_{1}}{16} + \\frac{\\xi_{1} \\eta_{1} \\gamma_{0}}{16} + \\frac{i \\xi_{1} \\eta_{1} \\gamma_{1}}{16} - \\frac{i \\xi_{1} \\gamma_{0} \\gamma_{1}}{16}$"
      ],
      "text/plain": [
       "I*\\xi_0/16 + \\xi_0*\\eta_0*\\eta_1/16 + I*\\xi_0*\\eta_0*\\eta_1*\\gamma_0*\\gamma_1/16 + \\xi_0*\\eta_0*\\gamma_0/16 + I*\\xi_0*\\eta_0*\\gamma_1/16 - I*\\xi_0*\\eta_1*\\gamma_0/16 + \\xi_0*\\eta_1*\\gamma_1/16 - \\xi_0*\\gamma_0*\\gamma_1/16 - \\xi_1/16 + I*\\xi_1*\\eta_0*\\eta_1/16 - \\xi_1*\\eta_0*\\eta_1*\\gamma_0*\\gamma_1/16 + I*\\xi_1*\\eta_0*\\gamma_0/16 - \\xi_1*\\eta_0*\\gamma_1/16 + \\xi_1*\\eta_1*\\gamma_0/16 + I*\\xi_1*\\eta_1*\\gamma_1/16 - I*\\xi_1*\\gamma_0*\\gamma_1/16"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursiveapply((p*identity*ket1).expand(),normalorder2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0$"
      ],
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursiveapply((p*ket1*bra0).expand(),normalorder2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{i}{8} - \\frac{\\eta_{0} \\eta_{1}}{8} - \\frac{i \\eta_{0} \\eta_{1} \\gamma_{0} \\gamma_{1}}{8} - \\frac{\\eta_{0} \\gamma_{0}}{8} - \\frac{i \\eta_{0} \\gamma_{1}}{8} + \\frac{i \\eta_{1} \\gamma_{0}}{8} - \\frac{\\eta_{1} \\gamma_{1}}{8} + \\frac{\\gamma_{0} \\gamma_{1}}{8}$"
      ],
      "text/plain": [
       "-I/8 - \\eta_0*\\eta_1/8 - I*\\eta_0*\\eta_1*\\gamma_0*\\gamma_1/8 - \\eta_0*\\gamma_0/8 - I*\\eta_0*\\gamma_1/8 + I*\\eta_1*\\gamma_0/8 - \\eta_1*\\gamma_1/8 + \\gamma_0*\\gamma_1/8"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursiveapply((p*ket1*bra1).expand(),normalorder2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1}{2} + \\frac{i \\xi_{0} \\xi_{1}}{2}$"
      ],
      "text/plain": [
       "1/2 + I*\\xi_0*\\xi_1/2"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursiveapply(((xi[0]-I*xi[1])/2 * (xi[0]+I*xi[1])/2).expand(),normalorder2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\left(\\xi_{0} - i \\xi_{1}\\right) \\left(\\eta_{0} + i \\eta_{1}\\right)}{4}$"
      ],
      "text/plain": [
       "(\\xi_0 - I*\\xi_1)*(\\eta_0 + I*\\eta_1)/4"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Gamma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\eta_{0} + i \\eta_{1}}{2}$"
      ],
      "text/plain": [
       "(\\eta_0 + I*\\eta_1)/2"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bra0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\gamma_{0} - i \\gamma_{1}}{2}$"
      ],
      "text/plain": [
       "(\\gamma_0 - I*\\gamma_1)/2"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ket0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{i \\xi_{0}}{16} - \\frac{\\xi_{0} \\eta_{0} \\eta_{1}}{16} + \\frac{i \\xi_{0} \\eta_{0} \\eta_{1} \\gamma_{0} \\gamma_{1}}{16} + \\frac{\\xi_{0} \\eta_{0} \\gamma_{0}}{16} - \\frac{i \\xi_{0} \\eta_{0} \\gamma_{1}}{16} + \\frac{i \\xi_{0} \\eta_{1} \\gamma_{0}}{16} + \\frac{\\xi_{0} \\eta_{1} \\gamma_{1}}{16} + \\frac{\\xi_{0} \\gamma_{0} \\gamma_{1}}{16} + \\frac{\\xi_{1}}{16} + \\frac{i \\xi_{1} \\eta_{0} \\eta_{1}}{16} + \\frac{\\xi_{1} \\eta_{0} \\eta_{1} \\gamma_{0} \\gamma_{1}}{16} - \\frac{i \\xi_{1} \\eta_{0} \\gamma_{0}}{16} - \\frac{\\xi_{1} \\eta_{0} \\gamma_{1}}{16} + \\frac{\\xi_{1} \\eta_{1} \\gamma_{0}}{16} - \\frac{i \\xi_{1} \\eta_{1} \\gamma_{1}}{16} - \\frac{i \\xi_{1} \\gamma_{0} \\gamma_{1}}{16}$"
      ],
      "text/plain": [
       "I*\\xi_0/16 - \\xi_0*\\eta_0*\\eta_1/16 + I*\\xi_0*\\eta_0*\\eta_1*\\gamma_0*\\gamma_1/16 + \\xi_0*\\eta_0*\\gamma_0/16 - I*\\xi_0*\\eta_0*\\gamma_1/16 + I*\\xi_0*\\eta_1*\\gamma_0/16 + \\xi_0*\\eta_1*\\gamma_1/16 + \\xi_0*\\gamma_0*\\gamma_1/16 + \\xi_1/16 + I*\\xi_1*\\eta_0*\\eta_1/16 + \\xi_1*\\eta_0*\\eta_1*\\gamma_0*\\gamma_1/16 - I*\\xi_1*\\eta_0*\\gamma_0/16 - \\xi_1*\\eta_0*\\gamma_1/16 + \\xi_1*\\eta_1*\\gamma_0/16 - I*\\xi_1*\\eta_1*\\gamma_1/16 - I*\\xi_1*\\gamma_0*\\gamma_1/16"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursiveapply((p*Gamma*ket0).expand(),normalorder2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((p*).expand(),normalorder2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1}{8} - \\frac{i \\eta_{0} \\eta_{1}}{8} + \\frac{\\eta_{0} \\eta_{1} \\gamma_{0} \\gamma_{1}}{8} - \\frac{i \\eta_{0} \\gamma_{0}}{8} + \\frac{\\eta_{0} \\gamma_{1}}{8} - \\frac{\\eta_{1} \\gamma_{0}}{8} - \\frac{i \\eta_{1} \\gamma_{1}}{8} + \\frac{i \\gamma_{0} \\gamma_{1}}{8}$"
      ],
      "text/plain": [
       "1/8 - I*\\eta_0*\\eta_1/8 + \\eta_0*\\eta_1*\\gamma_0*\\gamma_1/8 - I*\\eta_0*\\gamma_0/8 + \\eta_0*\\gamma_1/8 - \\eta_1*\\gamma_0/8 - I*\\eta_1*\\gamma_1/8 + I*\\gamma_0*\\gamma_1/8"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursiveapply((p*tensor0).expand(),normalorder2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "tensor_neg=(1-I*xi[0]*xi[1])/2*(1+I*eta[0]*eta[1])/2*(1-I*g[0]*g[1])/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1}{16} + \\frac{i \\eta_{0} \\eta_{1}}{16} + \\frac{\\eta_{0} \\eta_{1} \\gamma_{0} \\gamma_{1}}{16} - \\frac{i \\eta_{0} \\gamma_{0}}{16} - \\frac{\\eta_{0} \\gamma_{1}}{16} + \\frac{\\eta_{1} \\gamma_{0}}{16} - \\frac{i \\eta_{1} \\gamma_{1}}{16} - \\frac{i \\gamma_{0} \\gamma_{1}}{16} - \\frac{i \\xi_{0} \\xi_{1}}{16} + \\frac{\\xi_{0} \\xi_{1} \\eta_{0} \\eta_{1}}{16} - \\frac{i \\xi_{0} \\xi_{1} \\eta_{0} \\eta_{1} \\gamma_{0} \\gamma_{1}}{16} - \\frac{\\xi_{0} \\xi_{1} \\eta_{0} \\gamma_{0}}{16} + \\frac{i \\xi_{0} \\xi_{1} \\eta_{0} \\gamma_{1}}{16} - \\frac{i \\xi_{0} \\xi_{1} \\eta_{1} \\gamma_{0}}{16} - \\frac{\\xi_{0} \\xi_{1} \\eta_{1} \\gamma_{1}}{16} - \\frac{\\xi_{0} \\xi_{1} \\gamma_{0} \\gamma_{1}}{16}$"
      ],
      "text/plain": [
       "1/16 + I*\\eta_0*\\eta_1/16 + \\eta_0*\\eta_1*\\gamma_0*\\gamma_1/16 - I*\\eta_0*\\gamma_0/16 - \\eta_0*\\gamma_1/16 + \\eta_1*\\gamma_0/16 - I*\\eta_1*\\gamma_1/16 - I*\\gamma_0*\\gamma_1/16 - I*\\xi_0*\\xi_1/16 + \\xi_0*\\xi_1*\\eta_0*\\eta_1/16 - I*\\xi_0*\\xi_1*\\eta_0*\\eta_1*\\gamma_0*\\gamma_1/16 - \\xi_0*\\xi_1*\\eta_0*\\gamma_0/16 + I*\\xi_0*\\xi_1*\\eta_0*\\gamma_1/16 - I*\\xi_0*\\xi_1*\\eta_1*\\gamma_0/16 - \\xi_0*\\xi_1*\\eta_1*\\gamma_1/16 - \\xi_0*\\xi_1*\\gamma_0*\\gamma_1/16"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursiveapply((p*tensor0_p+p*tensor_neg).expand(),normalorder2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1}{16} - \\frac{i \\eta_{0} \\eta_{1}}{16} + \\frac{\\eta_{0} \\eta_{1} \\gamma_{0} \\gamma_{1}}{16} - \\frac{i \\eta_{0} \\gamma_{0}}{16} + \\frac{\\eta_{0} \\gamma_{1}}{16} - \\frac{\\eta_{1} \\gamma_{0}}{16} - \\frac{i \\eta_{1} \\gamma_{1}}{16} + \\frac{i \\gamma_{0} \\gamma_{1}}{16} + \\frac{i \\xi_{0} \\xi_{1}}{16} + \\frac{\\xi_{0} \\xi_{1} \\eta_{0} \\eta_{1}}{16} + \\frac{i \\xi_{0} \\xi_{1} \\eta_{0} \\eta_{1} \\gamma_{0} \\gamma_{1}}{16} + \\frac{\\xi_{0} \\xi_{1} \\eta_{0} \\gamma_{0}}{16} + \\frac{i \\xi_{0} \\xi_{1} \\eta_{0} \\gamma_{1}}{16} - \\frac{i \\xi_{0} \\xi_{1} \\eta_{1} \\gamma_{0}}{16} + \\frac{\\xi_{0} \\xi_{1} \\eta_{1} \\gamma_{1}}{16} - \\frac{\\xi_{0} \\xi_{1} \\gamma_{0} \\gamma_{1}}{16}$"
      ],
      "text/plain": [
       "1/16 - I*\\eta_0*\\eta_1/16 + \\eta_0*\\eta_1*\\gamma_0*\\gamma_1/16 - I*\\eta_0*\\gamma_0/16 + \\eta_0*\\gamma_1/16 - \\eta_1*\\gamma_0/16 - I*\\eta_1*\\gamma_1/16 + I*\\gamma_0*\\gamma_1/16 + I*\\xi_0*\\xi_1/16 + \\xi_0*\\xi_1*\\eta_0*\\eta_1/16 + I*\\xi_0*\\xi_1*\\eta_0*\\eta_1*\\gamma_0*\\gamma_1/16 + \\xi_0*\\xi_1*\\eta_0*\\gamma_0/16 + I*\\xi_0*\\xi_1*\\eta_0*\\gamma_1/16 - I*\\xi_0*\\xi_1*\\eta_1*\\gamma_0/16 + \\xi_0*\\xi_1*\\eta_1*\\gamma_1/16 - \\xi_0*\\xi_1*\\gamma_0*\\gamma_1/16"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursiveapply((p*tensor).expand(),normalorder2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursiveapply((p*tensor).expand(),normalorder2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\eta_{0} \\gamma_{0}$"
      ],
      "text/plain": [
       "-\\eta_0*\\gamma_0"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursiveapply((g[1]*eta[1]*eta[0]*eta[1]*g[0]*g[1]),normalorder2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\gamma_{0} \\gamma_{1}$"
      ],
      "text/plain": [
       "\\gamma_0*\\gamma_1"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursiveapply((g[0]*eta[0]*g[1]*eta[1]*eta[0]*eta[1]),normalorder2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 + 2 i \\gamma_{0} \\gamma_{1}$"
      ],
      "text/plain": [
       "2 + 2*I*\\gamma_0*\\gamma_1"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursiveapply(((1-I*eta[0]*eta[1])*(1+n*I*g[0]*g[1])).expand(),normalorder2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [],
   "source": [
    "Gamma=(1-I*xi[0]*xi[1])/2*(1+I*eta[0]*eta[1])/2\n",
    "# Gamma=(xi[0]-I*xi[1])/2 * (eta[0]+I*eta[1])/2+ (xi[0]+I*xi[1])/2 * (eta[0]-I*eta[1])/2\n",
    "# Gamma=(\n",
    "#     (1+I*xi[0]*xi[1])/2*(1-I*eta[0]*eta[1])/2 \n",
    "#  +(1-I*xi[0]*xi[1])/2*(1+I*eta[0]*eta[1])/2 \n",
    "#  +I*(xi[0]-I*xi[1])/2 * (eta[0]+I*eta[1])/2\n",
    "#  +I*(xi[0]+I*xi[1])/2 * (eta[0]-I*eta[1])/2\n",
    "   # )\n",
    "\n",
    "# Gamma=rho"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [],
   "source": [
    "simp=recursiveapply(Gamma.expand(),normalorder2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1}{4} + \\frac{i \\eta_{0} \\eta_{1}}{4} - \\frac{i \\xi_{0} \\xi_{1}}{4} + \\frac{\\xi_{0} \\xi_{1} \\eta_{0} \\eta_{1}}{4}$"
      ],
      "text/plain": [
       "1/4 + I*\\eta_0*\\eta_1/4 - I*\\xi_0*\\xi_1/4 + \\xi_0*\\xi_1*\\eta_0*\\eta_1/4"
      ]
     },
     "execution_count": 227,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1}{4} + \\frac{i \\eta_{0} \\eta_{1}}{4} - \\frac{i \\xi_{0} \\xi_{1}}{4} + \\frac{\\xi_{0} \\xi_{1} \\eta_{0} \\eta_{1}}{4}$"
      ],
      "text/plain": [
       "1/4 + I*\\eta_0*\\eta_1/4 - I*\\xi_0*\\xi_1/4 + \\xi_0*\\xi_1*\\eta_0*\\eta_1/4"
      ]
     },
     "execution_count": 228,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursiveapply(Dagger(simp).subs(selfjoint),normalorder2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1}{4} + \\frac{i \\eta_{0} \\eta_{1}}{4} - \\frac{i \\xi_{0} \\xi_{1}}{4} + \\frac{\\xi_{0} \\xi_{1} \\eta_{0} \\eta_{1}}{4}$"
      ],
      "text/plain": [
       "1/4 + I*\\eta_0*\\eta_1/4 - I*\\xi_0*\\xi_1/4 + \\xi_0*\\xi_1*\\eta_0*\\eta_1/4"
      ]
     },
     "execution_count": 229,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursiveapply((Gamma).expand(),normalorder2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{i}{4} - \\frac{\\eta_{0} \\eta_{1}}{4} + \\frac{\\xi_{0} \\xi_{1}}{4} + \\frac{i \\xi_{0} \\xi_{1} \\eta_{0} \\eta_{1}}{4}$"
      ],
      "text/plain": [
       "I/4 - \\eta_0*\\eta_1/4 + \\xi_0*\\xi_1/4 + I*\\xi_0*\\xi_1*\\eta_0*\\eta_1/4"
      ]
     },
     "execution_count": 230,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursiveapply((I*eta[0]*eta[0]*Gamma).expand(),normalorder2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1}{4} + \\frac{i \\eta_{0} \\eta_{1}}{4} - \\frac{i \\xi_{0} \\xi_{1}}{4} + \\frac{\\xi_{0} \\xi_{1} \\eta_{0} \\eta_{1}}{4}$"
      ],
      "text/plain": [
       "1/4 + I*\\eta_0*\\eta_1/4 - I*\\xi_0*\\xi_1/4 + \\xi_0*\\xi_1*\\eta_0*\\eta_1/4"
      ]
     },
     "execution_count": 231,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursiveapply((I*eta[0]*eta[1]*Gamma).expand(),normalorder2) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{i \\xi_{0} \\eta_{0}}{4} + \\frac{\\xi_{0} \\eta_{1}}{4} - \\frac{\\xi_{1} \\eta_{0}}{4} - \\frac{i \\xi_{1} \\eta_{1}}{4}$"
      ],
      "text/plain": [
       "-I*\\xi_0*\\eta_0/4 + \\xi_0*\\eta_1/4 - \\xi_1*\\eta_0/4 - I*\\xi_1*\\eta_1/4"
      ]
     },
     "execution_count": 232,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursiveapply((I*eta[0]*xi[0]*Gamma).expand(),normalorder2) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\xi_{0} \\eta_{0}}{4} + \\frac{i \\xi_{0} \\eta_{1}}{4} - \\frac{i \\xi_{1} \\eta_{0}}{4} + \\frac{\\xi_{1} \\eta_{1}}{4}$"
      ],
      "text/plain": [
       "\\xi_0*\\eta_0/4 + I*\\xi_0*\\eta_1/4 - I*\\xi_1*\\eta_0/4 + \\xi_1*\\eta_1/4"
      ]
     },
     "execution_count": 233,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursiveapply((I*eta[0]*xi[1]*Gamma).expand(),normalorder2) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{\\xi_{0} \\eta_{0}}{4} - \\frac{i \\xi_{0} \\eta_{1}}{4} + \\frac{i \\xi_{1} \\eta_{0}}{4} - \\frac{\\xi_{1} \\eta_{1}}{4}$"
      ],
      "text/plain": [
       "-\\xi_0*\\eta_0/4 - I*\\xi_0*\\eta_1/4 + I*\\xi_1*\\eta_0/4 - \\xi_1*\\eta_1/4"
      ]
     },
     "execution_count": 234,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursiveapply((I*eta[1]*xi[0]*Gamma).expand(),normalorder2) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{i \\xi_{0} \\eta_{0}}{4} + \\frac{\\xi_{0} \\eta_{1}}{4} - \\frac{\\xi_{1} \\eta_{0}}{4} - \\frac{i \\xi_{1} \\eta_{1}}{4}$"
      ],
      "text/plain": [
       "-I*\\xi_0*\\eta_0/4 + \\xi_0*\\eta_1/4 - \\xi_1*\\eta_0/4 - I*\\xi_1*\\eta_1/4"
      ]
     },
     "execution_count": 235,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursiveapply((I*eta[1]*xi[1]*Gamma).expand(),normalorder2) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{1}{4} - \\frac{i \\eta_{0} \\eta_{1}}{4} + \\frac{i \\xi_{0} \\xi_{1}}{4} - \\frac{\\xi_{0} \\xi_{1} \\eta_{0} \\eta_{1}}{4}$"
      ],
      "text/plain": [
       "-1/4 - I*\\eta_0*\\eta_1/4 + I*\\xi_0*\\xi_1/4 - \\xi_0*\\xi_1*\\eta_0*\\eta_1/4"
      ]
     },
     "execution_count": 236,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursiveapply((I*xi[0]*xi[1]*Gamma).expand(),normalorder2) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{i \\eta_{0} \\eta_{1} \\cdot \\left(1 - \\eta_{0} \\eta_{1}\\right)}{2}$"
      ],
      "text/plain": [
       "I*\\eta_0*\\eta_1*(1 - \\eta_0*\\eta_1)/2"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(I*eta[0]*eta[1])*(1-eta[0]*eta[1])/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{1}{2} + \\frac{i \\eta_{0} \\eta_{1}}{2}$"
      ],
      "text/plain": [
       "-1/2 + I*\\eta_0*\\eta_1/2"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursiveapply(((I*eta[0]*eta[1])*(1-I*eta[0]*eta[1])/2).expand(),normalorder2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1}{2} + \\frac{i \\eta_{0} \\eta_{1}}{2}$"
      ],
      "text/plain": [
       "1/2 + I*\\eta_0*\\eta_1/2"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursiveapply(((I*eta[0]*eta[1])*(1+I*eta[0]*eta[1])/2).expand(),normalorder2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "8763e5ea16b716ad1eeffeab5f34109bd722594d0305e114e3d37565ed57b2a4"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}