[メモ2] - Unity学習帳２冊目

Unity学習帳2冊目メモ2

[ トップ ] [ 差分 | バックアップ | リロード ] [ 新規 | 一覧 | 検索 | 最新 | ヘルプ ]

メニューバー

抽斗

Wolfram
GoogleTr
基礎/変数名単語帳
 wikiテンプレート

メモ

P65の\({ \nu }_{ j }\) は\({H }_{ 1 }\)に対するズレを表していると考えられる
指数と回転置換群と順列（全てを網羅する置換）には明確な関係、繋がりがある
プログラムコード的に数学的帰納を利用せずに指数と回転置換群を利用して自由に順列を作ることも可能な筈
指数と回転置換群で順列を分析するという視点

指数と回転置換群(n進数)を利用した順列の作成

ここでは数学的帰納を利用しないで指数と回転置換群、n進数（合同）の関係で順列を作成しています
XとYの数列は自由に変更可能な状態で順列を作成出来る

TODO：仕組みもメモで書く

 
 
 
 
 
-
|
|
-
|
|
|
|
|
-
|
!
|
|
|
|
|
-
|
!
|
|
-
|
|
|
-
-
!
-
|
|
|
!
|
!
!
|
|
-
|
!
!
|
!

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
 
public class Model3 : MonoBehaviour
{
 
    void Start()
    {
        int[] X = { 1, 2, 3, 4 };
        char[] Y = { 'A', 'B' };    //Y要素を自由に変えても正確に順列が生成できます
 
        int[] Z = new int[X.Length + 1];
        for (int i = 0; i < Z.Length; i++)
        {
            Z[i] = (int)Mathf.Pow(Y.Length, i);     //指数を利用して作成した数列
        }
        int total = Z[Z.Length - 1];
 
 
        List<char[]> charList = new List<char[]>();
        for (int i = 0; i < total; i++)
        {
            charList.Add(new char[X.Length]);
        }
 
        for (int i = 0; i < X.Length; i++)
        {
            int mod = 0;
            char set = Y[mod];
            for (int j = 0; j < total; j++)
            {
                //指数の数列と回転置換群との関係をここで利用してる
                if (j % Z[i] == 0)
                {
                    set = Y[mod % (Y.Length)];
                    mod++;
 
                }
                charList[j][i] = set;        //二次元配列的なListの使用方法
            }
        }
 
        foreach (var item in charList)
        {
            print(new string(item));
        }
    }
 
}

出力
何気に右側の数字アイコンで重複数がわかるのは便利かもしれない

支援プログラム

群Rの計算をC#で行うコードを書いてみた。演算子のオーバーロードを用いた回転置換群の計算機
この場合、６要素しか考えていないので例えば７要素にする場合、変更が全体に必要

\(\sigma \cdot \sigma \cdot \sigma \\ \sigma \cdot \sigma \cdot \sigma \cdot \tau \\ \tau \cdot \sigma \cdot \sigma \\ \sigma \cdot \sigma \cdot \sigma \cdot \sigma \cdot \tau \\ f\cdot \tau \cdot { \sigma }^{ 2 }\\ f\cdot { \sigma }^{ 4 }\cdot \tau \\ f\cdot \tau \cdot { \sigma }^{ 2 }とf\cdot { \sigma }^{ 4 }\cdot \tau は同値?\)

といった様な計算をさせている

 
 
 
 
-
|
|
-
-
!
|
|
|
|
|
|
|
|
-
!
|
|
|
|
|
|
!
|
-
!
-
|
|
|
|
-
|
|
!
|
|
-
|
|
!
|
-
!
-
|
|
|
-
|
!
|
-
|
!
|
-
|
!
|
|
!
|
-
!
-
-
!
-
|
!
|
-
!
-
|
!
|
|
!
|
-
!
-
|
!
|
-
!
-
|
!
!
!

using UnityEngine;
using System.Collections;
 
