AntisymmetricProjection
AntisymmetricProjection | |
Produces the projection onto the antisymmetric subspace | |
Other toolboxes required | none |
---|---|
Related functions | SymmetricProjection SwapOperator |
Function category | Permutations and symmetry of subsystems |
AntisymmetricProjection is a function that computes the orthogonal projection onto the antisymmetric subspace of two or more subsystems. The output of this function is always a sparse matrix.
Contents
Syntax
- PA = AntisymmetricProjection(DIM)
- PA = AntisymmetricProjection(DIM,P)
- PA = AntisymmetricProjection(DIM,P,PARTIAL)
- PA = AntisymmetricProjection(DIM,P,PARTIAL,MODE)
Argument descriptions
- DIM: The dimension of each of the subsystems.
- P (optional, default 2): The number of subsystems.
- PARTIAL (optional, default 0): If PARTIAL = 1 then PA isn't the orthogonal projection itself, but rather a matrix whose columns form an orthonormal basis for the antisymmetric subspace (and hence PA*PA' is the orthogonal projection onto the antisymmetric subspace).
- MODE (optional, default -1): A flag that determines which of two algorithms is used to compute the antisymmetric projection. If MODE = -1 then this script chooses which algorithm it thinks will be faster based on the values of DIM and P. If you wish to force the script to use a specific one of the algorithms (not recommended!), they are as follows:
- MODE = 0: Computes the antisymmetric projection by explicitly constructing an orthonormal basis of the antisymmetric subspace. The method for constructing such a basis is a modification of the procedure described for the symmetric subspace in ^{[1]}. This method is typically fast when DIM is small compared to P.
- MODE = 1: Computes the antisymmetric projection by averaging all P! permutation operators (in the sense of the PermutationOperator function). Permutation operators corresponding to an even permutation are given a weight of +1, while permutation operators corresponding to an odd permutation are given a weight of -1.^{[2]} Because P! grows very quickly, this method is only practical when P is small.
Examples
Two subsystems
To compute the antisymmetric projection on two-qubit space, the following code suffices:
>> AntisymmetricProjection(2) ans = (2,2) 0.5000 (3,2) -0.5000 (2,3) -0.5000 (3,3) 0.5000
Note that the output of this function is always sparse. If you want a full matrix (not recommended for even moderately large DIM or P), you must explicitly convert it using MATLAB's built-in full function.
More subsystems and PARTIAL
To compute a matrix whose columns form an orthonormal basis for the symmetric subspace of three-qutrit space, set PARTIAL = 1:
>> PA = AntisymmetricProjection(3,3,1) PA = (6,1) 0.4082 (8,1) -0.4082 (12,1) -0.4082 (16,1) 0.4082 (20,1) 0.4082 (22,1) -0.4082
Note that PA is an isometry from the antisymmetric subspace (which is one-dimensional in this case) to the full three-qutrit space. In other words, PA'*PA is the identity matrix (i.e., the scalar 1 here) and PA*PA' is the orthogonal projection onto the antisymmetric subspace, which we can verify as follows:
>> PA'*PA ans = (1,1) 1.0000 >> norm(PA*PA' - AntisymmetricProjection(3,3),'fro') ans = 3.3307e-016
When DIM is too small
When DIM < P, the antisymmetric subspace is zero-dimensional, as verified in the DIM = 4, P = 6 case by the following line of code:
>> AntisymmetricProjection(4,6) ans = All zero sparse: 4096-by-4096
Source code
Click on "expand" to the right to view the MATLAB source code for this function.
%% ANTISYMMETRICPROJECTION Produces the projection onto the antisymmetric subspace
% This function has one required argument:
% DIM: the dimension of the local systems
%
% PA = AntisymmetricProjection(DIM) is the orthogonal projection onto the
% anti symmetric subspace of two copies of DIM-dimensional space. PA is
% always a sparse matrix.
%
% This function has five optional arguments:
% P (default 2)
% PARTIAL (default 0)
% MODE (default -1)
%
% PA = AntisymmetricProjection(DIM,P,PARTIAL,MODE) is the orthogonal
% projection onto the antisymmetric subspace of P copies of
% DIM-dimensional space. If PARTIAL = 1 then PA isn't the orthogonal
% projection itself, but rather a matrix whose columns form an
% orthonormal basis for the antisymmetric subspace (and hence PA*PA' is
% the orthogonal projection onto the antisymmetric subspace). MODE is a
% flag that determines which of two algorithms is used to compute the
% antisymmetric projection. If MODE = -1 then this script chooses
% whichever algorithm it thinks will be faster based on the values of DIM
% and P. If you wish to force one specific algorithm, set either MODE = 0
% (which generally works best when DIM is small) or MODE = 1 (which
% generally works best when P is small).
%
% URL: http://www.qetlab.com/AntisymmetricProjection
% requires: opt_args.m, perm_sign.m, PermutationOperator.m,
% PermuteSystems.m, sporth.m
% author: Nathaniel Johnston (nathaniel@njohnston.ca)
% package: QETLAB
% last updated: November 26, 2012
function PA = AntisymmetricProjection(dim,varargin)
% set optional argument defaults: p=2, partial=0, mode=-1
[p,partial,mode] = opt_args({ 2, 0, -1 },varargin{:});
dimp = dim^p;
if(p == 1)
PA = speye(dim);
return
elseif(dim < p) % the antisymmetric subspace is empty if dim < p
PA = sparse(dimp,dimp*(1-partial));
return
elseif(mode == -1) % guess which algorithm will be faster
mode = (dim >= p+4);
end
plist = perms(1:p);
pfac = size(plist,1);
% The antisymmetric projection is the normalization of the sum of all
% signed permutation operators. This method of computing the
% antisymmetric projection is reasonably quick when the local dimension
% is large compared to the number of systems.
if(mode == 1)
PA = sparse(dimp,dimp);
for j = 1:pfac
PA = PA + perm_sign(plist(j,:))*PermutationOperator(dim*ones(1,p),plist(j,:),0,1);
end
PA = PA/pfac;
if(partial)
PA = sporth(PA);
end
% When the local dimension is small compared to the number of systems,
% it is quicker to just explicitly construct an orthonormal basis for
% the antisymmetric subspace.
else
lim = nchoosek(dim,p);
ind = nchoosek(1:dim,p);
Id = speye(dim);
PA = spalloc(dimp,lim,pfac*lim); % allocate the correct number of non-zero elements to PA for speed/memory reasons
% construct an orthonormal basis for the antisymmetric subspace
for j = 1:lim
v = spalloc(dimp,1,pfac);
for k = 1:pfac
vt = Id(:,ind(j,plist(k,1)));
for m = 2:p
vt = kron(vt,Id(:,ind(j,plist(k,m))));
end
v = v + perm_sign(plist(k,:))*vt;
end
PA(:,j) = v;
end
if(partial)
PA = PA/sqrt(pfac);
else
PA = PA*PA'/pfac;
end
end
end
References
- ↑ John Watrous. Lecture 21: The quantum de Finetti theorem, Theory of Quantum Information Lecture Notes, 2008.
- ↑ R.B. Griffiths. Systems of Identical Particles, 33-756 Quantum Mechanics II Course Notes, 2011.