7 added 149 characters in body edited Aug 14 '18 at 17:21 chuckstables 37911 silver badge1313 bronze badges I'm currently writing a basic program in python to simulate a 1 + 1 dimensional yang mills gauge theory with symmetry group $$SU(2)$$. On the lattice you work with link variables, which are $$SU(N)$$ matrices defined formally as $$U_u(x) = e^{-igaA_u(x)}$$, where $$A_u(x) = \sum_{i=0}^{N^2-1}(A_u^iT^i)$$ and where $$T^i$$ is the $$i^{th}$$ generator of the $$SU(N)$$ group. The lattice action is related to the plaquettes on the lattice, where a plaquette is the smallest closed product of link variables on the lattice. To be clear: $$U_{u}(x)$$ is a vector of $$SU(N)$$ matrices: you'd have one $$SU(N)$$ matrix for each $$u$$. So $$U_x(x)$$ is a SU(N) matrix, as is $$U_t(x)$$. The monte carlo update algorithm goes like this. We look at a link on the lattice individually, and we suggest a change to said link variable, $$U_u(x) \to U'_u(x)$$ (where u is the direction of the link; in 1 + 1 dimensions it's either $$x$$ or $$t$$) We then compute the change in the action that would occur if we accepted the change $$U_u(x) \to U'_u(x)$$. If the change in the action, $$dS$$, is negative then we accept the change. If the change in the action, $$dS$$ is positive then we accept the change with a probability of $$e^{-dS}$$. We do this process for each link variable on the lattice. So; here's my question. How do I propose sufficiently small changes to an SU(N) matrix such that the average acceptance probability isn't absurdly small? I don't think I can propose changes of the form $$U_u(x) \to U_u(x) + U'_u(x)$$, where $$U'_u(x)$$ is a 'small' SU(N) matrix (if there even is such a thing), as I don't think the sum of two SU(N) matrices is generally SU(N). I could simply generate $$K$$ random SU(N) matrices, and then randomly select one of those $$K$$ $$SU(N)$$ matrices to be my proposed link variable $$U_u(x)$$. When I implement this however I end up with $$dS$$'s with large magnitudes, which means low acceptance probabilities. Which means that a large number of iterations must be done to get a configuration independent from your starting one. Sorry for the length. If anyone wants my code at the moment let me know. It's written in python, and only has an iterator and a way to generate $$K$$ random SU(2) matrices. EDIT: I think I've found the source of the discrepancy between my initial results and my current results. Let's say I generate 1000 random su(2) matrices using some algorithm. To update the link variables I propose $$U_u(x) \mapsto MU_u(x)$$, where M is one of my 1000 random su(2) matrices. I'm not sure if you can actually construct the entire space of su(2) by repeatedly multiplying these 1000 random matrices together. Even when I've changed my code to be 2+1 D su(2) yang mills, I still get the problem where my plaquette expectation value changes as I change my step size. In particular the plaquette expectation value goes UP as I decrease the step size. Only when I generate completely random su(2) matrices M to update $$U_u(x) \mapsto MU_u(x)$$ do I get the minimal plaquette size. EDIT2: Might it be that I am updating the entire lattice at once? What I'm doing is running through the lattice once without changing any links, then changing all the links at the end of each iteration. EDIT3: The update algorithm was indeed the problem. You have to randomly select a link variable on a random site, update that, and then continue. I'm currently writing a basic program in python to simulate a 1 + 1 dimensional yang mills gauge theory with symmetry group $$SU(2)$$. On the lattice you work with link variables, which are $$SU(N)$$ matrices defined formally as $$U_u(x) = e^{-igaA_u(x)}$$, where $$A_u(x) = \sum_{i=0}^{N^2-1}(A_u^iT^i)$$ and where $$T^i$$ is the $$i^{th}$$ generator of the $$SU(N)$$ group. The lattice action is related to the plaquettes on the lattice, where a plaquette is the smallest closed product of link variables on the lattice. To be clear: $$U_{u}(x)$$ is a vector of $$SU(N)$$ matrices: you'd have one $$SU(N)$$ matrix for each $$u$$. So $$U_x(x)$$ is a SU(N) matrix, as is $$U_t(x)$$. The monte carlo update algorithm goes like this. We look at a link on the lattice individually, and we suggest a change to said link variable, $$U_u(x) \to U'_u(x)$$ (where u is the direction of the link; in 1 + 1 dimensions it's either $$x$$ or $$t$$) We then compute the change in the action that would occur if we accepted the change $$U_u(x) \to U'_u(x)$$. If the change in the action, $$dS$$, is negative then we accept the change. If the change in the action, $$dS$$ is positive then we accept the change with a probability of $$e^{-dS}$$. We do this process for each link variable on the lattice. So; here's my question. How do I propose sufficiently small changes to an SU(N) matrix such that the average acceptance probability isn't absurdly small? I don't think I can propose changes of the form $$U_u(x) \to U_u(x) + U'_u(x)$$, where $$U'_u(x)$$ is a 'small' SU(N) matrix (if there even is such a thing), as I don't think the sum of two SU(N) matrices is generally SU(N). I could simply generate $$K$$ random SU(N) matrices, and then randomly select one of those $$K$$ $$SU(N)$$ matrices to be my proposed link variable $$U_u(x)$$. When I implement this however I end up with $$dS$$'s with large magnitudes, which means low acceptance probabilities. Which means that a large number of iterations must be done to get a configuration independent from your starting one. Sorry for the length. If anyone wants my code at the moment let me know. It's written in python, and only has an iterator and a way to generate $$K$$ random SU(2) matrices. EDIT: I think I've found the source of the discrepancy between my initial results and my current results. Let's say I generate 1000 random su(2) matrices using some algorithm. To update the link variables I propose $$U_u(x) \mapsto MU_u(x)$$, where M is one of my 1000 random su(2) matrices. I'm not sure if you can actually construct the entire space of su(2) by repeatedly multiplying these 1000 random matrices together. Even when I've changed my code to be 2+1 D su(2) yang mills, I still get the problem where my plaquette expectation value changes as I change my step size. In particular the plaquette expectation value goes UP as I decrease the step size. Only when I generate completely random su(2) matrices M to update $$U_u(x) \mapsto MU_u(x)$$ do I get the minimal plaquette size. EDIT2: Might it be that I am updating the entire lattice at once? What I'm doing is running through the lattice once without changing any links, then changing all the links at the end of each iteration. I'm currently writing a basic program in python to simulate a 1 + 1 dimensional yang mills gauge theory with symmetry group $$SU(2)$$. On the lattice you work with link variables, which are $$SU(N)$$ matrices defined formally as $$U_u(x) = e^{-igaA_u(x)}$$, where $$A_u(x) = \sum_{i=0}^{N^2-1}(A_u^iT^i)$$ and where $$T^i$$ is the $$i^{th}$$ generator of the $$SU(N)$$ group. The lattice action is related to the plaquettes on the lattice, where a plaquette is the smallest closed product of link variables on the lattice. To be clear: $$U_{u}(x)$$ is a vector of $$SU(N)$$ matrices: you'd have one $$SU(N)$$ matrix for each $$u$$. So $$U_x(x)$$ is a SU(N) matrix, as is $$U_t(x)$$. The monte carlo update algorithm goes like this. We look at a link on the lattice individually, and we suggest a change to said link variable, $$U_u(x) \to U'_u(x)$$ (where u is the direction of the link; in 1 + 1 dimensions it's either $$x$$ or $$t$$) We then compute the change in the action that would occur if we accepted the change $$U_u(x) \to U'_u(x)$$. If the change in the action, $$dS$$, is negative then we accept the change. If the change in the action, $$dS$$ is positive then we accept the change with a probability of $$e^{-dS}$$. We do this process for each link variable on the lattice. So; here's my question. How do I propose sufficiently small changes to an SU(N) matrix such that the average acceptance probability isn't absurdly small? I don't think I can propose changes of the form $$U_u(x) \to U_u(x) + U'_u(x)$$, where $$U'_u(x)$$ is a 'small' SU(N) matrix (if there even is such a thing), as I don't think the sum of two SU(N) matrices is generally SU(N). I could simply generate $$K$$ random SU(N) matrices, and then randomly select one of those $$K$$ $$SU(N)$$ matrices to be my proposed link variable $$U_u(x)$$. When I implement this however I end up with $$dS$$'s with large magnitudes, which means low acceptance probabilities. Which means that a large number of iterations must be done to get a configuration independent from your starting one. Sorry for the length. If anyone wants my code at the moment let me know. It's written in python, and only has an iterator and a way to generate $$K$$ random SU(2) matrices. EDIT: I think I've found the source of the discrepancy between my initial results and my current results. Let's say I generate 1000 random su(2) matrices using some algorithm. To update the link variables I propose $$U_u(x) \mapsto MU_u(x)$$, where M is one of my 1000 random su(2) matrices. I'm not sure if you can actually construct the entire space of su(2) by repeatedly multiplying these 1000 random matrices together. Even when I've changed my code to be 2+1 D su(2) yang mills, I still get the problem where my plaquette expectation value changes as I change my step size. In particular the plaquette expectation value goes UP as I decrease the step size. Only when I generate completely random su(2) matrices M to update $$U_u(x) \mapsto MU_u(x)$$ do I get the minimal plaquette size. EDIT2: Might it be that I am updating the entire lattice at once? What I'm doing is running through the lattice once without changing any links, then changing all the links at the end of each iteration. EDIT3: The update algorithm was indeed the problem. You have to randomly select a link variable on a random site, update that, and then continue. 6 added 208 characters in body edited Aug 11 '18 at 20:28 chuckstables 37911 silver badge1313 bronze badges I'm currently writing a basic program in python to simulate a 1 + 1 dimensional yang mills gauge theory with symmetry group $$SU(2)$$. On the lattice you work with link variables, which are $$SU(N)$$ matrices defined formally as $$U_u(x) = e^{-igaA_u(x)}$$, where $$A_u(x) = \sum_{i=0}^{N^2-1}(A_u^iT^i)$$ and where $$T^i$$ is the $$i^{th}$$ generator of the $$SU(N)$$ group. The lattice action is related to the plaquettes on the lattice, where a plaquette is the smallest closed product of link variables on the lattice. To be clear: $$U_{u}(x)$$ is a vector of $$SU(N)$$ matrices: you'd have one $$SU(N)$$ matrix for each $$u$$. So $$U_x(x)$$ is a SU(N) matrix, as is $$U_t(x)$$. The monte carlo update algorithm goes like this. We look at a link on the lattice individually, and we suggest a change to said link variable, $$U_u(x) \to U'_u(x)$$ (where u is the direction of the link; in 1 + 1 dimensions it's either $$x$$ or $$t$$) We then compute the change in the action that would occur if we accepted the change $$U_u(x) \to U'_u(x)$$. If the change in the action, $$dS$$, is negative then we accept the change. If the change in the action, $$dS$$ is positive then we accept the change with a probability of $$e^{-dS}$$. We do this process for each link variable on the lattice. So; here's my question. How do I propose sufficiently small changes to an SU(N) matrix such that the average acceptance probability isn't absurdly small? I don't think I can propose changes of the form $$U_u(x) \to U_u(x) + U'_u(x)$$, where $$U'_u(x)$$ is a 'small' SU(N) matrix (if there even is such a thing), as I don't think the sum of two SU(N) matrices is generally SU(N). I could simply generate $$K$$ random SU(N) matrices, and then randomly select one of those $$K$$ $$SU(N)$$ matrices to be my proposed link variable $$U_u(x)$$. When I implement this however I end up with $$dS$$'s with large magnitudes, which means low acceptance probabilities. Which means that a large number of iterations must be done to get a configuration independent from your starting one. Sorry for the length. If anyone wants my code at the moment let me know. It's written in python, and only has an iterator and a way to generate $$K$$ random SU(2) matrices. EDIT: I think I've found the source of the discrepancy between my initial results and my current results. Let's say I generate 1000 random su(2) matrices using some algorithm. To update the link variables I propose $$U_u(x) \mapsto MU_u(x)$$, where M is one of my 1000 random su(2) matrices. I'm not sure if you can actually construct the entire space of su(2) by repeatedly multiplying these 1000 random matrices together. Even when I've changed my code to be 2+1 D su(2) yang mills, I still get the problem where my plaquette expectation value changes as I change my step size. In particular the plaquette expectation value goes UP as I decrease the step size. Only when I generate completely random su(2) matrices M to update $$U_u(x) \mapsto MU_u(x)$$ do I get the minimal plaquette size. EDIT2: Might it be that I am updating the entire lattice at once? What I'm doing is running through the lattice once without changing any links, then changing all the links at the end of each iteration. I'm currently writing a basic program in python to simulate a 1 + 1 dimensional yang mills gauge theory with symmetry group $$SU(2)$$. On the lattice you work with link variables, which are $$SU(N)$$ matrices defined formally as $$U_u(x) = e^{-igaA_u(x)}$$, where $$A_u(x) = \sum_{i=0}^{N^2-1}(A_u^iT^i)$$ and where $$T^i$$ is the $$i^{th}$$ generator of the $$SU(N)$$ group. The lattice action is related to the plaquettes on the lattice, where a plaquette is the smallest closed product of link variables on the lattice. To be clear: $$U_{u}(x)$$ is a vector of $$SU(N)$$ matrices: you'd have one $$SU(N)$$ matrix for each $$u$$. So $$U_x(x)$$ is a SU(N) matrix, as is $$U_t(x)$$. The monte carlo update algorithm goes like this. We look at a link on the lattice individually, and we suggest a change to said link variable, $$U_u(x) \to U'_u(x)$$ (where u is the direction of the link; in 1 + 1 dimensions it's either $$x$$ or $$t$$) We then compute the change in the action that would occur if we accepted the change $$U_u(x) \to U'_u(x)$$. If the change in the action, $$dS$$, is negative then we accept the change. If the change in the action, $$dS$$ is positive then we accept the change with a probability of $$e^{-dS}$$. We do this process for each link variable on the lattice. So; here's my question. How do I propose sufficiently small changes to an SU(N) matrix such that the average acceptance probability isn't absurdly small? I don't think I can propose changes of the form $$U_u(x) \to U_u(x) + U'_u(x)$$, where $$U'_u(x)$$ is a 'small' SU(N) matrix (if there even is such a thing), as I don't think the sum of two SU(N) matrices is generally SU(N). I could simply generate $$K$$ random SU(N) matrices, and then randomly select one of those $$K$$ $$SU(N)$$ matrices to be my proposed link variable $$U_u(x)$$. When I implement this however I end up with $$dS$$'s with large magnitudes, which means low acceptance probabilities. Which means that a large number of iterations must be done to get a configuration independent from your starting one. Sorry for the length. If anyone wants my code at the moment let me know. It's written in python, and only has an iterator and a way to generate $$K$$ random SU(2) matrices. EDIT: I think I've found the source of the discrepancy between my initial results and my current results. Let's say I generate 1000 random su(2) matrices using some algorithm. To update the link variables I propose $$U_u(x) \mapsto MU_u(x)$$, where M is one of my 1000 random su(2) matrices. I'm not sure if you can actually construct the entire space of su(2) by repeatedly multiplying these 1000 random matrices together. Even when I've changed my code to be 2+1 D su(2) yang mills, I still get the problem where my plaquette expectation value changes as I change my step size. In particular the plaquette expectation value goes UP as I decrease the step size. Only when I generate completely random su(2) matrices M to update $$U_u(x) \mapsto MU_u(x)$$ do I get the minimal plaquette size. I'm currently writing a basic program in python to simulate a 1 + 1 dimensional yang mills gauge theory with symmetry group $$SU(2)$$. On the lattice you work with link variables, which are $$SU(N)$$ matrices defined formally as $$U_u(x) = e^{-igaA_u(x)}$$, where $$A_u(x) = \sum_{i=0}^{N^2-1}(A_u^iT^i)$$ and where $$T^i$$ is the $$i^{th}$$ generator of the $$SU(N)$$ group. The lattice action is related to the plaquettes on the lattice, where a plaquette is the smallest closed product of link variables on the lattice. To be clear: $$U_{u}(x)$$ is a vector of $$SU(N)$$ matrices: you'd have one $$SU(N)$$ matrix for each $$u$$. So $$U_x(x)$$ is a SU(N) matrix, as is $$U_t(x)$$. The monte carlo update algorithm goes like this. We look at a link on the lattice individually, and we suggest a change to said link variable, $$U_u(x) \to U'_u(x)$$ (where u is the direction of the link; in 1 + 1 dimensions it's either $$x$$ or $$t$$) We then compute the change in the action that would occur if we accepted the change $$U_u(x) \to U'_u(x)$$. If the change in the action, $$dS$$, is negative then we accept the change. If the change in the action, $$dS$$ is positive then we accept the change with a probability of $$e^{-dS}$$. We do this process for each link variable on the lattice. So; here's my question. How do I propose sufficiently small changes to an SU(N) matrix such that the average acceptance probability isn't absurdly small? I don't think I can propose changes of the form $$U_u(x) \to U_u(x) + U'_u(x)$$, where $$U'_u(x)$$ is a 'small' SU(N) matrix (if there even is such a thing), as I don't think the sum of two SU(N) matrices is generally SU(N). I could simply generate $$K$$ random SU(N) matrices, and then randomly select one of those $$K$$ $$SU(N)$$ matrices to be my proposed link variable $$U_u(x)$$. When I implement this however I end up with $$dS$$'s with large magnitudes, which means low acceptance probabilities. Which means that a large number of iterations must be done to get a configuration independent from your starting one. Sorry for the length. If anyone wants my code at the moment let me know. It's written in python, and only has an iterator and a way to generate $$K$$ random SU(2) matrices. EDIT: I think I've found the source of the discrepancy between my initial results and my current results. Let's say I generate 1000 random su(2) matrices using some algorithm. To update the link variables I propose $$U_u(x) \mapsto MU_u(x)$$, where M is one of my 1000 random su(2) matrices. I'm not sure if you can actually construct the entire space of su(2) by repeatedly multiplying these 1000 random matrices together. Even when I've changed my code to be 2+1 D su(2) yang mills, I still get the problem where my plaquette expectation value changes as I change my step size. In particular the plaquette expectation value goes UP as I decrease the step size. Only when I generate completely random su(2) matrices M to update $$U_u(x) \mapsto MU_u(x)$$ do I get the minimal plaquette size. EDIT2: Might it be that I am updating the entire lattice at once? What I'm doing is running through the lattice once without changing any links, then changing all the links at the end of each iteration. 5 added 211 characters in body edited Aug 11 '18 at 4:26 chuckstables 37911 silver badge1313 bronze badges I'm currently writing a basic program in python to simulate a 1 + 1 dimensional yang mills gauge theory with symmetry group $$SU(2)$$. On the lattice you work with link variables, which are $$SU(N)$$ matrices defined formally as $$U_u(x) = e^{-igaA_u(x)}$$, where $$A_u(x) = \sum_{i=0}^{N^2-1}(A_u^iT^i)$$ and where $$T^i$$ is the $$i^{th}$$ generator of the $$SU(N)$$ group. The lattice action is related to the plaquettes on the lattice, where a plaquette is the smallest closed product of link variables on the lattice. To be clear: $$U_{u}(x)$$ is a vector of $$SU(N)$$ matrices: you'd have one $$SU(N)$$ matrix for each $$u$$. So $$U_x(x)$$ is a SU(N) matrix, as is $$U_t(x)$$. The monte carlo update algorithm goes like this. We look at a link on the lattice individually, and we suggest a change to said link variable, $$U_u(x) \to U'_u(x)$$ (where u is the direction of the link; in 1 + 1 dimensions it's either $$x$$ or $$t$$) We then compute the change in the action that would occur if we accepted the change $$U_u(x) \to U'_u(x)$$. If the change in the action, $$dS$$, is negative then we accept the change. If the change in the action, $$dS$$ is positive then we accept the change with a probability of $$e^{-dS}$$. We do this process for each link variable on the lattice. So; here's my question. How do I propose sufficiently small changes to an SU(N) matrix such that the average acceptance probability isn't absurdly small? I don't think I can propose changes of the form $$U_u(x) \to U_u(x) + U'_u(x)$$, where $$U'_u(x)$$ is a 'small' SU(N) matrix (if there even is such a thing), as I don't think the sum of two SU(N) matrices is generally SU(N). I could simply generate $$K$$ random SU(N) matrices, and then randomly select one of those $$K$$ $$SU(N)$$ matrices to be my proposed link variable $$U_u(x)$$. When I implement this however I end up with $$dS$$'s with large magnitudes, which means low acceptance probabilities. Which means that a large number of iterations must be done to get a configuration independent from your starting one. Sorry for the length. If anyone wants my code at the moment let me know. It's written in python, and only has an iterator and a way to generate $$K$$ random SU(2) matrices. EDIT: I think I've found the source of the discrepancy between my initial results and my current results. Let's say I generate 1000 random su(2) matrices using some algorithm. To update the link variables I propose $$U_u(x) \mapsto MU_u(x)$$, where M is one of my 1000 random su(2) matrices. I'm not sure if you can actually construct the entire space of su(2) by repeatedly multiplying these 1000 random matrices together. Even when I've changed my code to be 2+1 D su(2) yang mills, I still get the problem where my plaquette expectation value changes as I change my step size. In particular the plaquette expectation value goes UP as I decrease the step size. Only when I generate completely random su(2) matrices M to update $$U_u(x) \mapsto MU_u(x)$$ do I get the minimal plaquette size. I'm currently writing a basic program in python to simulate a 1 + 1 dimensional yang mills gauge theory with symmetry group $$SU(2)$$. On the lattice you work with link variables, which are $$SU(N)$$ matrices defined formally as $$U_u(x) = e^{-igaA_u(x)}$$, where $$A_u(x) = \sum_{i=0}^{N^2-1}(A_u^iT^i)$$ and where $$T^i$$ is the $$i^{th}$$ generator of the $$SU(N)$$ group. The lattice action is related to the plaquettes on the lattice, where a plaquette is the smallest closed product of link variables on the lattice. To be clear: $$U_{u}(x)$$ is a vector of $$SU(N)$$ matrices: you'd have one $$SU(N)$$ matrix for each $$u$$. So $$U_x(x)$$ is a SU(N) matrix, as is $$U_t(x)$$. The monte carlo update algorithm goes like this. We look at a link on the lattice individually, and we suggest a change to said link variable, $$U_u(x) \to U'_u(x)$$ (where u is the direction of the link; in 1 + 1 dimensions it's either $$x$$ or $$t$$) We then compute the change in the action that would occur if we accepted the change $$U_u(x) \to U'_u(x)$$. If the change in the action, $$dS$$, is negative then we accept the change. If the change in the action, $$dS$$ is positive then we accept the change with a probability of $$e^{-dS}$$. We do this process for each link variable on the lattice. So; here's my question. How do I propose sufficiently small changes to an SU(N) matrix such that the average acceptance probability isn't absurdly small? I don't think I can propose changes of the form $$U_u(x) \to U_u(x) + U'_u(x)$$, where $$U'_u(x)$$ is a 'small' SU(N) matrix (if there even is such a thing), as I don't think the sum of two SU(N) matrices is generally SU(N). I could simply generate $$K$$ random SU(N) matrices, and then randomly select one of those $$K$$ $$SU(N)$$ matrices to be my proposed link variable $$U_u(x)$$. When I implement this however I end up with $$dS$$'s with large magnitudes, which means low acceptance probabilities. Which means that a large number of iterations must be done to get a configuration independent from your starting one. Sorry for the length. If anyone wants my code at the moment let me know. It's written in python, and only has an iterator and a way to generate $$K$$ random SU(2) matrices. EDIT: I think I've found the source of the discrepancy between my initial results and my current results. Let's say I generate 1000 random su(2) matrices using some algorithm. To update the link variables I propose $$U_u(x) \mapsto MU_u(x)$$, where M is one of my 1000 random su(2) matrices. I'm not sure if you can actually construct the entire space of su(2) by repeatedly multiplying these 1000 random matrices together. Even when I've changed my code to be 2+1 D su(2) yang mills, I still get the problem where my plaquette expectation value changes as I change my step size. I'm currently writing a basic program in python to simulate a 1 + 1 dimensional yang mills gauge theory with symmetry group $$SU(2)$$. On the lattice you work with link variables, which are $$SU(N)$$ matrices defined formally as $$U_u(x) = e^{-igaA_u(x)}$$, where $$A_u(x) = \sum_{i=0}^{N^2-1}(A_u^iT^i)$$ and where $$T^i$$ is the $$i^{th}$$ generator of the $$SU(N)$$ group. The lattice action is related to the plaquettes on the lattice, where a plaquette is the smallest closed product of link variables on the lattice. To be clear: $$U_{u}(x)$$ is a vector of $$SU(N)$$ matrices: you'd have one $$SU(N)$$ matrix for each $$u$$. So $$U_x(x)$$ is a SU(N) matrix, as is $$U_t(x)$$. The monte carlo update algorithm goes like this. We look at a link on the lattice individually, and we suggest a change to said link variable, $$U_u(x) \to U'_u(x)$$ (where u is the direction of the link; in 1 + 1 dimensions it's either $$x$$ or $$t$$) We then compute the change in the action that would occur if we accepted the change $$U_u(x) \to U'_u(x)$$. If the change in the action, $$dS$$, is negative then we accept the change. If the change in the action, $$dS$$ is positive then we accept the change with a probability of $$e^{-dS}$$. We do this process for each link variable on the lattice. So; here's my question. How do I propose sufficiently small changes to an SU(N) matrix such that the average acceptance probability isn't absurdly small? I don't think I can propose changes of the form $$U_u(x) \to U_u(x) + U'_u(x)$$, where $$U'_u(x)$$ is a 'small' SU(N) matrix (if there even is such a thing), as I don't think the sum of two SU(N) matrices is generally SU(N). I could simply generate $$K$$ random SU(N) matrices, and then randomly select one of those $$K$$ $$SU(N)$$ matrices to be my proposed link variable $$U_u(x)$$. When I implement this however I end up with $$dS$$'s with large magnitudes, which means low acceptance probabilities. Which means that a large number of iterations must be done to get a configuration independent from your starting one. Sorry for the length. If anyone wants my code at the moment let me know. It's written in python, and only has an iterator and a way to generate $$K$$ random SU(2) matrices. EDIT: I think I've found the source of the discrepancy between my initial results and my current results. Let's say I generate 1000 random su(2) matrices using some algorithm. To update the link variables I propose $$U_u(x) \mapsto MU_u(x)$$, where M is one of my 1000 random su(2) matrices. I'm not sure if you can actually construct the entire space of su(2) by repeatedly multiplying these 1000 random matrices together. Even when I've changed my code to be 2+1 D su(2) yang mills, I still get the problem where my plaquette expectation value changes as I change my step size. In particular the plaquette expectation value goes UP as I decrease the step size. Only when I generate completely random su(2) matrices M to update $$U_u(x) \mapsto MU_u(x)$$ do I get the minimal plaquette size. 4 added 81 characters in body edited Aug 11 '18 at 4:15 chuckstables 37911 silver badge1313 bronze badges 3 added 501 characters in body edited Aug 10 '18 at 19:59 chuckstables 37911 silver badge1313 bronze badges 2 added 4 characters in body; edited tags edited Aug 8 '18 at 3:56 Qmechanic♦ 114k1313 gold badges225225 silver badges13521352 bronze badges 1 asked Jul 28 '18 at 20:54 chuckstables 37911 silver badge1313 bronze badges