public class Model2 : MonoBehaviour
{
 
    void Start()
    {
        //置換関数化
        Rotate f = new Rotate("ABCABC");                                //f:X→Y
        Rotate iota = new Rotate(new int[] { 0, 1, 2, 3, 4, 5 });       //ι：恒等置換
        Rotate sigma = new Rotate(new int[] { 5, 0, 1, 2, 3, 4 });      //σ：回転
        Rotate sigma2 = new Rotate(new int[] { 4, 5, 0, 1, 2, 3 });     //σ^2：回転
        Rotate sigma3 = new Rotate(new int[] { 3, 4, 5, 0, 1, 2 });
        Rotate sigma4 = new Rotate(new int[] { 2, 3, 4, 5, 0, 1 });
        Rotate sigma5 = new Rotate(new int[] { 1, 2, 3, 4, 5, 0 });
        Rotate tau = new Rotate(new int[] { 5, 4, 3, 2, 1, 0 });        //τ：左右反転
 
        //以下のように計算機として使う
        print(sigma * sigma * sigma);
        print(sigma * sigma * sigma * tau);
        print(tau * sigma * sigma);
        print(sigma * sigma * sigma * sigma * tau);
        print(f * tau * sigma2);
        print(f * sigma4 * tau);
        print(f * tau * sigma2 == f * sigma4 * tau);
    }
 
    //回転をモデル化した置換群R
    class Rotate
    {
        public string X;
        public int[] shift;
 
        public Rotate(int[] shift)
        {
            this.X = "012345";
            this.shift = shift;
        }
 
        public Rotate(string X)
        {
            this.X = X;
            this.shift = new int[] { 0, 1, 2, 3, 4, 5 };
        }
 
        //演算子「*」のオーバーロード
        public static Rotate operator *(Rotate left, Rotate right)
        {
            char[] temp = new char[left.X.Length];
            char[] temp2 = new char[left.X.Length];
            for (int i = 0; i < left.shift.Length; i++)
            {
                temp[i] = left.X[left.shift[i]];
            }
            for (int i = 0; i < right.shift.Length; i++)
            {
                temp2[i] = temp[right.shift[i]];
            }
 
            //あたらしいRotate型を作って返す
            //演算後はιで文字列の配置が変わった物を渡している。これが連続する二項演算の左辺になる
            Rotate iota = new Rotate(new int[] { 0, 1, 2, 3, 4, 5 });
            iota.X = new string(temp2);
            return iota;
        }
 
        //演算子「==」のオーバーロード
        public static bool operator ==(Rotate left, Rotate right)
        {
            //オブジェクトとして同一かどうか
            if (object.ReferenceEquals(left, right))
            {
                return true;
            }
 
            //オブジェクトとしてnullかどうか
            if (((object)left == null) || ((object)right == null))
            {
                return false;
            }
 
            return (left.X == right.X);
        }
 
        //演算子「==」と共に必ず設定する必要がある
        public static bool operator !=(Rotate left, Rotate right)
        {
            return !(left == right); //これはoperatorの処理で判定している
        }
 
        //文字表示
        public override string ToString()
        {
            return X;
        }
    }
}

P56～

\(X=\left\{ k\in \mathbb{Z}|1\le k\le 6 \right\} =\left\{ 1,2,3,4,5,6 \right\} \\ Y=\left\{ A=シューマイ,B=棒棒鶏,C=酢豚 \right\} \\ f:X\rightarrow Y\\ g:X\rightarrow Y\\ \sigma :X\rightarrow X\\ \iota =\begin{pmatrix} 1 & 2 & 3 & 4 & 5 & 6 \\ 1 & 2 & 3 & 4 & 5 & 6 \end{pmatrix}\\ \sigma =\begin{pmatrix} 1 & 2 & 3 & 4 & 5 & 6 \\ 6 & 1 & 2 & 3 & 4 & 5 \end{pmatrix}\\ R=\left\{ \iota ,\sigma ,{ \sigma }^{ 2 },{ \sigma }^{ 3 },{ \sigma }^{ 4 },{ \sigma }^{ 5 } \right\} \\ \)

