Julia で行列の転置・随伴を使いこなす：LinearAlgebra 実践ガイド

LinearAlgebra.Adjoint は、Julia の線形代数ライブラリ (LinearAlgebra) に含まれる型の一つで、行列の随伴（ずいはん） を表現するために使われます。随伴行列は、数学においてはエルミート共役（Hermitian conjugate）とも呼ばれます。

具体的には、ある行列 (A) が与えられたとき、その随伴 (A^*) は次のように定義されます。

1. まず、行列 (A) の転置行列 (A^T) を求めます。これは、行列 (A) の行と列を入れ替えたものです。
2. 次に、その転置行列 (A^T) の各要素の複素共役を取ります。複素数 (z = a + bi) の複素共役は (\bar{z} = a - bi) です。実数の場合は複素共役を取っても値は変わりません。

したがって、行列 (A) の随伴 (A^*) の ((i, j)) 成分は、行列 (A) の ((j, i)) 成分の複素共役となります。数式で表すと以下のようになります。

(A∗)ij​=Aji​​

Julia において LinearAlgebra.Adjoint 型のオブジェクトを作成するには、行列の後にシングルクォート ' を付けます。例えば、行列 A があるとき、A' と書くことでその随伴行列を表す Adjoint 型のオブジェクトが生成されます。

LinearAlgebra.Adjoint の重要な点

• 演算のサポート
  Adjoint 型のオブジェクトは、通常の行列と同様に、行列積、加算、スカラー倍などの線形代数の演算をサポートしています。
• 遅延評価（Lazy Evaluation）
  随伴の計算は、実際に値が必要になるまで遅延されることがあります。これは、特に大きな行列の場合にパフォーマンス上の利点があります。
• ビュー（View）であること
  A' は、元の行列 A のデータをコピーするのではなく、そのビュー（参照）を作成します。つまり、A' に対する操作は、必要に応じて元の A のデータに影響を与える可能性があります（ただし、直接的な要素の変更は通常行われません）。これにより、メモリ効率が向上します。

使用例

using LinearAlgebra

# 実数成分の行列
A = [1 2; 3 4]
A_adjoint = A'
println("行列 A:\n", A)
println("A の随伴 (転置):\n", A_adjoint)

# 複素数成分の行列
B = [1+1im 2-3im; 0 4+2im]
B_adjoint = B'
println("\n行列 B:\n", B)
println("B の随伴 (エルミート共役):\n", B_adjoint)

# ベクトル（列ベクトルとみなされる）の場合
v = [1; 2+1im; 3]
v_adjoint = v'
println("\nベクトル v:\n", v)
println("v の随伴 (行ベクトル):\n", v_adjoint)

この例では、実数成分の行列 A の随伴は単なる転置行列になりますが、複素数成分の行列 B の随伴では、転置に加えて各要素の複素共役が取られていることがわかります。また、ベクトルに対して ' を適用すると、行ベクトル（随伴ベクトル）が得られます。

---

型に関するエラー (TypeError など)

• トラブルシューティング
  
  • 演算を行う前に、関連する行列やベクトルの次元（サイズ）が整合しているかを確認してください。
  • typeof() 関数を使用して、変数の型が期待通り Adjoint または Matrix であるかを確認してください。
  • もし Adjoint 型を明示的な Matrix 型に変換したい場合は、Matrix(A') のように Matrix() コンストラクタを使用できます。ただし、これはデータのコピーを伴うため、メモリ使用量が増加する可能性があります。
• 原因
  Adjoint 型のオブジェクトに対して、定義されていない演算を行おうとした場合に発生します。例えば、Adjoint 型と異なるサイズの行列との加算や乗算などです。

意図しないビュー (予期せぬ元の行列への影響)

• トラブルシューティング
  
  • Adjoint オブジェクトに対して要素の代入 (A'[i, j] = value) を行うことは避けるべきです。もし元の行列とは独立した修正を行いたい場合は、Matrix(A') でコピーを作成してから操作してください。
  • 関数によっては、Adjoint 型の入力をその場で変更しようとする場合があります。そのような関数を使用する際は、ドキュメントを注意深く確認し、必要であれば事前にコピーを作成することを検討してください。
• 原因
  Adjoint は元の行列のビューであるため、Adjoint オブジェクトを通して元の行列の要素を直接変更しようとすると、予期せぬ結果を引き起こす可能性があります。ただし、Julia の標準的な操作では、Adjoint ビューを通して元のデータを直接書き換えることは通常許可されていません。

パフォーマンスに関する問題 (不要なコピー)

• トラブルシューティング
  
  • パフォーマンスが重要な部分では、Adjoint 型のまま演算が効率的に行われるか、関数の実装を確認してください。
  • 不要な Matrix() 変換を避けるようにコードを見直してください。
  • 可能であれば、Adjoint 型を直接サポートするライブラリ関数を使用するように心がけてください。
• 原因
  Adjoint はビューであるため、多くの操作で効率的ですが、場合によっては意図せずコピーが発生し、パフォーマンスの低下を招くことがあります。例えば、Adjoint 型のオブジェクトを引数として取る関数が、内部で Matrix() コンストラクタを呼び出してコピーを作成する場合があります。

複素共役に関する誤解

• トラブルシューティング
  
  • 行列の成分が実数か複素数かを確認し、期待される結果を正しく理解してください。
  • もし複素共役なしの単なる転置が必要な場合は、transpose(A) 関数を使用してください。
• 原因
  実数成分の行列に対して Adjoint を取ると転置行列が得られますが、複素数成分の行列に対しては転置に加えて複素共役が取られます。この点を理解していないと、期待する結果と異なる場合があります。

線形代数の基本的な理解不足

• 原因
  随伴行列（エルミート共役）の数学的な定義や性質を十分に理解していないと、Adjoint の使用方法や結果の解釈を誤る可能性があります。

• Julia のドキュメントを参照する
  LinearAlgebra.Adjoint や関連する関数に関する公式ドキュメントは、正確な情報を提供してくれます。
• 簡単な例で試す
  問題が複雑な場合に、小さな行列やベクトルで Adjoint の動作を試してみることで、理解が深まることがあります。
• @info や @debug マクロを活用する
  変数の値やプログラムの実行フローを追跡するのに役立ちます。
• エラーメッセージを внимательно に読む
  Julia のエラーメッセージは、問題の原因や場所に関する貴重な情報を提供してくれます。

---

例1: 実数行列の随伴（転置）

using LinearAlgebra

# 3x2 の実数行列を作成
A = [1.0 2.0; 3.0 4.0; 5.0 6.0]
println("元の行列 A:")
println(A)

# 随伴（この場合は単なる転置）を計算
A_adjoint = A'
println("\nA の随伴 (A'):")
println(A_adjoint)

# 随伴の型を確認
println("\n型 of A': ", typeof(A_adjoint))

# 随伴の要素にアクセス
println("\nA'[1, 2]: ", A_adjoint[1, 2])

この例では、実数成分の行列 A を作成し、シングルクォート ' を使ってその随伴 A' を計算しています。実数行列の場合、随伴は単なる転置行列になります。typeof(A_adjoint) を見ると、結果が Adjoint{Float64, Matrix{Float64}} 型であることがわかります。これは、元の行列 A の要素の型が Float64 であり、元が Matrix{Float64} 型であったためです。

例2: 複素数行列の随伴（エルミート共役）

using LinearAlgebra

# 2x2 の複素数行列を作成
B = [1+2im 3-1im; 0.5+0im 4+3im]
println("元の行列 B:")
println(B)

# 随伴（エルミート共役）を計算
B_adjoint = B'
println("\nB の随伴 (B'):")
println(B_adjoint)

# 随伴の要素にアクセス
println("\nB'[2, 1]: ", B_adjoint[2, 1]) # B[1, 2] の複素共役 (3+1im)

この例では、複素数成分の行列 B を作成し、その随伴 B' を計算しています。複素数行列の場合、随伴は転置に加えて各要素の複素共役を取ります。B'[2, 1] の値は、元の B[1, 2] の複素共役である 3 + 1im となります。

例3: ベクトルの随伴

using LinearAlgebra

# 列ベクトルを作成
v = [1.0; 2.0; 3.0]
println("元のベクトル v:")
println(v)

# 随伴（行ベクトル）を計算
v_adjoint = v'
println("\nv の随伴 (v'):")
println(v_adjoint)
println("\n型 of v': ", typeof(v_adjoint))

# 行ベクトルにアクセス
println("\nv'[1]: ", v_adjoint[1])

# 複素数ベクトル
w = [1+1im; 2-1im]
w_adjoint = w'
println("\n元の複素数ベクトル w:")
println(w)
println("\nw の随伴 (w'):")
println(w_adjoint)

ベクトルに対して ' を適用すると、列ベクトルは行ベクトル（随伴ベクトル）に、行ベクトルは列ベクトルになります。複素数ベクトルの場合は、要素の複素共役も取られます。typeof(v_adjoint) を見ると、Adjoint{Float64, Matrix{Float64}} と表示されますが、これは内部的には 1x3 の行列として扱われているためです。

例4: 随伴を使った線形代数演算

using LinearAlgebra

# 行列とベクトル
C = [1 2; 3 4]
x = [5; 6]

# ベクトルの随伴（行ベクトル）と行列の積
x_adjoint_C = x' * C
println("x' * C: ", x_adjoint_C)

# 行列の随伴とベクトルの積
C_adjoint_x = C' * x
println("C' * x: ", C_adjoint_x)

# 複素数行列とベクトルの内積（随伴ベクトルを使用）
y = [1+1im; 2-1im]
z = [3; 4+1im]
inner_product = y' * z
println("\n複素数ベクトルの内積 (y' * z): ", inner_product)

この例では、Adjoint を使ってベクトルと行列の積を計算したり、複素数ベクトルの内積を計算したりしています。複素数ベクトルの内積は、一方のベクトルの随伴ともう一方のベクトルの積として定義されることが一般的です。

例5: 関数内で Adjoint を扱う

using LinearAlgebra

function conjugate_transpose_multiply(A::AbstractMatrix, b::AbstractVector)
    return A' * b
end

M = [1 2; 3 4]
v = [5; 6]
result = conjugate_transpose_multiply(M, v)
println("\nconjugate_transpose_multiply(M, v): ", result)

N = [1+1im 2; 3 4-1im]
w = [1; 2im]
result_complex = conjugate_transpose_multiply(N, w)
println("conjugate_transpose_multiply(N, w): ", result_complex)

この例では、行列とその随伴とベクトルの積を計算する関数 conjugate_transpose_multiply を定義しています。この関数は、実数行列と複素数行列の両方に対して正しく動作します。

---

transpose() 関数と conj() 関数の組み合わせ (実数および複素数行列)

• 実数行列の場合
  実数行列の随伴は単なる転置なので、transpose() 関数を使用できます。

A_real = [1.0 2.0; 3.0 4.0]
A_transposed = transpose(A_real)
println("transpose(A_real):\n", A_transposed)

• 複素数行列の場合
  複素数行列の随伴は、転置と各要素の複素共役を取ることで得られます。これを行うには、まず transpose() で転置を行い、次に conj() 関数で各要素の複素共役を取ります。

B_complex = [1+2im 3-1im; 0.5+0im 4+3im]
B_transposed = transpose(B_complex)
B_adjoint_manual = conj.(B_transposed) # ドット演算子で要素ごとに conj を適用
println("\ntranspose(B_complex):\n", B_transposed)
println("conj.(transpose(B_complex)) (手動での随伴):\n", B_adjoint_manual)

adjoint() 関数 (実数および複素数行列)

Julia の LinearAlgebra には、直接的に随伴（エルミート共役）を計算する adjoint() 関数も用意されています。これは、シングルクォート ' 演算子と同じ結果を返しますが、関数形式で使用したい場合に便利です。

C = [1 2; 3 4]
C_adjoint_func = adjoint(C)
println("\nadjoint(C):\n", C_adjoint_func)

D = [1-1im 2+0im; 0 3+2im]
D_adjoint_func = adjoint(D)
println("\nadjoint(D):\n", D_adjoint_func)

内包表記やループを用いた要素ごとの操作 (より制御が必要な場合)

より細かく制御したい場合や、特定の条件に基づいて操作を行いたい場合は、内包表記やループを使って各要素に対して処理を行うことができます。

E = [1+0im 2-1im; 3+1im 4+0im]
rows, cols = size(E)
E_adjoint_manual_loop = Matrix{ComplexF64}(undef, cols, rows) # 結果を格納する行列を初期化

for i in 1:rows
    for j in 1:cols
        E_adjoint_manual_loop[j, i] = conj(E[i, j])
    end
end

println("\n行列 E:\n", E)
println("手動で計算した E の随伴 (ループ使用):\n", E_adjoint_manual_loop)

この方法では、元の行列の要素を行と列を入れ替えながら複素共役を取る処理を明示的に記述しています。

ユーザー定義関数 (特定の目的に合わせた処理)

特定の目的に合わせて、随伴に類似した操作を行う関数を自分で定義することもできます。例えば、転置だけを行いたい場合や、特定の条件でのみ複素共役を取りたい場合などです。

function my_transpose(A::AbstractMatrix)
    rows, cols = size(A)
    result = similar(A, cols, rows) # 元の行列と同じ要素型で、サイズが入れ替わった行列を作成
    for i in 1:rows
        for j in 1:cols
            result[j, i] = A[i, j]
        end
    end
    return result
end

F = [1.0 2.0; 3.0 4.0]
F_transposed_custom = my_transpose(F)
println("\n自作の転置関数 my_transpose(F):\n", F_transposed_custom)

Adjoint を直接使用する利点

• 線形代数ライブラリとの統合
  多くの線形代数関数は Adjoint 型を直接サポートしています。
• 遅延評価
  実際の計算は必要になるまで遅延されるため、パフォーマンスが向上する可能性があります。
• 効率的なビュー
  Adjoint はデータのコピーを避け、メモリ効率が良いです。
• 簡潔な記法
  シングルクォート ' は非常に簡潔で読みやすいです。

• 学習や理解のため
  随伴の計算プロセスをより深く理解するために、手動で操作を実装してみることは有益です。
• Adjoint 型ではない行列を期待する関数との互換性
  一部の外部ライブラリや古いコードでは、Adjoint 型を直接扱えない場合があります。その際は、Matrix(A') などで明示的に Matrix 型に変換する必要があるかもしれません。
• 明示的な操作が必要な場合
  要素ごとに特定の処理を加えたい場合など。