User:Justin545

This is a Wikipedia user page. This is not an encyclopedia article or the talk page for an encyclopedia article. If you find this page on any site other than Wikipedia, you are viewing a mirror site. Be aware that the page may be outdated and that the user whom this page is about may have no personal affiliation with any site other than Wikipedia. The original page is located at https://en.wikipedia.org/wiki/User:Justin545.

1. /sandbox (personal sandbox)
2. /sandbox/ex
3. /sandbox/ex2
4. /sandbox/ex3
5. /sandbox/Template:NumBlk (for Special:TemplateSandbox)
6. /Private Note
7. /Glossary
8. /Valuables
9. /IRC
10. /Blog comments
11. /.emacs
12. /mtbv
13. /regtst.cpp
14. /CheckPrintCall.cxx

1. List of XML and HTML character entity references
2. Wikipedia:WikiProject User scripts/Scripts
3. How to mount LVM volumes, help! (keyword="mount LVM fedora")
4. Template:AD
5. Ubuntu 下安装 JRE (Java Runtime Environment)
6. Red/Black Tree Demonstration
7. Multi Thread Programming
8. epoll()簡單介紹（轉貼）
9. AVL Trees vs. Red-Black Trees?
10. Virtual memory areas (VMAs) are tracked with red-black trees, as are epoll file descriptors
11. Epoll calls rb_set_parent(n, n) to initialize the rb-tree node
12. reentrant，thread-safe 和 async-signal-safe
13. Linux Interprocess Communications
14. Comparing the aio and epoll event frameworks
15. Linux Kernel IPC 的介紹
16. 可重入性 线程安全 Async-Signal-Safe
17. Bash Shell Script可以做到光棒上下移動選單的功能嗎 ?
18. ANSI escape code
19. Understanding the Linux Kernel
20. (IEEE make manual) The Open Group Base Specifications Issue 6 IEEE Std 1003.1, 2004 Edition manual
21. 在Emacs裡面使用Cscope
22. IEs4Linux
23. 將隨身碟格式化成 NTFS
24. [17] Exceptions and error handling
25. Performance (Apple Developer Connection)
26. What every programmer should know about memory
27. Polymorphic Inline Cache
28. Context Threading: A Flexible and Efficient Dispatch Technique for Virtual Machine Interpreters
29. Branch prediction
30. http://www.open-std.org/jtc1/sc22/wg...1997/N1124.pdf
31. All about Linux signals
32. LLVM - Low-Level Virtual Machine
33. C++ Literal Constants
34. mips 和 mipsel 的差異
35. Garbage Collection
36. Re: Problems with glibc-2.2.2 and threads (realtime signal)
37. 搭建LLVM實驗環境(轉貼)
38. Simple VM JIT with LLVM
39. Communicating sequential processes (CSP) mentioned in Go language
40. The Very Basics of Garbage Collection (see 'Myths' section)
41. Ch interpreter (an embeddable C/C++ interpreter)
42. JDownloader
43. Log-Out of Google Account
44. 在 Ubuntu 9.04 設置 Android 開發環境
45. Java not found. Java is required for Android
46. How to install Android SDK and play with Android 2.0 in the emulator
47. Access Android Market from Android Emulator
48. Dalvik spends 7.4% of its time garbage collecting => Android UI spends 7.4% of its time unresponsive
49. Kernel : likely/unlikely macros (gcc branch prediction information `__builtin_expect()')
50. [資料] Dalvik VM的JIT編譯器的資料堆積(dumping...work in progress)
51. How does garbage collection work? (generational garbage collector)
52. Using Generational Garbage Collection To Implement Cache-Conscious Data Placement
53. gcc 預先定義的巨集 (__func__, __FUNCTION__, __PRETTY_FUNCTION__)
54. Re: Force GCC to unroll a loop? (loop unrolling could consume instruction cache and reduce performance)

1. Linux man
2. POSIX:2008
3. phpMan
4. Ubuntu Manpage
5. die.net
6. About.com

• Try-catch makes the code tidy and readable, without try-catch the code becomes ugly as you need to check the result and handle exceptions after each function call. However, it is performed in run-time and have overhead each time a function is called?

• Gmail Manager: A Gmail notifier which allows you to receive new mail notifications.

• Signals
• File system
• Out of memory (heap)

• Add/remove code usually changes the execution speed of the program. Which could affects the timing between different tasks, such as timeout mechanism or time restrictions in real-time systems. In the extreme case, the execution could be blocked and causes starvations/deadlocks. Add/remove code actually affects the program counter.

• It should be helpful to prevent deadlock by checking each statement one by one in the locked area and make sure each one will not block the execution.

##  Sharing folder

##  Modify '/etc/exports', for example:
##
##      /nfstmp *(rw,sync)

sudo /etc/init.d/nfs-kernel-server restart

• Ask community if it's a bug: Emacs seems to hang when some of SCIM are killed or closed.

;;  You can also use `M-x customize-variable <RET> x-select-enable-clipboard <RET>' to change the variable by Emacs UI.
(setq-default x-select-enable-clipboard t)

;;(defun x-clipboard-edit-key()
;;  (global-set-key [(shift delete)] 'clipboard-kill-region)
;;  (global-set-key [(control insert)] 'clipboard-kill-ring-save)
;;  (global-set-key [(shift insert)] 'x-clipboard-yank))

Emacs for MS Windows:
<S-delete> runs the command kill-region
<C-insert> runs the command kill-ring-save
<S-insert> runs the command yank

svnadmin cteate /tmp/tstprj
mkdir /tmp/workdir
cd /tmp/workdir
svn co file:///tmp/tstprj
cd tstprj
cp /etc/fstab .
svn add fstab
svn ci --username=justin

cat << 'EOF' > /tmp/PrintPos.sh
#!/bin/bash
c=$#
i=1
while [ $i -le $c ]; do
    echo "\$$i='$1'"
    shift
    i=$(($i + 1))
done
EOF
chmod a+x /tmp/PrintPos.sh

cat << 'EOF' > /tmp/ConcurDiffWrap.sh
#!/bin/bash

##  !! There is interval between @a1@ and @a2@ such that other process would
##  interfere the execution within the interval.
NewTmpDir()
{
    local Node

    while :; do
        Node=$RANDOM
        if [ ! -e /tmp/${Node} ]; then # @a1@
            mkdir /tmp/${Node}  # @a2@
            eval "${1}=/tmp/${Node}"
            return
        fi
    done
}

NewTmpDir Dir

mv "$6" "${Dir}/Old" || echo 'Cannot move $6'
echo '' > "$6"
mv "$7" "${Dir}/New" || echo 'Cannot move $7'
echo '' > "$7"

meld "$1" "$2" "$3" "$4" "$5" "${Dir}/Old" "${Dir}/New" &

##  Print positional parameters.
##
##  Put this segment at positions where positional parameter are no longer used,
##  becasue there are `shift' in this segment.
c=$#
i=1
while [ $i -le $c ]; do
    echo "\$$i='$1'"
    shift
    i=$(($i + 1))
done

echo '==================================================================='
EOF
chmod a+x /tmp/ConcurDiffWrap.sh

svn di -r 2:3 --diff-cmd /tmp/ConcurDiffWrap.sh

• minicom in English UI

$ LANG=en_US.UTF-8 sudo minicom

• Ctrl-A Z T and change terminal setting from VT102 to ANSI

mkdir /tmp/ramdisk
sudo mount -t tmpfs -o size=16 tmpfs /tmp/ramdisk

sudo umount /tmp/ramdisk

"The scalar product or action is written as

⟨ ϕ ∣ ψ ⟩ . {\displaystyle \langle \phi {\mid }\psi \rangle .}

The right part is called the ket /kɛt/; it is a vector, typically represented as a column vector, and written | ψ ⟩ . {\displaystyle |\psi \rangle .}

The left part is called the bra, /brɑː/; it is the Hermitian conjugate of the ket with the same label, typically represented as a row vector, and written ⟨ ϕ | . {\displaystyle \langle \phi |.} " - Bra–ket notation

| 0 ⟩ = [ 1 0 ] {\displaystyle |0\rangle ={\begin{bmatrix}1\\0\end{bmatrix}}} and | 1 ⟩ = [ 0 1 ] {\displaystyle |1\rangle ={\begin{bmatrix}0\\1\end{bmatrix}}}

| ψ 1 ⟩ = a | 0 ⟩ + b | 1 ⟩ = a [ 1 0 ] + b [ 0 1 ] = [ a 0 ] + [ 0 b ] = [ a b ] {\displaystyle |\psi _{1}\rangle =a|0\rangle +b|1\rangle =a{\begin{bmatrix}1\\0\end{bmatrix}}+b{\begin{bmatrix}0\\1\end{bmatrix}}={\begin{bmatrix}a\\0\end{bmatrix}}+{\begin{bmatrix}0\\b\end{bmatrix}}={\begin{bmatrix}a\\b\end{bmatrix}}}

| ψ 2 ⟩ = c | 0 ⟩ + d | 1 ⟩ = [ c d ] {\displaystyle |\psi _{2}\rangle =c|0\rangle +d|1\rangle ={\begin{bmatrix}c\\d\end{bmatrix}}}

| 00 ⟩ = | 0 ⟩ ⊗ | 0 ⟩ = [ 1 0 ] ⊗ [ 1 0 ] = [ 1 0 0 0 ] {\displaystyle |00\rangle =|0\rangle \otimes |0\rangle ={\begin{bmatrix}1\\0\end{bmatrix}}\otimes {\begin{bmatrix}1\\0\end{bmatrix}}={\begin{bmatrix}1\\0\\0\\0\end{bmatrix}}}

| 01 ⟩ = | 0 ⟩ ⊗ | 1 ⟩ = [ 1 0 ] ⊗ [ 0 1 ] = [ 0 1 0 0 ] {\displaystyle |01\rangle =|0\rangle \otimes |1\rangle ={\begin{bmatrix}1\\0\end{bmatrix}}\otimes {\begin{bmatrix}0\\1\end{bmatrix}}={\begin{bmatrix}0\\1\\0\\0\end{bmatrix}}}

| 10 ⟩ = | 1 ⟩ ⊗ | 0 ⟩ = [ 0 1 ] ⊗ [ 1 0 ] = [ 0 0 1 0 ] {\displaystyle |10\rangle =|1\rangle \otimes |0\rangle ={\begin{bmatrix}0\\1\end{bmatrix}}\otimes {\begin{bmatrix}1\\0\end{bmatrix}}={\begin{bmatrix}0\\0\\1\\0\end{bmatrix}}}

| 11 ⟩ = | 1 ⟩ ⊗ | 1 ⟩ = [ 0 1 ] ⊗ [ 0 1 ] = [ 0 0 0 1 ] {\displaystyle |11\rangle =|1\rangle \otimes |1\rangle ={\begin{bmatrix}0\\1\end{bmatrix}}\otimes {\begin{bmatrix}0\\1\end{bmatrix}}={\begin{bmatrix}0\\0\\0\\1\end{bmatrix}}}

| ψ 1 ψ 2 ⟩ = | ψ 1 ⟩ ⊗ | ψ 2 ⟩ = ( a | 0 ⟩ + b | 1 ⟩ ) ⊗ ( c | 0 ⟩ + d | 1 ⟩ ) = a c | 0 ⟩ ⊗ | 0 ⟩ + a d | 0 ⟩ ⊗ | 1 ⟩ + b c | 1 ⟩ ⊗ | 0 ⟩ + b d | 1 ⟩ ⊗ | 1 ⟩ = a c | 00 ⟩ + a d | 01 ⟩ + b c | 10 ⟩ + b d | 11 ⟩ = a c [ 1 0 0 0 ] + a d [ 0 1 0 0 ] + b c [ 0 0 1 0 ] + b d [ 0 0 0 1 ] = [ a c a d b c b d ] {\displaystyle |\psi _{1}\psi _{2}\rangle =|\psi _{1}\rangle \otimes |\psi _{2}\rangle =(a|0\rangle +b|1\rangle )\otimes (c|0\rangle +d|1\rangle )=ac|0\rangle \otimes |0\rangle +ad|0\rangle \otimes |1\rangle +bc|1\rangle \otimes |0\rangle +bd|1\rangle \otimes |1\rangle =ac|00\rangle +ad|01\rangle +bc|10\rangle +bd|11\rangle =ac{\begin{bmatrix}1\\0\\0\\0\end{bmatrix}}+ad{\begin{bmatrix}0\\1\\0\\0\end{bmatrix}}+bc{\begin{bmatrix}0\\0\\1\\0\end{bmatrix}}+bd{\begin{bmatrix}0\\0\\0\\1\end{bmatrix}}={\begin{bmatrix}ac\\ad\\bc\\bd\end{bmatrix}}}

| ψ 1 ψ 2 ⟩ = | ψ 1 ⟩ ⊗ | ψ 2 ⟩ = [ a b ] ⊗ [ c d ] = [ a c a d b c b d ] {\displaystyle |\psi _{1}\psi _{2}\rangle =|\psi _{1}\rangle \otimes |\psi _{2}\rangle ={\begin{bmatrix}a\\b\end{bmatrix}}\otimes {\begin{bmatrix}c\\d\end{bmatrix}}={\begin{bmatrix}ac\\ad\\bc\\bd\end{bmatrix}}}

1. "Any quantum circuit can be simulated to an arbitrary degree of accuracy using a combination of CNOT gates and single qubit rotations." - Controlled NOT gate
2. "The first implementation scheme for a controlled-NOT quantum gate was proposed by Ignacio Cirac and Peter Zoller in 1995" - Trapped_ion_quantum_computer#History_of_trapped_ion_quantum_computing
3. "Because the number of elements in the matrices is 2 2 x {\displaystyle 2^{2x}} , where x is the number of qubits the gates act on, it is intractable to simulate large quantum systems using classical computers." - Quantum_gate#Circuit_composition_and_entangled_states

X = N O T = [ 0 1 1 0 ] {\displaystyle X=NOT={\begin{bmatrix}0&1\\1&0\end{bmatrix}}} .

X = N O T = 1 2 [ 1 + i 1 − i 1 − i 1 + i ] {\displaystyle {\sqrt {X}}={\sqrt {NOT}}={\frac {1}{2}}{\begin{bmatrix}1+i&1-i\\1-i&1+i\end{bmatrix}}}

N O T N O T = ( 1 2 [ 1 + i 1 − i 1 − i 1 + i ] ) ( 1 2 [ 1 + i 1 − i 1 − i 1 + i ] ) {\displaystyle {\sqrt {NOT}}\,{\sqrt {NOT}}=\left({\frac {1}{2}}{\begin{bmatrix}1+i&1-i\\1-i&1+i\end{bmatrix}}\right)\left({\frac {1}{2}}{\begin{bmatrix}1+i&1-i\\1-i&1+i\end{bmatrix}}\right)}

= [ 1 2 ( 1 + i ) 1 2 ( 1 − i ) 1 2 ( 1 − i ) 1 2 ( 1 + i ) ] [ 1 2 ( 1 + i ) 1 2 ( 1 − i ) 1 2 ( 1 − i ) 1 2 ( 1 + i ) ] {\displaystyle ={\begin{bmatrix}{\frac {1}{2}}(1+i)&{\frac {1}{2}}(1-i)\\{\frac {1}{2}}(1-i)&{\frac {1}{2}}(1+i)\end{bmatrix}}{\begin{bmatrix}{\frac {1}{2}}(1+i)&{\frac {1}{2}}(1-i)\\{\frac {1}{2}}(1-i)&{\frac {1}{2}}(1+i)\end{bmatrix}}}

= [ 1 2 ( 1 + i ) 1 2 ( 1 + i ) + 1 2 ( 1 − i ) 1 2 ( 1 − i ) 1 2 ( 1 + i ) 1 2 ( 1 − i ) + 1 2 ( 1 − i ) 1 2 ( 1 + i ) 1 2 ( 1 − i ) 1 2 ( 1 + i ) + 1 2 ( 1 + i ) 1 2 ( 1 − i ) 1 2 ( 1 − i ) 1 2 ( 1 − i ) + 1 2 ( 1 + i ) 1 2 ( 1 + i ) ] {\displaystyle ={\begin{bmatrix}{\frac {1}{2}}(1+i){\frac {1}{2}}(1+i)+{\frac {1}{2}}(1-i){\frac {1}{2}}(1-i)&{\frac {1}{2}}(1+i){\frac {1}{2}}(1-i)+{\frac {1}{2}}(1-i){\frac {1}{2}}(1+i)\\{\frac {1}{2}}(1-i){\frac {1}{2}}(1+i)+{\frac {1}{2}}(1+i){\frac {1}{2}}(1-i)&{\frac {1}{2}}(1-i){\frac {1}{2}}(1-i)+{\frac {1}{2}}(1+i){\frac {1}{2}}(1+i)\end{bmatrix}}}

= [ 1 2 ( 1 + i ) 1 2 ( 1 + i ) + 1 2 ( 1 − i ) 1 2 ( 1 − i ) 1 2 ( 1 + i ) 1 2 ( 1 − i ) + 1 2 ( 1 − i ) 1 2 ( 1 + i ) 1 2 ( 1 + i ) 1 2 ( 1 − i ) + 1 2 ( 1 − i ) 1 2 ( 1 + i ) 1 2 ( 1 + i ) 1 2 ( 1 + i ) + 1 2 ( 1 − i ) 1 2 ( 1 − i ) ] {\displaystyle ={\begin{bmatrix}{\frac {1}{2}}(1+i){\frac {1}{2}}(1+i)+{\frac {1}{2}}(1-i){\frac {1}{2}}(1-i)&{\frac {1}{2}}(1+i){\frac {1}{2}}(1-i)+{\frac {1}{2}}(1-i){\frac {1}{2}}(1+i)\\{\frac {1}{2}}(1+i){\frac {1}{2}}(1-i)+{\frac {1}{2}}(1-i){\frac {1}{2}}(1+i)&{\frac {1}{2}}(1+i){\frac {1}{2}}(1+i)+{\frac {1}{2}}(1-i){\frac {1}{2}}(1-i)\end{bmatrix}}}

= [ 1 2 1 2 ( 1 + i ) ( 1 + i ) + 1 2 1 2 ( 1 − i ) ( 1 − i ) 1 2 1 2 ( 1 + i ) ( 1 − i ) + 1 2 1 2 ( 1 − i ) ( 1 + i ) 1 2 1 2 ( 1 + i ) ( 1 − i ) + 1 2 1 2 ( 1 − i ) ( 1 + i ) 1 2 1 2 ( 1 + i ) ( 1 + i ) + 1 2 1 2 ( 1 − i ) ( 1 − i ) ] {\displaystyle ={\begin{bmatrix}{\frac {1}{2}}{\frac {1}{2}}(1+i)(1+i)+{\frac {1}{2}}{\frac {1}{2}}(1-i)(1-i)&{\frac {1}{2}}{\frac {1}{2}}(1+i)(1-i)+{\frac {1}{2}}{\frac {1}{2}}(1-i)(1+i)\\{\frac {1}{2}}{\frac {1}{2}}(1+i)(1-i)+{\frac {1}{2}}{\frac {1}{2}}(1-i)(1+i)&{\frac {1}{2}}{\frac {1}{2}}(1+i)(1+i)+{\frac {1}{2}}{\frac {1}{2}}(1-i)(1-i)\end{bmatrix}}}

= [ 1 4 ( 1 + i ) ( 1 + i ) + 1 4 ( 1 − i ) ( 1 − i ) 1 4 ( 1 + i ) ( 1 − i ) + 1 4 ( 1 − i ) ( 1 + i ) 1 4 ( 1 + i ) ( 1 − i ) + 1 4 ( 1 − i ) ( 1 + i ) 1 4 ( 1 + i ) ( 1 + i ) + 1 4 ( 1 − i ) ( 1 − i ) ] {\displaystyle ={\begin{bmatrix}{\frac {1}{4}}(1+i)(1+i)+{\frac {1}{4}}(1-i)(1-i)&{\frac {1}{4}}(1+i)(1-i)+{\frac {1}{4}}(1-i)(1+i)\\{\frac {1}{4}}(1+i)(1-i)+{\frac {1}{4}}(1-i)(1+i)&{\frac {1}{4}}(1+i)(1+i)+{\frac {1}{4}}(1-i)(1-i)\end{bmatrix}}}

= [ 1 4 [ ( 1 + i ) ( 1 + i ) + ( 1 − i ) ( 1 − i ) ] 1 4 [ ( 1 + i ) ( 1 − i ) + ( 1 − i ) ( 1 + i ) ] 1 4 [ ( 1 + i ) ( 1 − i ) + ( 1 − i ) ( 1 + i ) ] 1 4 [ ( 1 + i ) ( 1 + i ) + ( 1 − i ) ( 1 − i ) ] ] {\displaystyle ={\begin{bmatrix}{\frac {1}{4}}[(1+i)(1+i)+(1-i)(1-i)]&{\frac {1}{4}}[(1+i)(1-i)+(1-i)(1+i)]\\{\frac {1}{4}}[(1+i)(1-i)+(1-i)(1+i)]&{\frac {1}{4}}[(1+i)(1+i)+(1-i)(1-i)]\end{bmatrix}}}

= 1 4 [ ( 1 + i ) ( 1 + i ) + ( 1 − i ) ( 1 − i ) ( 1 + i ) ( 1 − i ) + ( 1 − i ) ( 1 + i ) ( 1 + i ) ( 1 − i ) + ( 1 − i ) ( 1 + i ) ( 1 + i ) ( 1 + i ) + ( 1 − i ) ( 1 − i ) ] {\displaystyle ={\frac {1}{4}}{\begin{bmatrix}(1+i)(1+i)+(1-i)(1-i)&(1+i)(1-i)+(1-i)(1+i)\\(1+i)(1-i)+(1-i)(1+i)&(1+i)(1+i)+(1-i)(1-i)\end{bmatrix}}}

= 1 4 [ ( 1 + i + i + i 2 ) + ( 1 − i − i + i 2 ) ( 1 − i + i − i 2 ) + ( 1 + i − i − i 2 ) ( 1 − i + i − i 2 ) + ( 1 + i − i − i 2 ) ( 1 + i + i + i 2 ) + ( 1 − i − i + i 2 ) ] {\displaystyle ={\frac {1}{4}}{\begin{bmatrix}(1+i+i+i^{2})+(1-i-i+i^{2})&(1-i+i-i^{2})+(1+i-i-i^{2})\\(1-i+i-i^{2})+(1+i-i-i^{2})&(1+i+i+i^{2})+(1-i-i+i^{2})\end{bmatrix}}}

= 1 4 [ ( 1 + 2 i − 1 ) + ( 1 − 2 i − 1 ) ( 1 − ( − 1 ) ) + ( 1 − ( − 1 ) ) ( 1 − ( − 1 ) ) + ( 1 − ( − 1 ) ) ( 1 + 2 i − 1 ) + ( 1 − 2 i − 1 ) ] {\displaystyle ={\frac {1}{4}}{\begin{bmatrix}(1+2i-1)+(1-2i-1)&(1-(-1))+(1-(-1))\\(1-(-1))+(1-(-1))&(1+2i-1)+(1-2i-1)\end{bmatrix}}}

= 1 4 [ 2 i + ( − 2 i ) 2 + 2 2 + 2 2 i + ( − 2 i ) ] {\displaystyle ={\frac {1}{4}}{\begin{bmatrix}2i+(-2i)&2+2\\2+2&2i+(-2i)\end{bmatrix}}}

= 1 4 [ 0 4 4 0 ] {\displaystyle ={\frac {1}{4}}{\begin{bmatrix}0&4\\4&0\end{bmatrix}}}

= [ 0 1 1 0 ] = N O T = X {\displaystyle ={\begin{bmatrix}0&1\\1&0\end{bmatrix}}=NOT=X}

In fact, you can use the service of online symbolic mathematics to do the above work for you. Related links:

1. Mathics
2. Online tools for doing symbolic mathematics - Mathematics Stack Exchange

p 00 : | 00 ⟩ ↦ | 00 ⟩ {\displaystyle p_{00}:\,\,|00\rangle \mapsto |00\rangle }
p 01 : | 01 ⟩ ↦ | 01 ⟩ {\displaystyle p_{01}:\,\,|01\rangle \mapsto |01\rangle }
p 10 : | 10 ⟩ ↦ | 11 ⟩ {\displaystyle p_{10}:\,\,|10\rangle \mapsto |11\rangle }
p 11 : | 11 ⟩ ↦ | 10 ⟩ {\displaystyle p_{11}:\,\,|11\rangle \mapsto |10\rangle }

The meaning of notation above:

For example, state | 01 ⟩ {\displaystyle |01\rangle } means that the first qubit is 0 and the second qubit is 1. If, for example, p 01 = 0.7 {\displaystyle p_{01}=0.7} , it means that state | 01 ⟩ {\displaystyle |01\rangle } appears with probability 0.7 after measurements.

The above map is the result of a series of quntum program executions which applying CNOT gate on the system. But you can not know the map beforehand, so how to know the value of the second qubit after applying the quantum gate operation above? Here is what you may do:

You should be able to encode the system so that each state appears with the probability according to your design. Suppose that you encode the system so that the probability distribution is

p 00 = 0.4 {\displaystyle p_{00}=0.4}

p 01 = 0.3 {\displaystyle p_{01}=0.3}

p 10 = 0.2 {\displaystyle p_{10}=0.2}

p 11 = 0.1 {\displaystyle p_{11}=0.1}

(note that p 00 + p 01 + p 10 + p 11 = 1 {\displaystyle p_{00}+p_{01}+p_{10}+p_{11}=1} )

Suppose that you want to know the second qubit's value of state | 10 ⟩ {\displaystyle |10\rangle } after the quantum operation. Because the corresponding probability you have encoded is p 10 = 0.2 {\displaystyle p_{10}=0.2} , you should be able to find one of 4 after-operation states | 00 ⟩ {\displaystyle |00\rangle } , | 01 ⟩ {\displaystyle |01\rangle } , | 10 ⟩ {\displaystyle |10\rangle } and | 11 ⟩ {\displaystyle |11\rangle } appears with probability 0.2 as you repeat the quantum program over and over several times. And you will finally realize that state | 11 ⟩ {\displaystyle |11\rangle } appears with probability 0.2 after you repeat enough the quantum program, so it means the state transition is from | 10 ⟩ {\displaystyle |10\rangle } to | 11 ⟩ {\displaystyle |11\rangle } and therefore the second qubit's value changes from 0 to 1 after the quantum operation.

CNOT = ( 1 0 0 0 0 1 0 0 0 0 0 1 0 0 1 0 ) {\displaystyle {\mbox{CNOT}}=\left({\begin{array}{cccc}1&0&0&0\\0&1&0&0\\0&0&0&1\\0&0&1&0\end{array}}\right)}

I ⊗ CNOT = ( 1 0 0 1 ) ⊗ ( 1 0 0 0 0 1 0 0 0 0 0 1 0 0 1 0 ) = ( 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 ) {\displaystyle I\otimes {\mbox{CNOT}}=\left({\begin{array}{cc}1&0\\0&1\end{array}}\right)\otimes \left({\begin{array}{cccc}1&0&0&0\\0&1&0&0\\0&0&0&1\\0&0&1&0\end{array}}\right)=\left({\begin{array}{cccccccc}1&0&0&0&0&0&0&0\\0&1&0&0&0&0&0&0\\0&0&0&1&0&0&0&0\\0&0&1&0&0&0&0&0\\0&0&0&0&1&0&0&0\\0&0&0&0&0&1&0&0\\0&0&0&0&0&0&0&1\\0&0&0&0&0&0&1&0\end{array}}\right)}

| ψ ⟩ = ( a b c d e f g h ) {\displaystyle |\psi \rangle =\left({\begin{array}{c}a\\b\\c\\d\\e\\f\\g\\h\end{array}}\right)}

( I ⊗ CNOT ) | ψ ⟩ = ( 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 ) ( a b c d e f g h ) = ( a b d c e f h g ) qubits 000 qubits 001 qubits 010 qubits 011 qubits 100 qubits 101 qubits 110 qubits 111 {\displaystyle (I\otimes {\mbox{CNOT}})|\psi \rangle =\left({\begin{array}{cccccccc}1&0&0&0&0&0&0&0\\0&1&0&0&0&0&0&0\\0&0&0&1&0&0&0&0\\0&0&1&0&0&0&0&0\\0&0&0&0&1&0&0&0\\0&0&0&0&0&1&0&0\\0&0&0&0&0&0&0&1\\0&0&0&0&0&0&1&0\end{array}}\right)\left({\begin{array}{c}a\\b\\c\\d\\e\\f\\g\\h\end{array}}\right)=\left({\begin{array}{c}a\\b\\d\\c\\e\\f\\h\\g\end{array}}\right)\,\,\,{\begin{array}{c}{\text{qubits 000}}\\{\text{qubits 001}}\\{\text{qubits 010}}\\{\text{qubits 011}}\\{\text{qubits 100}}\\{\text{qubits 101}}\\{\text{qubits 110}}\\{\text{qubits 111}}\end{array}}}

1. "If the discount factor meets or exceeds 1, the Q {\displaystyle Q} values may diverge." - State–action–reward–state–action#Discount_factor_(gamma)

Simplify by letting α = γ = 1 {\displaystyle \alpha =\gamma =1} . The result should be more close to dynamic programming.

Q-learning

Q ( s t , a t ) ← ( 1 − α ) ⋅ Q ( s t , a t ) ⏟ o l d   v a l u e + α ⏟ l e a r n i n g   r a t e ⋅ ( r t ⏟ r e w a r d + γ ⏟ d i s c o u n t   f a c t o r ⋅ max a Q ( s t + 1 , a ) ⏟ e s t i m a t e   o f   o p t i m a l   f u t u r e   v a l u e ) ⏞ l e a r n e d   v a l u e {\displaystyle Q(s_{t},a_{t})\leftarrow (1-\alpha )\cdot \underbrace {Q(s_{t},a_{t})} _{\rm {old~value}}+\underbrace {\alpha } _{\rm {learning~rate}}\cdot \overbrace {{\bigg (}\underbrace {r_{t}} _{\rm {reward}}+\underbrace {\gamma } _{\rm {discount~factor}}\cdot \underbrace {\max _{a}Q(s_{t+1},a)} _{\rm {estimate~of~optimal~future~value}}{\bigg )}} ^{\rm {learned~value}}}

Q ( s t , a t ) ← ( 1 − α ) ⋅ Q ( s t , a t ) + α ⋅ ( r t + γ ⋅ max a Q ( s t + 1 , a ) ) ⏞ l e a r n e d   v a l u e {\displaystyle Q(s_{t},a_{t})\leftarrow (1-\alpha )\cdot Q(s_{t},a_{t})+\alpha \cdot \overbrace {{\bigg (}r_{t}+\gamma \cdot \max _{a}Q(s_{t+1},a){\bigg )}} ^{\rm {learned~value}}}

Q ( s t , a t ) ← ( 1 − α ) ⋅ Q ( s t , a t ) + α ⋅ ( r t + γ ⋅ max a Q ( s t + 1 , a ) ) {\displaystyle Q(s_{t},a_{t})\leftarrow (1-\alpha )\cdot Q(s_{t},a_{t})+\alpha \cdot {\bigg (}r_{t}+\gamma \cdot \max _{a}Q(s_{t+1},a){\bigg )}}

Q ( s t , a t ) ← r t + max a Q ( s t + 1 , a ) {\displaystyle Q(s_{t},a_{t})\leftarrow r_{t}+\max _{a}Q(s_{t+1},a)}

SARSA

Q ( s t , a t ) ← Q ( s t , a t ) + α [ r t + γ Q ( s t + 1 , a t + 1 ) − Q ( s t , a t ) ] {\displaystyle Q(s_{t},a_{t})\leftarrow Q(s_{t},a_{t})+\alpha [r_{t}+\gamma Q(s_{t+1},a_{t+1})-Q(s_{t},a_{t})]}

Q ( s t , a t ) ← Q ( s t , a t ) + [ r t + γ Q ( s t + 1 , a t + 1 ) − Q ( s t , a t ) ] {\displaystyle Q(s_{t},a_{t})\leftarrow Q(s_{t},a_{t})+[r_{t}+\gamma Q(s_{t+1},a_{t+1})-Q(s_{t},a_{t})]}

Q ( s t , a t ) ← Q ( s t , a t ) + r t + γ Q ( s t + 1 , a t + 1 ) − Q ( s t , a t ) {\displaystyle Q(s_{t},a_{t})\leftarrow Q(s_{t},a_{t})+r_{t}+\gamma Q(s_{t+1},a_{t+1})-Q(s_{t},a_{t})}

Q ( s t , a t ) ← r t + Q ( s t + 1 , a t + 1 ) {\displaystyle Q(s_{t},a_{t})\leftarrow r_{t}+Q(s_{t+1},a_{t+1})}

int pipefd[2];

void handler(int signum)
{
  char ch = 0;
  write(pipefd[1], &ch, sizeof(ch));
}

void startRoutine(SIMP_SOCK_Arg_T *arg)
{
  //  ...
  pipe(pipefd);
  fcntl(pipefd[0], F_SETFL, fcntl(pipefd[0], F_GETFL) | O_NONBLOCK);
  fcntl(pipefd[1], F_SETFL, fcntl(pipefd[1], F_GETFL) | O_NONBLOCK);
  signal(SIGTERM, handler);

  FD_ZERO(&rfds);
  FD_SET(arg->mSock.mSocket, &rfds);
  FD_SET(pipefd[0], &rfds);
  //  ...
  while (1)
  {
    _rfds = rfds;
    //  ...
    if (select(maxfd + 1, &_rfds, &_wfds, NULL, NULL) == -1)
    {
      if (errno == EINTR) continue;
      break;
    }

    //  ... read()/write() socket and process data ...

    //  There could be resource allocation somewhere
    void *p = malloc(...);
    //  ... do something about *p ...
    free(p);

    if (FD_ISSET(pipefd[0], &_rfds))
    {
      char ch;
      read(pipefd[0], &ch, sizeof(ch));
      break;
    }
  }
  //  ...
}

Adiabatic quantum computation
BKL singularity
BadVista
Bing
Bing (Search)
Bing (search engine)
Bing (web search engine)
Cavity quantum electrodynamics
Classical test theory
Cluster state
Coherence (physics)
Convolution
Criticism of Google
Criticism of Microsoft
Criticism of Wikipedia
Criticism of Windows 7
Device driver
Dirac delta function
Direct Rendering Manager
Euler's theorem (differential geometry)
Evolute
Fourier series
Freedesktop.org
Git (software)
Google
Google platform
Graphics Execution Manager
Guievict
Internet Explorer 8
Jordan curve theorem
Keith Packard
LOCC
Lagrange's identity
Library (computing)
List of unsolved problems in physics
Loadable kernel module
MeeGo
MeeGo (operating system)
Method of characteristics
Metric tensor
MicroXwin
Microsoft
Microsoft Office 2007
Möbius transformation
Nitrogen-vacancy center
O(1) scheduler
Office Open XML
One-way quantum computer
OpenDocument
OpenDocument software
Optical lattice
Optical pumping
Overlap-add method
Overlap–add method
Phasor
Phasor (sine waves)
Pseudo-differential operator
Pythagorean triple
Qt (framework)
Quantum channel
Quantum cryptography
Quantum error correction
Quantum gate
Quantum information
Quantum key distribution
Quantum mechanical Bell test prediction
Quantum programming
Quantum teleportation
Quasiconformal mapping
Qubit
Ratio test
Riesz transform
Selection rule
Separable state
Separable states
Squashed entanglement
Standardization of Office Open XML
Sturm-Liouville theory
Sturm–Liouville theory
Superconducting quantum computing
Topological computing
Topological quantum computer
Trapped ion quantum computer
Universal quantum simulator
Unsolved problems in physics
Wayland (display server)
Wayland (display server protocol)
Wayland display server
Windowing system
Windows 7
Windows 7/Archive 7
X Window System
Xmove
Xpra
User:HAl
User:Justin545/Blog comments
User:Justin545/Blogger
User:Justin545/IRC
User:Justin545/Private Note
User:Silly rabbit
Template:NumBlk
Template:NumBlk/doc

• xyz
• abc

• f ( x ) = a x + b {\displaystyle f(x)=ax+b}

  17

• f ( x ) = a x + b {\displaystyle f(x)=ax+b}

  57

Carbon sink