集合を定義して問題をモデル化し関数の型を決め置換関数と置換群を作成している。問題を解りやすくするために仮に

\(f=\begin{pmatrix} 1 & 2 & 3 & 4 & 5 & 6 \\ A & B & B & A & A & C \end{pmatrix}\\ g=\begin{pmatrix} 1 & 2 & 3 & 4 & 5 & 6 \\ A & C & A & B & B & A \end{pmatrix}\)
の状態だったとする

\(g=f\cdot { \sigma }^{ j }\quad { \sigma }^{ j }\in R\quad \cdots \left( ア \right) \\ f=g\cdot { \sigma }^{ k }\quad \left( 0\le k\le 5 \right) \quad \cdots \left( イ \right) \)
この場合、 \(g=f\cdot { \sigma }^{ 2 }\) \(f=g\cdot { \sigma }^{ 4 }\) \(j=2,k=4\)

\(f{ \sim }_{ R }g\)
\(R\) の置換群により同値であることを確認すると

①\(R\)の中に恒等置換 \(\iota \) があるので反射性OK
\(f=f\cdot \iota \) 従って \(f{ \sim }_{ R }f\)

②任意の \({ \sigma }^{ j }\) に対して\(R\)の中に逆関数があるので対称性OK
式を変形して逆関数を求める式を作ってみる

\(g=g\cdot \iota =g\cdot { \sigma }^{ 6 }\quad \cdots gに対する恒等置換\iota を考える\)
\(g\cdot { \sigma }^{ 6 }=f\cdot { \sigma }^{ j }\quad \cdots \left( ア \right) を代入\\ g\cdot { \sigma }^{ 6 }=g\cdot { \sigma }^{ k }\cdot { \sigma }^{ j }\quad \cdots \left( イ \right) を代入\)
\( { \sigma }^{ 6 }={ \sigma }^{ k }\cdot { \sigma }^{ j }\quad \cdots 置換の回転を代数式で扱う。gは消して指数法則を利用する\\ { \sigma }^{ j }={ \sigma }^{ 6-k }\quad \cdots { \sigma }^{ j }に対して解く\\ { \sigma }^{ k }={ \sigma }^{ 6-j }\quad \cdots { \sigma }^{ k }に対して解く\)
\( g=f\cdot { \sigma }^{ j }=f\cdot { \sigma }^{ 6-k }\quad \cdots \left( ア \right) に代入\\ f=g\cdot { \sigma }^{ k }=g\cdot { \sigma }^{ 6-j }\quad \cdots \left( イ \right) に代入\)
\(j\)が\(2\)だと\(k\)は\(4\)になる。\(g\)も\(f\)も互いに\(R\)の置換群の中で逆置換の関係になる
シフトの方向を逆にして置換しているわけでないことに注意！これを対称性と呼んでいる
対称性が成立すると \( f{ \sim }_{ R }g\rightarrow g{ \sim }_{ R }f\) と言える（ここはP59の(3)にも繋がっている）

③推移性がある
演算"\(\cdot\) "において演算結果が集合\(R\)の中で閉じている(演算結果が集合\(R\)の外に出ない)
\(g=f\cdot { \sigma }^{ m }\\ h=g\cdot { \sigma }^{ n }\)
とすると\(h=f\cdot { \sigma }^{ m }\cdot { \sigma }^{ n }=f\cdot { \sigma }^{ m+n }\)
\({ \sigma }^{ m+n }\in R\)なので\(f{ \sim }_{ R }h\)が成り立つ
推移性が成立すると \(\quad f{ \sim }_{ R }g\quad \wedge \quad g{ \sim }_{ R }h\quad \rightarrow \quad f{ \sim }_{ R }h\) と言える

添付ファイル: