<?xml version="1.0" encoding="UTF-8"?>
<!-- generator="FeedCreator 1.8" -->
<?xml-stylesheet href="https://yanevskiv.com/lib/exe/css.php?s=feed" type="text/css"?>
<rdf:RDF
    xmlns="http://purl.org/rss/1.0/"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
    xmlns:dc="http://purl.org/dc/elements/1.1/">
    <channel rdf:about="https://yanevskiv.com/feed.php">
        <title>Ivan&#039;s wiki</title>
        <description></description>
        <link>https://yanevskiv.com/</link>
        <image rdf:resource="https://yanevskiv.com/_media/logo.png" />
       <dc:date>2026-06-06T19:06:12+00:00</dc:date>
        <items>
            <rdf:Seq>
                <rdf:li rdf:resource="https://yanevskiv.com/115200?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/arduino-uno-r4-wifi?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/assert.h?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/bash-internal?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/basis-state?rev=1779560435&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/bell-state?rev=1779716879&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/bloch-sphere?rev=1779716812&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/born-rule?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/c-headers?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/c-standard-library?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ci-cd?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/cnot-gate?rev=1779716974&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/complex.h?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/coreutils?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/cp-1?rev=1779717371&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ctype.h?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/density-matrix?rev=1779717347&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/deutsch-jozsa?rev=1779717036&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/deutsch?rev=1779717025&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/dirac-notation?rev=1779717212&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/do-while-0?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/docker?rev=1778943410&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/eigenstate?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/embedded-glossary?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/eof?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/eqn-electromagnetism?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/errno.h?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/exit-status?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/fdsa?rev=1778765059&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/fft?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/function-macro?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ghz-state?rev=1779716905&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/gist-docker?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/gist-git?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/gist-semaphores?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/git?rev=1778943393&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/gitignore?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/global-phase?rev=1779717241&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/gnu-linux?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/grover?rev=1779717069&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/h-gate?rev=1779716945&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/harvard-architecture?rev=1778954182&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/header-guard?rev=1778763693&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/hhl?rev=1779717107&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/hilbert-space?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/home?rev=1779714515&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/hopf-fibration?rev=1779717387&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/hpc?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/hsp?rev=1779717094&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/i-gate?rev=1779704114&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/i-state?rev=1779716853&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ifupdown?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/introduction-to-quantum-computing?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/iswap-gate?rev=1779717001&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/kdp20260110-1?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/kdp20260110-2?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/kdp20260218-1?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/kdp20260218-2?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/kdp20260218-3?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/kpsewhich?rev=1779031999&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/kraus-operator?rev=1779717358&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/landauers-principle?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/latex-syntax?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/latex?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/lindbald-equation?rev=1779717159&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/lindbald-master-equation?rev=1779493225&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-algorithms?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-c-concepts?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-c-headers?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-commands?rev=1779108450&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-concepts-in-quantum-control?rev=1779494717&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-concepts-in-quantum-error-correction?rev=1779494403&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-concepts?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-cpp-concepts?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-cpp-headers?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-data-structures?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-embedded-engineering-concepts?rev=1778954210&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-essential-quantum-computing-concepts?rev=1779494908&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-hardware?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-headers-cpp?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-hpc-commands?rev=1779108473&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-kdp-exercises?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-latex-commands?rev=1779030995&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-logic-gates?rev=1778943536&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-miscellaneous-quantum-computing-concepts?rev=1779495097&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-miscellaneous-topics?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-optimal-quantum-control-algorithms?rev=1779491124&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-parallel-computing-concepts?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-paths?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-quantum-algorithms?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-quantum-computing-concepts?rev=1779717440&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-quantum-computing-libraries?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-quantum-error-correction-codes?rev=1779493887&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-quantum-gates?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-quantum-states?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-software-engineering-concepts?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-software-engineering-tools?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-syntaxes?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-system-commands?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-tools?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/list-of-util-linux-commands?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/main-return?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/math-books?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/mathematical-maturity?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/matmul?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/minus-i-state?rev=1779716857&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/minus-state?rev=1779716847&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/mixed-state?rev=1779716831&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/multiqubit-gates?rev=1779716937&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/my-bookmarks?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/name-mangling?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/net-config?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/nih-syndrome?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/nisq?rev=1779717118&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/noon-state?rev=1779716926&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/numbers-every-programmer-should-know?rev=1779495120&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/nvcc?rev=1779108594&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/one-state?rev=1779717275&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/p-gate?rev=1779716953&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/past-disclaimer?rev=1779714524&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/path-usr?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/path-var?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/pauli-gate?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/pdflatex?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/perf?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/playground?rev=1778765281&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/plus-state?rev=1779716839&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/posix-headers?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/pragma-once?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/probability-amplitude?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/pure-state?rev=1779717261&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/qaoa?rev=1779717132&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/qft?rev=1779717046&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/qpe?rev=1779717058&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/quantum-algorithm?rev=1779717335&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/quantum-circuit?rev=1779717013&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/quantum-gate?rev=1779704059&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/quantum-i-gate?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/quantum-register?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/quantum-x-gate?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/quantum-y-gate?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/quantum-z-gate?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/qubit-gates-in-c?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/qubit?rev=1779715005&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/r-gate?rev=1779717325&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/rabi-cycles?rev=1779717171&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ramsey-interference?rev=1779717186&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ruin-theory?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/rule-of-5?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/rwa?rev=1779717197&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/saxpy?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/schrodinger-equation?rev=1779494585&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/semaphore.h?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/semaphore?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/shell?rev=1778764029&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/shor?rev=1779717082&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/ssh?rev=1778943426&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/state-vector?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/stdbool.h?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/string.h?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/strunk-and-white?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/swap-gate?rev=1779716993&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/syntax?rev=1778765950&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/terminal?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/test-driven-development?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/thinkpad?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/three-qubits?rev=1779716889&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/tmux?rev=1778943419&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/todo?rev=1778764571&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/toffoli-gate?rev=1779716985&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/topics?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/two-qubits?rev=1779716869&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/u-gate?rev=1779716964&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/vps?rev=1778943493&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/vqe?rev=1779717143&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/w-state?rev=1779716915&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/wip-example?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/writing-guide?rev=1779716312&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/x-gate?rev=1779704472&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/x220-gpu-rendering-with-hyprland?rev=1779736963&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/y-gate?rev=1779717302&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/yanevskiv-wiki?rev=1778758708&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/z-gate?rev=1779717314&amp;do=diff"/>
                <rdf:li rdf:resource="https://yanevskiv.com/zero-state?rev=1779717268&amp;do=diff"/>
            </rdf:Seq>
        </items>
    </channel>
    <image rdf:about="https://yanevskiv.com/_media/logo.png">
        <title>Ivan's wiki</title>
        <link>https://yanevskiv.com/</link>
        <url>https://yanevskiv.com/_media/logo.png</url>
    </image>
    <item rdf:about="https://yanevskiv.com/115200?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>115200</title>
        <link>https://yanevskiv.com/115200?rev=1778758708&amp;do=diff</link>
        <description>115200

115200 is the default baud rate for Arduino USB-UART communication.

picocom

You specify the baudrate using -b option.



 $ picocom /dev/ttyACM0 -b 115200


To exit picocom, use Ctrl + A, X. This means holding control and pressing &#039;A&#039; and &#039;X&#039;. Don&#039;t release control while switching from &#039;A&#039; to &#039;X&#039;.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/arduino-uno-r4-wifi?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Arduino Uno R4 WiFi</title>
        <link>https://yanevskiv.com/arduino-uno-r4-wifi?rev=1778758708&amp;do=diff</link>
        <description>Arduino Uno R4 WiFi

Documentation:

	* &lt;https://docs.arduino.cc/hardware/uno-r4-wifi/&gt;</description>
    </item>
    <item rdf:about="https://yanevskiv.com/assert.h?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title></title>
        <link>https://yanevskiv.com/assert.h?rev=1778758708&amp;do=diff</link>
        <description>&lt;assert.h&gt;

In C programming language, &lt;assert.h&gt; is a header which is part of the C standard library. It provides assert(), which is used for runtime assertions.

A runtime assertion is when you want to exit the program early because important condition isn&#039;t met. For example, you tried to allocate memory with</description>
    </item>
    <item rdf:about="https://yanevskiv.com/bash-internal?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of internal Bash shell commands</title>
        <link>https://yanevskiv.com/bash-internal?rev=1778758708&amp;do=diff</link>
        <description>List of internal Bash shell commands</description>
    </item>
    <item rdf:about="https://yanevskiv.com/basis-state?rev=1779560435&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-23T18:20:35+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Basis state</title>
        <link>https://yanevskiv.com/basis-state?rev=1779560435&amp;do=diff</link>
        <description>Basis state

Basis state is a state vector that is part of a basis. A basis is set of two or more quantum states out of which all other quantum states can be built through linear combination.

A qubit is a two-level quantum system so has two basis states. The standard basis $\lvert 0\rangle, \lvert 1\rangle}$$\lvert\text{cat}\rangle$$\lvert\text{dog}\rangle$$d = 2$$\lvert\psi\rangle$$a,b\in\mathbb C$$\mathbb C^2$$\mathbb C^2$$$ \lvert\psi\rangle = \begin{pmatrix}a\\b\end{pmatrix},\quad\lvert\psi…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/bell-state?rev=1779716879&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:47:59+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Bell state</title>
        <link>https://yanevskiv.com/bell-state?rev=1779716879&amp;do=diff</link>
        <description>Bell state

Bell states are the four maximally entangled two-qubit states. They form an orthonormal basis for the two-qubit Hilbert space $\mathbb{C}^4$ and are named after physicist John Bell. Bell states play a central role in quantum teleportation, superdense coding, and quantum key distribution.$$\lvert\Phi^+\rangle = \frac{1}{\sqrt{2}}(\lvert 00\rangle + \lvert 11\rangle)$$$$\lvert\Phi^-\rangle = \frac{1}{\sqrt{2}}(\lvert 00\rangle - \lvert 11\rangle)$$$$\lvert\Psi^+\rangle = \frac{1}{\sqrt…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/bloch-sphere?rev=1779716812&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:46:52+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Bloch sphere</title>
        <link>https://yanevskiv.com/bloch-sphere?rev=1779716812&amp;do=diff</link>
        <description>Bloch sphere

Bloch sphere is a geometrical representation of a single qubit state as a point on the surface of a unit sphere in three-dimensional space. It provides an intuitive way to visualize qubit states and the effect of quantum gates as rotations. The Bloch sphere is named after physicist Felix Bloch.$\lvert\psi\rangle = a\lvert 0\rangle + b\lvert 1\rangle$$a, b \in \mathbb{C}$$|a|^2 + |b|^2 = 1$$\theta \in [0, \pi]$$\varphi \in [0, 2\pi)$$$\lvert\psi\rangle = \cos\frac{\theta}{2}\lvert 0…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/born-rule?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Born rule</title>
        <link>https://yanevskiv.com/born-rule?rev=1778758708&amp;do=diff</link>
        <description>Born rule

Born rule is a postulate in quantum mechanics that gives an interpretation of probability amplitudes. Namely, probability amplitude $c\in\mathbb{C}$ associated with some state $\lvert i\rangle$ encodes the probability of finding the quantum system in the state $\lvert i\rangle$. The value of this probability $c$$$P_i = |c|^2$$$\lvert\psi\rangle$$a\in\mathbb{C}$$\lvert 0\rangle$$b\in\mathbb{C}$$\lvert 1\rangle$$$\lvert\psi\rangle = a\lvert 0\rangle + b\lvert 1\rangle$$$\lvert 0\rangle$…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/c-headers?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>C headers</title>
        <link>https://yanevskiv.com/c-headers?rev=1778758708&amp;do=diff</link>
        <description>C headers

C headers offer an interface to the C standard library.

List of headers

	* &lt;assert.h&gt;
	* &lt;complex.h&gt;
	* &lt;ctype.h&gt;
	* &lt;errno.h&gt;
	* fenv.h
	* float.h
	* inttypes.h
	* iso646.h
	* limits.h
	* locale.h
	* math.h
	* setjmp.h
	* signal.h
	* stdalign.h
	* stdarg.h
	* stdatomic.h
	* stdbit.h
	* &lt;stdbool.h&gt;
	* stdckdint.h
	* stddef.h
	* stdint.h
	* stdio.h
	* stdlib.h
	* stdmchar.h
	* stdnoreturn.h
	* &lt;string.h&gt;
	* tgmath.h
	* thread.h
	* time.h
	* uchar.h
	* wchar.h
	* wctype.h

Links

	* &lt;…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/c-standard-library?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>C standard library</title>
        <link>https://yanevskiv.com/c-standard-library?rev=1778758708&amp;do=diff</link>
        <description>C standard library

C standard library is one library that&#039;s always linked by default when you compile C programs.

To use the library, a set of headers is offered which you can include by default.

For example, &lt;stdlib.h&gt; and &lt;stdio.h&gt; in this code are headers from the C standard library (but there are also headers which are</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ci-cd?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>CI/CD</title>
        <link>https://yanevskiv.com/ci-cd?rev=1778758708&amp;do=diff</link>
        <description>CI/CD

CI/CD stands for “continuous integration / continuous delivery”. It is a term used for a set of pratcies you put in place in order to simultaneously accomplish the following two:

	* Quickly integrate changes you make to your software into production (</description>
    </item>
    <item rdf:about="https://yanevskiv.com/cnot-gate?rev=1779716974&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:49:34+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>CNOT gate</title>
        <link>https://yanevskiv.com/cnot-gate?rev=1779716974&amp;do=diff</link>
        <description>CNOT gate

CNOT gate (Controlled-NOT gate, also written CX) is a two-qubit quantum gate that flips the target qubit if and only if the control qubit is in state $\lvert 1\rangle$. It is one of the most fundamental and widely used gates in quantum computing.

$$\text{CNOT} = \begin{pmatrix}1 &amp; 0 &amp; 0 &amp; 0\\ 0 &amp; 1 &amp; 0 &amp; 0\\ 0 &amp; 0 &amp; 0 &amp; 1\\ 0 &amp; 0 &amp; 1 &amp; 0\end{pmatrix}$$

The rows and columns of this $4\times 4$$\lvert 00\rangle, \lvert 01\rangle, \lvert 10\rangle, \lvert 11\rangle$$$\text{CNOT}\lvert …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/complex.h?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title></title>
        <link>https://yanevskiv.com/complex.h?rev=1778758708&amp;do=diff</link>
        <description>&lt;complex.h&gt;

In C programming language, &lt;complex.h&gt; is a header which is part of the C standard library (specifically, C99). It implements the algebra of complex numbers $\mathbb C$.

You need at least version C99 to use this header, so compile with gcc -std=c99 main.c -o program$2 + i3$$i$$z = 2 + i3$$|z|$$e^z$$\log(z)$$\sin(z)$$\cos(z)$$\tan(z)$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/coreutils?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of coreutils commands</title>
        <link>https://yanevskiv.com/coreutils?rev=1778758708&amp;do=diff</link>
        <description>List of coreutils commands

coreutils (or GNU core utilities) are a set of commands inherited from Unix and implemented by the GNU project.

These commands are pretty much available on all GNU/Linux systems, no matter the distro.

The following is a table of coreutil commands. You can use</description>
    </item>
    <item rdf:about="https://yanevskiv.com/cp-1?rev=1779717371&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:56:11+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$\mathbb{CP}^1$</title>
        <link>https://yanevskiv.com/cp-1?rev=1779717371&amp;do=diff</link>
        <description>$\mathbb{CP}^1$

Complex projective line (or $\mathbb{CP}^1$) is the Hilbert space where pure qubits live in. It is defined as the quotient space of $\mathbb{C}^2$ and $\mathbb{C}$, both of which are punctured in their respective zero elements.

$$\mathbb{CP}^1 \stackrel{\text{def}}{=} (\mathbb{C}^2 \setminus\{0\})/\mathbb{C}^\times\qquad \mathbb{C}^\times\stackrel{\text{def}}{=}\mathbb{C} \setminus \{0\}$$

Motivation

To do quantum computing, we usually use the Hilbert space $\mathbb{C}^2$$\lv…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ctype.h?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title></title>
        <link>https://yanevskiv.com/ctype.h?rev=1778758708&amp;do=diff</link>
        <description>&lt;ctype.h&gt;

In C programming language, &lt;ctype.h&gt; is a header which is part of the C standard library. It gives you functions related to the character type char. Although it does sound like it&#039;s something about C types (like short, int, float, double) rather than strictly about</description>
    </item>
    <item rdf:about="https://yanevskiv.com/density-matrix?rev=1779717347&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:55:47+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Density matrix</title>
        <link>https://yanevskiv.com/density-matrix?rev=1779717347&amp;do=diff</link>
        <description>Density matrix

Density matrix (written as $\rho$) is a matrix representation of a quantum state that is strictly more general than the state vector $\lvert\psi\rangle$. While a state vector can only represent pure states, a density matrix can represent mixed states as well, making it the correct tool for open quantum systems, noisy circuits, and statistical ensembles of quantum states.$\lvert\psi\rangle$$$\rho = \lvert\psi\rangle\langle\psi\rvert$$$\lvert 0\rangle$$\lvert 1\rangle$$$\rho_0 = \l…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/deutsch-jozsa?rev=1779717036&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:50:36+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Deutsch-Jozsa algorithm</title>
        <link>https://yanevskiv.com/deutsch-jozsa?rev=1779717036&amp;do=diff</link>
        <description>Deutsch-Jozsa algorithm

Deutsch-Jozsa algorithm is a quantum algorithm that determines whether a function $f:\{0,1\}^n \to \{0,1\}$ is constant or balanced using exactly one quantum query. It was proposed by David Deutsch and Richard Jozsa in 1992 as a generalization of Deutsch&#039;s algorithm to $n$$f$$2^n$$2^{n-1} + 1$$n + 1$$n$$\lvert 0\rangle^{\otimes n}$$\lvert 1\rangle$$n+1$$n$$n$$$\lvert 0\rangle^{\otimes n}\lvert 1\rangle \xrightarrow{H^{\otimes n+1}} \frac{1}{\sqrt{2^n}}\sum_{x=0}^{2^n-1}\…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/deutsch?rev=1779717025&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:50:25+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Deutsch&#039;s algorithm</title>
        <link>https://yanevskiv.com/deutsch?rev=1779717025&amp;do=diff</link>
        <description>Deutsch&#039;s algorithm

Deutsch&#039;s algorithm is the simplest quantum algorithm that demonstrates a quantum speedup over any classical algorithm. It determines whether a binary function $f:\{0,1\} \to \{0,1\}$ is constant (same output for both inputs) or balanced (different outputs for the two inputs) using only a single quantum query, whereas any classical algorithm requires two.$f$$U_f$$\lvert x\rangle\lvert y\rangle \mapsto \lvert x\rangle\lvert y \oplus f(x)\rangle$$f$$f(0)$$f(1)$$U_f$$\lvert 0\r…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/dirac-notation?rev=1779717212&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:53:32+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Dirac notation</title>
        <link>https://yanevskiv.com/dirac-notation?rev=1779717212&amp;do=diff</link>
        <description>Dirac notation

Dirac notation (or bra-ket notation) is a convenient way to name vectors in a Hilbert space $\mathcal{H}$ (via “kets”) and its dual space $\mathcal{H}^*$ (via “bras”). Kets are written as $\lvert\text{name}\rangle$ and bras are written as $\langle\text{name}\rvert$. The text inside a bra or ket has no intrinsic meaning — it is simply a label, much like naming a variable in programming.$\lvert\psi\rangle$$\mathbb{C}^2$$a, b \in \mathbb{C}$$$\lvert\psi\rangle = \begin{pmatrix}a\\b\…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/do-while-0?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>do { ... } while (0)</title>
        <link>https://yanevskiv.com/do-while-0?rev=1778758708&amp;do=diff</link>
        <description>do { ... } while (0)

In C programming language,do { ... } while (0) is a loop which does a single iteration. A compiler will optimize it away completely, so the syntax produces no actual machine code.

Most commonly, it&#039;s used to make function-macros.

Example:


/*
 * - clearing psr.i is implicitly serialized (visible by next insn)
 * - setting psr.i requires data serialization
 * - we need a stop-bit before reading PSR because we sometimes
 *   write a floating-point register right before rea…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/docker?rev=1778943410&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-16T14:56:50+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>docker</title>
        <link>https://yanevskiv.com/docker?rev=1778943410&amp;do=diff</link>
        <description>docker

What is docker?

Docker is a tool for managing containers. Containers are somewhat like virtual machine instances except a lot more lightweight.

Think of an application e.g. a web app. You want to run the application, but you don&#039;t want to pollute your host OS with all the baggage that comes with it (libraries, dependencies, config files, services,</description>
    </item>
    <item rdf:about="https://yanevskiv.com/eigenstate?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Eigenstate</title>
        <link>https://yanevskiv.com/eigenstate?rev=1778758708&amp;do=diff</link>
        <description>Eigenstate

Eigenstate is refers to a quantum state associated with a quantum gate that remains unchanged after applying the gate.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/embedded-glossary?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Embedded engineering glossary</title>
        <link>https://yanevskiv.com/embedded-glossary?rev=1778758708&amp;do=diff</link>
        <description>Embedded engineering glossary

	* QNX (Quantum Network eXecutive) - A proprietary real-time operating system (RTOS)
	* Lock-free queue - An efficient MT-safe queue implemented only using atomic instructions with no spinlocks, semaphores or mutexes.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/eof?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>EOF</title>
        <link>https://yanevskiv.com/eof?rev=1778758708&amp;do=diff</link>
        <description>EOF

EOF is an acronym that stands for “End of file”

Shell

In shell, EOF is commonly used as a terminator in what is called a heredoc (“here document”).
It&#039;s when you want to supply a multiline text to a command to its standard output, using &lt;&lt;.



 $ cat &gt; hello.txt &lt;&lt; EOF
Here, you can write anything you like.
It&#039;s not over until you actually type E-O-F.
You can cancel with Ctrl + C.
EOF</description>
    </item>
    <item rdf:about="https://yanevskiv.com/eqn-electromagnetism?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>(WIP) Equations of Electromagnetism</title>
        <link>https://yanevskiv.com/eqn-electromagnetism?rev=1778758708&amp;do=diff</link>
        <description>(WIP) Equations of Electromagnetism

Electrostatics

Coulomb&#039;s law

Attractive force $Q_2$ feels thanks to $Q_1$&#039;s electric field:
$$\mathbf F_ = \frac{1}{4\pi\varepsilon_0}\frac{Q_1Q_2}{r^2}\mathbf r_{012}$$

Electric field

Electric field created by a single point charge $Q$:
$$\mathbf E = \frac{1}{4\pi\varepsilon_0}\frac{Q}{r^2}\mathbf r_0$$

Electric field created by multiple point charges $Q_1, Q_2, ..., Q_N$:
$$\mathbf E = \frac{1}{4\pi\varepsilon_0}\sum_{i=1}^{N}\frac{Q_i}{r^2_i}\mathbf r…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/errno.h?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title></title>
        <link>https://yanevskiv.com/errno.h?rev=1778758708&amp;do=diff</link>
        <description>&lt;errno.h&gt;

In C programming language, &lt;errno.h&gt; is a header that&#039;s part of the C standard library. 

It defines all the ENAME constants used to name errors and gives access to the global int errno;. 

Constants

Standard POSIX errors:



E2BIG            EACCES           EADDRINUSE       EADDRNOTAVAIL  
EAFNOSUPPORT     EAGAIN           EALREADY         EBADF          
EBADMSG          EBUSY            ECANCELED        ECHILD         
ECONNABORTED     ECONNREFUSED     ECONNRESET       EDEADLK   …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/exit-status?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Exit status</title>
        <link>https://yanevskiv.com/exit-status?rev=1778758708&amp;do=diff</link>
        <description>Exit status

Exit status lets the user of your program know if the program ended in success or failure.

Commonly, 0 is success, any other value is failure (most commonly, failure is 1 -- a bit counter intuitive at first!)

Your users can inspect it with</description>
    </item>
    <item rdf:about="https://yanevskiv.com/fdsa?rev=1778765059&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T13:24:19+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title></title>
        <link>https://yanevskiv.com/fdsa?rev=1778765059&amp;do=diff</link>
        <description>fdsafdsafdsafdas  fdsafdsafds</description>
    </item>
    <item rdf:about="https://yanevskiv.com/fft?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>FFT</title>
        <link>https://yanevskiv.com/fft?rev=1778758708&amp;do=diff</link>
        <description>FFT

FFT (or Fast Fourier Transform) is an algorithm that computes DFT (or “Discrete Fourier Transform”). There are several FFT algorithms but the most popular one is called Cooley–Tukey FFT.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/function-macro?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Function macro</title>
        <link>https://yanevskiv.com/function-macro?rev=1778758708&amp;do=diff</link>
        <description>Function macro

Function macro is a C preprocessor macro that looks like a function call when you use it.

This is a basic example with a single expression. sqr(x) looks and feels like a function even though it&#039;s a macro. A good habit to get into is to always enclose arguments into parenthesis when you define function macros. For example,</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ghz-state?rev=1779716905&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:48:25+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>GHZ state</title>
        <link>https://yanevskiv.com/ghz-state?rev=1779716905&amp;do=diff</link>
        <description>GHZ state

GHZ state (Greenberger-Horne-Zeilinger state) is a maximally entangled quantum state of three or more qubits. The three-qubit GHZ state is an equal superposition of all-zeros and all-ones.

$$\lvert\text{GHZ}\rangle = \frac{1}{\sqrt{2}}(\lvert 000\rangle + \lvert 111\rangle)$$

The GHZ state is named after Daniel Greenberger, Michael Horne, and Anton Zeilinger, who introduced it in 1989. It is a natural generalization of the two-qubit Bell state $\lvert\Phi^+\rangle$$0$$1$$n$$n \geq 2…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/gist-docker?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Docker (Reference)</title>
        <link>https://yanevskiv.com/gist-docker?rev=1778758708&amp;do=diff</link>
        <description>Docker (Reference)

This page includes a myriad docker commands for reference.

Basic

Containers

Run ubuntu:latest image (will do docker pull automatically if you don&#039;t have it)



docker run -it --rm ubuntu:latest


Images

Pull ubuntu:latest image</description>
    </item>
    <item rdf:about="https://yanevskiv.com/gist-git?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Git (Examples)</title>
        <link>https://yanevskiv.com/gist-git?rev=1778758708&amp;do=diff</link>
        <description>Git (Examples)

Basics

Creating a repository with an initial commit:



git init


Adding a file to the staging area:



git add file.txt


Un-adding a file from the staging area:



git restore --staged file.txt


Showing what&#039;s in the staging area:</description>
    </item>
    <item rdf:about="https://yanevskiv.com/gist-semaphores?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>(WIP) Semaphores (Examples)</title>
        <link>https://yanevskiv.com/gist-semaphores?rev=1778758708&amp;do=diff</link>
        <description>(WIP) Semaphores (Examples)

This page includes some examples of semaphores in multi-threading environments. The syntax is borrowed from EasyMT.

Basic

Synchronization

Two threads a() and b() alternate their execution regardless of the scheduler.

Output: $B$$B$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/git?rev=1778943393&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-16T14:56:33+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>git</title>
        <link>https://yanevskiv.com/git?rev=1778943393&amp;do=diff</link>
        <description>git

Git is a tool for managing repositories. Repositories are like folders, except it&#039;s easier to track the changes that happen inside them.

Think of a project you&#039;ve been working on e.g. a game in written in C++.

You&#039;ve been working on your game for weeks and now you have quite a bit of code. You&#039;re starting to be a little afraid of making changes</description>
    </item>
    <item rdf:about="https://yanevskiv.com/gitignore?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>.gitignore</title>
        <link>https://yanevskiv.com/gitignore?rev=1778758708&amp;do=diff</link>
        <description>.gitignore

.gitignore is a file 

You can ignore everything in a given di

F.A.Q.

How do I ignore a directory without making a commit?

Just put * in .gitignore of the directory you want to ignore (e.g. ./local directory) 



# ./local/.gitignore
# Ignore everything in directory `./local`

*</description>
    </item>
    <item rdf:about="https://yanevskiv.com/global-phase?rev=1779717241&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:54:01+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Global phase</title>
        <link>https://yanevskiv.com/global-phase?rev=1779717241&amp;do=diff</link>
        <description>Global phase

Global phase is a property of a quantum state that emerges from the mathematical description but is physically completely unobservable. Multiplying an entire quantum state by a complex number of unit magnitude $e^{i\phi}$ produces a state that is physically identical to the original in every possible measurement.$a = Ae^{i\alpha}$$b = Be^{i\beta}$$A, B \in \mathbb{R}$$\alpha, \beta \in (-\pi, \pi]$$$\lvert\psi\rangle = Ae^{i\alpha}\lvert 0\rangle + Be^{i\beta}\lvert 1\rangle$$$\lve…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/gnu-linux?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>GNU/Linux</title>
        <link>https://yanevskiv.com/gnu-linux?rev=1778758708&amp;do=diff</link>
        <description>GNU/Linux

GNU/Linux is a free operating system that replaced the older operating system called Unix. It&#039;s ubiquitous on servers and supercomputers. It&#039;s an increasingly popular choice for desktops, but not yet common. It&#039;s also the operating system behind SteamOS.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/grover?rev=1779717069&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:51:09+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Grover&#039;s algorithm</title>
        <link>https://yanevskiv.com/grover?rev=1779717069&amp;do=diff</link>
        <description>Grover&#039;s algorithm

Grover&#039;s algorithm is a quantum search algorithm that finds a marked element in an unstructured database of $N$ items in $O(\sqrt{N})$ queries. It was invented by Lov Grover in 1996 and provides a quadratic speedup over classical brute-force search, which requires $O(N)$$U_f$$\lvert x^*\rangle$$U_f\lvert x\rangle = -\lvert x\rangle$$x = x^*$$U_f\lvert x\rangle = \lvert x\rangle$$\lvert s\rangle = H^{\otimes n}\lvert 0\rangle^{\otimes n}$$\lvert x^*\rangle$$G$$U_f$$D = 2\lvert…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/h-gate?rev=1779716945&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:49:05+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Hadamard gate</title>
        <link>https://yanevskiv.com/h-gate?rev=1779716945&amp;do=diff</link>
        <description>Hadamard gate

Hadamard gate (or H gate) is one of the most important single-qubit quantum gates. It maps the computational basis states $\lvert 0\rangle$ and $\lvert 1\rangle$ to equal superpositions, and is used at the start of most quantum algorithms to create superposition from a classical input.$$H = \frac{1}{\sqrt{2}}\begin{pmatrix}1 &amp; 1\\ 1 &amp; -1\end{pmatrix}$$$\lvert +\rangle$$\lvert -\rangle$$$H\lvert 0\rangle = \frac{\lvert 0\rangle + \lvert 1\rangle}{\sqrt{2}} = \lvert +\rangle$$$$H\lv…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/harvard-architecture?rev=1778954182&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-16T17:56:22+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Harvard architecture</title>
        <link>https://yanevskiv.com/harvard-architecture?rev=1778954182&amp;do=diff</link>
        <description>Harvard architecture

Harvard archictecture is a type of computer archictecture. It&#039;s a type of architecture where code and data are kept in separate memories.

The Harvard architecture can be contrasted against von-Neumann archictecture. In the latter, code and data are both stored in the same working memory (RAM). The CPU has to fetch both the instructions and data by accessing the same memory bus, leading to what is known as von-Neumann bottleneck. This doesn&#039;t really matter, of course</description>
    </item>
    <item rdf:about="https://yanevskiv.com/header-guard?rev=1778763693&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T13:01:33+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Header guard</title>
        <link>https://yanevskiv.com/header-guard?rev=1778763693&amp;do=diff</link>
        <description>Header guard

Header guards are a pattern used in C and C++ programming languages when writing header files. Header files (.h files) are files that are included in source files (.c and .cpp files) near the top (hence the name) using the #include &lt;...&gt;_</description>
    </item>
    <item rdf:about="https://yanevskiv.com/hhl?rev=1779717107&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:51:47+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>HHL algorithm</title>
        <link>https://yanevskiv.com/hhl?rev=1779717107&amp;do=diff</link>
        <description>HHL algorithm

HHL algorithm (Harrow-Hassidim-Lloyd algorithm) is a quantum algorithm for solving systems of linear equations $Ax = b$ where $A$ is an $N\times N$ sparse Hermitian matrix. Proposed in 2009, it achieves an exponential speedup over classical linear solvers under certain conditions.$O(Ns\kappa\log(1/\varepsilon))$$s$$\kappa$$\varepsilon$$O(\log(N)s^2\kappa^2/\varepsilon)$$N$$\lvert b\rangle$$A$$\lambda_j$$A$$\lvert\lambda_j\rangle \mapsto (C/\lambda_j)\lvert\lambda_j\rangle$$A^{-1}$…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/hilbert-space?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Hilbert space</title>
        <link>https://yanevskiv.com/hilbert-space?rev=1778758708&amp;do=diff</link>
        <description>Hilbert space

Hilbert space is a complete inner product space. It is vector space that is equipped with an inner product such that the metric induced by the inner product is complete within the space. Completeness means that all Cauchy sequences converge within the same space. Hilbert space is a special case of the more general Banach space, both of which are concepts from functional analysis.$\mathbb{R}$$\mathbb{C}$$\lvert\psi\rangle$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/home?rev=1779714515&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:08:35+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Home</title>
        <link>https://yanevskiv.com/home?rev=1779714515&amp;do=diff</link>
        <description>Home

Hi, I&#039;m Ivan! This website is my encyclopedia about various technical topics. The topics I cover on this wiki are mostly related to technology, but sometimes I also write about mathematics and physics.

I&#039;m an embedded software engineer. Therefore, most of the articles on this website are going to be written from that lens. For example, if I make an analogy, it&#039;s probably going to be related to embedded engineering in some way. I use</description>
    </item>
    <item rdf:about="https://yanevskiv.com/hopf-fibration?rev=1779717387&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:56:27+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Hopf fibration</title>
        <link>https://yanevskiv.com/hopf-fibration?rev=1779717387&amp;do=diff</link>
        <description>Hopf fibration

Hopf fibration is a map connecting the state vector representation of a qubit $\lvert\psi\rangle \in \mathbb{C}^2$ to a point on the Bloch sphere $(x, y, z) \in \mathbb{R}^3$. It explains why a qubit — an object living in the complex space $\mathbb{C}^2$ — can be visualized as a point on a real three-dimensional sphere.$a, b \in \mathbb{C}$$|a|^2 + |b|^2 = 1$$\mathbb{C}^2$$S^3$$S^3/U(1) \cong S^2$$\pi: S^3 \to S^2$$S^2$$S^3$$U(1)$$\pi$$\sigma_x, \sigma_y, \sigma_z$$$\pi:\mathbb{C…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/hpc?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>HPC</title>
        <link>https://yanevskiv.com/hpc?rev=1778758708&amp;do=diff</link>
        <description>HPC

HPC (High-performance computing) is an area of programming concerned with performance optimization. It&#039;s about making the most out of hardware.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/hsp?rev=1779717094&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:51:34+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Hidden subgroup problem</title>
        <link>https://yanevskiv.com/hsp?rev=1779717094&amp;do=diff</link>
        <description>Hidden subgroup problem

Hidden subgroup problem (HSP) is a class of problems that provides a unified framework for many quantum algorithms. The problem is: given a group $G$, a set $X$, and a function $f: G \to X$ that is constant on cosets of some subgroup $H \leq G$ and takes distinct values on different cosets, find the hidden subgroup $H$$\mathbb{Z}_2$$\mathbb{Z}_2^n$$\mathbb{Z}$$\mathbb{Z}_N$$G$$G$$\frac{1}{\sqrt{|H|}}\sum_{h\in H}\lvert x_0 h\rangle$$x_0$$G$$G$$H$$O(\log|G|)$$H$$G$$S_n$$D…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/i-gate?rev=1779704114&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T10:15:14+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>I gate</title>
        <link>https://yanevskiv.com/i-gate?rev=1779704114&amp;do=diff</link>
        <description>I gate

I gate (or Identity gate) is a quantum gate that leaves the state vector unchanged. In other words, it does nothing. It&#039;s commonly drawn as a wire. Its matrix representation is equivalent to the identity matrix. For a single qubit, the Identity gate is represented by a $$I = \begin{pmatrix}1 &amp; 0\\ 0 &amp; 1\end{pmatrix}$$$I$$\lvert\psi\rangle$$I\lvert\psi\rangle$$\lvert\psi\rangle = a\lvert 0\rangle + b\lvert 1\rangle$$$I\lvert\psi\rangle = \begin{pmatrix}1 &amp; 0\\ 0 &amp; 1\end{pmatrix}\begin{pma…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/i-state?rev=1779716853&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:47:33+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$\lvert i\rangle$</title>
        <link>https://yanevskiv.com/i-state?rev=1779716853&amp;do=diff</link>
        <description>$\lvert i\rangle$

Plus-i state $\lvert i\rangle$ (also written $\lvert +i\rangle$ or $\lvert y\rangle$) is a quantum state that is an equal superposition of $\lvert 0\rangle$ and $\lvert 1\rangle$ with a relative phase of $+i$. It is one of the six cardinal states on the Bloch sphere, sitting at the positive $y$-axis with coordinates $(0, 1, 0)$.

$$\lvert i\rangle = \frac{1}{\sqrt{2}}\lvert 0\rangle + \frac{i}{\sqrt{2}}\lvert 1\rangle = \frac{1}{\sqrt{2}}\begin{pmatrix}1\\i\end{pmatrix}$$

It …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ifupdown?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>ifupdown</title>
        <link>https://yanevskiv.com/ifupdown?rev=1778758708&amp;do=diff</link>
        <description>ifupdown

ifupdown is the traditional network manager on GNU/Linux systems. It has since been replaced by systemd-networkd. 

It was especially commmon in Debian systems before Debian 12 (Bookworm).

The “if” part is short for “interface”. “up” and “down” refer to</description>
    </item>
    <item rdf:about="https://yanevskiv.com/introduction-to-quantum-computing?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Introduction to quantum computing</title>
        <link>https://yanevskiv.com/introduction-to-quantum-computing?rev=1778758708&amp;do=diff</link>
        <description>Introduction to quantum computing

Quantum computing is a theory of programming a quantum computer.

If you&#039;re reading this article, you&#039;re likely curious about quantum computing and would like to learn more. How does a quantum computer work? What makes it different from a classical computer? How exactly do you program it? If you don&#039;t have a background in physics quantum computing may initially seem math-heavy and rather difficult to understand. An assumption I&#039;m going to make is that the reade…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/iswap-gate?rev=1779717001&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:50:01+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>iSWAP gate</title>
        <link>https://yanevskiv.com/iswap-gate?rev=1779717001&amp;do=diff</link>
        <description>iSWAP gate

iSWAP gate is a two-qubit quantum gate that swaps the states of two qubits and simultaneously multiplies the swapped states by the imaginary unit $i$.

$$\text{iSWAP} = \begin{pmatrix}1 &amp; 0 &amp; 0 &amp; 0\\ 0 &amp; 0 &amp; i &amp; 0\\ 0 &amp; i &amp; 0 &amp; 0\\ 0 &amp; 0 &amp; 0 &amp; 1\end{pmatrix}$$

The gate maps $\lvert 01\rangle \mapsto i\lvert 10\rangle$ and $\lvert 10\rangle \mapsto i\lvert 01\rangle$, while leaving $\lvert 00\rangle$ and $\lvert 11\rangle$ unchanged. The extra factor of $i$ distinguishes it from the …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/kdp20260110-1?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>KDP Midterm (2026-01-10) Question 1</title>
        <link>https://yanevskiv.com/kdp20260110-1?rev=1778758708&amp;do=diff</link>
        <description>KDP Midterm (2026-01-10) Question 1

Write and explain the Fine grain ticket algorithm implemented with $\text{FA}$ opeartion. If we replaced $\text{FA}$ with $\text{TS}$ (test-and-set) operation implemented in the following way, would it be possible to implement a fine-grained solution? If yes, implement it. Is the critical section entry fair? Why / why not?$\text{FA}$$\text{TS}$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/kdp20260110-2?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>KDP Midterm (2026-01-10) Question 2</title>
        <link>https://yanevskiv.com/kdp20260110-2?rev=1778758708&amp;do=diff</link>
        <description>KDP Midterm (2026-01-10) Question 2

Consider a dining table that can seat at most $N$ people ($N &gt; 2$). A person may take some food, sit at the table (sitAtTable()), eat, leave the table (leaveTable()) and walk away. No person should eat alone i.e. sit at the table alone. Also, every person that takes food must necessarily sit down in order to eat. Create a solution for this probalom using a</description>
    </item>
    <item rdf:about="https://yanevskiv.com/kdp20260218-1?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>KDP Exam (2026-02-18) Question 1</title>
        <link>https://yanevskiv.com/kdp20260218-1?rev=1778758708&amp;do=diff</link>
        <description>KDP Exam (2026-02-18) Question 1

Solve the dining philsophers problem by using signal and continue monitor discipline and by using covering condition technique. Ensure philosphers start eating in the order of their arrival.

Solution


#define N 5 /* number of philosophers */

monitor DiningPhilosophers {
    enum { THINKING, HUNGRY, EATING };
    int phil[N];
    cond delay[N];
    queue&lt;int&gt; q; 
    
    bool canEat(int id) {
        return (phil[(id - 1 + N) % N] != EATING) &amp;&amp; (phil[(id + 1)…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/kdp20260218-2?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>KDP Exam (2026-02-18) Question 2</title>
        <link>https://yanevskiv.com/kdp20260218-2?rev=1778758708&amp;do=diff</link>
        <description>KDP Exam (2026-02-18) Question 2

The Roller Coaster Problem. Assume there are $N$ passengers and $M$ cars in one roller coaster. Passengers alternate between walking around the amusement park and riding the roller coaster. One car can take at most $K$ passengers where $K &lt; N$$K$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/kdp20260218-3?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>(WIP) KDP Exam (2026-02-18) Question 3</title>
        <link>https://yanevskiv.com/kdp20260218-3?rev=1778758708&amp;do=diff</link>
        <description>(WIP) KDP Exam (2026-02-18) Question 3

Using synchronous message passing (synch_send, receive) write a distributed solution for The Dining Philosophers problem. In the distributed solution philosopher processes may only communicate with corresponding fork processes and fork processes may only communicate with corresponding philosopher processes.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/kpsewhich?rev=1779031999&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-17T15:33:19+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>kpsewhich</title>
        <link>https://yanevskiv.com/kpsewhich?rev=1779031999&amp;do=diff</link>
        <description>kpsewhich

kpsewhich is a LaTeX-related command. It&#039;s a diagnostic command that&#039;s used to look up the full path of a file you know the LaTeX compiler would use implicitly. In some way, it is similar to the which command, which shows the full path of a command if you would run it in the shell (e.g.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/kraus-operator?rev=1779717358&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:55:58+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Kraus operator</title>
        <link>https://yanevskiv.com/kraus-operator?rev=1779717358&amp;do=diff</link>
        <description>Kraus operator

Kraus operators $\{K_k\}$ are a set of matrices used to represent a quantum channel — a completely positive trace-preserving (CPTP) map $\mathcal{E}$ that sends density matrices to density matrices. Any physically valid quantum channel can be expressed in Kraus form.$$\mathcal{E}(\rho) = \sum_k K_k\rho K_k^\dagger$$$\sum_k K_k^\dagger K_k = I$$\text{tr}(\mathcal{E}(\rho)) = \text{tr}(\rho) = 1$$p$$K_0 = \sqrt{1-p}\,I$$K_1 = \sqrt{p}\,X$$p$$K_0 = \sqrt{1-p}\,I$$K_1 = \sqrt{p/3}\,X…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/landauers-principle?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Landauer&#039;s principle</title>
        <link>https://yanevskiv.com/landauers-principle?rev=1778758708&amp;do=diff</link>
        <description>Landauer&#039;s principle

Landauer&#039;s principle establishes the thermodynamic lower bound on energy required to erase information from a physical system (e.g. a computer register).

At temperature $T$, the minimum energy needed to erase information is:

$$E = (\text{bits erased}) \times k_B T \ln 2$$

Where $k_B$ is the Boltzman&#039;s constant.$S_0 = 64\times k_B\ln 2$$S_1 = 0$$\Delta S = S_0 - S_1$$Q = T \Delta S$$T = 300K$$$ E_\text{bit} \approx 2.9\times 10^{-21} J$$$$ E_\text{bit} \approx 0.018 \text…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/latex-syntax?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>LaTeX syntax</title>
        <link>https://yanevskiv.com/latex-syntax?rev=1778758708&amp;do=diff</link>
        <description>LaTeX syntax

For addition, you use the + symbol e.g. a + b = c:
$$ a + b = c$$

For subtraction, you use the - symbol e.g. a - b = c
$$ a - b = c$$

For multiplication, you just write ab or put a dot in between with \cdot (meaning: “centered dot”) like a \cdot b.
Using a * b$a * b$$$a\cdot b = c$$$a / b$$${a \over b} = c$$$$ a = b \pmod{N}$$$$e^{i\phi} = \cos(\phi) + i\sin(\phi)$$$$\ln(1 + x) = 1 + x + $$$$\int \iint \iiint \oint \oiint \oiiint$$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/latex?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>LaTeX</title>
        <link>https://yanevskiv.com/latex?rev=1778758708&amp;do=diff</link>
        <description>LaTeX

Latex (stylized as $\LaTeX$) is a markup language used to create scientific papers. It&#039;s the language used to produce PDF documents, like the ones you&#039;ll commonly see on arXiv.

Latex has a simple declarative syntax that looks like \command[opt1][opt2]...[optN]{arg1}{arg2}...{argN}</description>
    </item>
    <item rdf:about="https://yanevskiv.com/lindbald-equation?rev=1779717159&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:52:39+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lindblad master equation</title>
        <link>https://yanevskiv.com/lindbald-equation?rev=1779717159&amp;do=diff</link>
        <description>Lindblad master equation

Lindblad master equation (also called the GKSL equation, after Gorini, Kossakowski, Sudarshan, and Lindblad) is the most general Markovian master equation for the time evolution of the density matrix $\rho$ of an open quantum system — one that interacts with its environment.$$\frac{d\rho}{dt} = -\frac{i}{\hbar}[H, \rho] + \sum_k\left(L_k\rho L_k^\dagger - \frac{1}{2}L_k^\dagger L_k\rho - \frac{1}{2}\rho L_k^\dagger L_k\right)$$$-i[H,\rho]/\hbar$$L_k$$L_k$$\lvert 1\rangl…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/lindbald-master-equation?rev=1779493225&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T23:40:25+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lindbald master equation</title>
        <link>https://yanevskiv.com/lindbald-master-equation?rev=1779493225&amp;do=diff</link>
        <description>Lindbald master equation

Lindbald master equation is the equation that generalizes the Schrodinger equation.

The following is the equation written in terms of density matrix $\rho$.

$$\frac{d\rho}{dt} = -\frac{i}{\hbar}[H, \rho] + \sum_k\left(L_k^\dagger L_k - \frac{1}{2}\{L_k^\dagger L_k, \rho\}\right)$$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-algorithms?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of algorithms</title>
        <link>https://yanevskiv.com/list-of-algorithms?rev=1778758708&amp;do=diff</link>
        <description>List of algorithms

	* selection-sort
	* bubble-sort
	* insert-sort
	* merge-sort
	* quick-sort
	* 3d-rotation</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-c-concepts?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of C concepts</title>
        <link>https://yanevskiv.com/list-of-c-concepts?rev=1778758708&amp;do=diff</link>
        <description>List of C concepts

	* C standard library
	* #pragma once
	* do { ... } while (0)
	* Function macro
	* main() return
	* Exit status
	* Header guard
	* Embedded engineering glossary</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-c-headers?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of C headers</title>
        <link>https://yanevskiv.com/list-of-c-headers?rev=1778758708&amp;do=diff</link>
        <description>List of C headers

	* &lt;assert.h&gt;
	* &lt;complex.h&gt;
	* &lt;ctype.h&gt;
	* &lt;errno.h&gt;
	* fenv.h
	* float.h
	* inttypes.h
	* iso646.h
	* limits.h
	* locale.h
	* math.h
	* setjmp.h
	* signal.h
	* stdalign.h
	* stdarg.h
	* stdatomic.h
	* stdbit.h
	* &lt;stdbool.h&gt;
	* stdckdint.h
	* stddef.h
	* stdint.h
	* stdio.h
	* stdlib.h
	* stdmchar.h
	* stdnoreturn.h
	* &lt;string.h&gt;
	* tgmath.h
	* thread.h
	* time.h
	* uchar.h
	* wchar.h
	* wctype.h
	* curses.h
	* getopt.h</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-commands?rev=1779108450&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-18T12:47:30+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of commands</title>
        <link>https://yanevskiv.com/list-of-commands?rev=1779108450&amp;do=diff</link>
        <description>List of commands

	* List of util-linux commands
	* List of LaTeX commands
	* List of system commands
	* list-of-coreutils-commands
	* list-of-bash-internal-commands
	* List of HPC commands</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-concepts-in-quantum-control?rev=1779494717&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-23T00:05:17+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of concepts in quantum control</title>
        <link>https://yanevskiv.com/list-of-concepts-in-quantum-control?rev=1779494717&amp;do=diff</link>
        <description>List of concepts in quantum control

	* List of optimal quantum control algorithms
	* list-of-hamiltonians
	* pulse-shaping
	* drag-pulse
	* rabi-cycle
	* spin-echo
	* optimal-pulse-control
	* rotating-wave-approximation</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-concepts-in-quantum-error-correction?rev=1779494403&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-23T00:00:03+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of concepts in quantum error correction</title>
        <link>https://yanevskiv.com/list-of-concepts-in-quantum-error-correction?rev=1779494403&amp;do=diff</link>
        <description>List of concepts in quantum error correction

	* List of quantum error correction codes
	* list-of-lindbald-operators
	* list-of-kraus-operators
	* Density matrix
	* Lindbald master equation
	* Kraus operator
	* lindbald-operator
	* list-of-lindbald-operators
	* quantum-channel
	* cptp-map
	* superoperator
	* fault-tolerance</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-concepts?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of concepts</title>
        <link>https://yanevskiv.com/list-of-concepts?rev=1778758708&amp;do=diff</link>
        <description>List of concepts

	* C
		* header-guards
		* #pragma once

	* C++
		* Name mangling
		* Rule of 5

	* Miscellaneous
			* Numbers every programmer should know</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-cpp-concepts?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of C++ concepts</title>
        <link>https://yanevskiv.com/list-of-cpp-concepts?rev=1778758708&amp;do=diff</link>
        <description>List of C++ concepts

	* Name mangling
	* Rule of 5
	* CRTP
	* constexpr</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-cpp-headers?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of C++ headers</title>
        <link>https://yanevskiv.com/list-of-cpp-headers?rev=1778758708&amp;do=diff</link>
        <description>List of C++ headers

	* opencv.hpp
	* imgui.h
	* catch2.hpp
	* doctest.hpp</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-data-structures?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of data structures</title>
        <link>https://yanevskiv.com/list-of-data-structures?rev=1778758708&amp;do=diff</link>
        <description>List of data structures

	* array
	* forward-list
	* linked-list
	* dynamic-array
	* stack
	* queue
	* circular-buffer
	* matrix
	* binary-tree
	* heap
	* red-black-tree
	* b-tree
	* b-plus-tree
	* hash-map
	* graph</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-embedded-engineering-concepts?rev=1778954210&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-16T17:56:50+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of embedded engineering concepts</title>
        <link>https://yanevskiv.com/list-of-embedded-engineering-concepts?rev=1778954210&amp;do=diff</link>
        <description>List of embedded engineering concepts

	* List of logic gates
	* rtos
	* xv6
	* riscv
	* x86-64
	* mcu
	* spi
	* uart
	* i2c
	* gpio
	* wcet
	* Harvard architecture</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-essential-quantum-computing-concepts?rev=1779494908&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-23T00:08:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of essential quantum computing concepts</title>
        <link>https://yanevskiv.com/list-of-essential-quantum-computing-concepts?rev=1779494908&amp;do=diff</link>
        <description>List of essential quantum computing concepts

	* List of quantum gates
	* List of quantum states
	* List of quantum algorithms
	* Qubit
	* Two qubits
	* Quantum register
	* Quantum gate
	* Born rule
	* quantum-state
	* State vector
	* Pauli gate
	* Global phase
	* Basis state
	* Eigenstate
	* relative-phase
	* clifford-gate
	* Hopf fibration
	* $\mathbb{CP}^1$
	* unitary-gate
	* quantum-measurement
	* Bloch sphere
	* Dirac notation
	* dagger-operation
	* matrix-transpose
	* complex-conjugate
	* …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-hardware?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of hardware</title>
        <link>https://yanevskiv.com/list-of-hardware?rev=1778758708&amp;do=diff</link>
        <description>List of hardware

	* ThinkPad
	* Arduino Uno R4 WiFi
	* weller-we-1010</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-headers-cpp?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of headers in C++</title>
        <link>https://yanevskiv.com/list-of-headers-cpp?rev=1778758708&amp;do=diff</link>
        <description>List of headers in C++

&lt;https://en.cppreference.com/w/cpp/headers.html&gt;</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-hpc-commands?rev=1779108473&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-18T12:47:53+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of HPC commands</title>
        <link>https://yanevskiv.com/list-of-hpc-commands?rev=1779108473&amp;do=diff</link>
        <description>List of HPC commands

	* nvcc
	* cuobjdump</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-kdp-exercises?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of KDP exercises</title>
        <link>https://yanevskiv.com/list-of-kdp-exercises?rev=1778758708&amp;do=diff</link>
        <description>List of KDP exercises

	* KDP Midterm (2026-01-10) Question 1
	* KDP Midterm (2026-01-10) Question 2
	* KDP Exam (2026-02-18) Question 1
	* KDP Exam (2026-02-18) Question 2
	* (WIP) KDP Exam (2026-02-18) Question 3
	* kdp20260218-4</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-latex-commands?rev=1779030995&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-17T15:16:35+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of LaTeX commands</title>
        <link>https://yanevskiv.com/list-of-latex-commands?rev=1779030995&amp;do=diff</link>
        <description>List of LaTeX commands

	* pdflatex
	* kpsewhich</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-logic-gates?rev=1778943536&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-16T14:58:56+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of logic gates</title>
        <link>https://yanevskiv.com/list-of-logic-gates?rev=1778943536&amp;do=diff</link>
        <description>List of logic gates

	* and-gate
	* or-gate
	* not-gate
	* nand-gate
	* nor-gate</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-miscellaneous-quantum-computing-concepts?rev=1779495097&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-23T00:11:37+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of miscellaneous quantum computing concepts</title>
        <link>https://yanevskiv.com/list-of-miscellaneous-quantum-computing-concepts?rev=1779495097&amp;do=diff</link>
        <description>List of miscellaneous quantum computing concepts

	* schrodinger-picture
	* heisenberg-picture
	* interaction-picture
	* measurement-problem
	* intepretation-of-quantum-mechanics
	* copenhagen-interpretation
	* many-world-interpretation</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-miscellaneous-topics?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of miscellaneous topics</title>
        <link>https://yanevskiv.com/list-of-miscellaneous-topics?rev=1778758708&amp;do=diff</link>
        <description>List of miscellaneous topics

	* bytebeat
	* code-golf
	* List of KDP exercises</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-optimal-quantum-control-algorithms?rev=1779491124&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T23:05:24+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of optimal quantum control algorithms</title>
        <link>https://yanevskiv.com/list-of-optimal-quantum-control-algorithms?rev=1779491124&amp;do=diff</link>
        <description>List of optimal quantum control algorithms

	* grape
	* crab
	* goat</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-parallel-computing-concepts?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of parallel computing concepts</title>
        <link>https://yanevskiv.com/list-of-parallel-computing-concepts?rev=1778758708&amp;do=diff</link>
        <description>List of parallel computing concepts

	* introduction-to-parallel-computing
	* synchronization-primitve
	* SAXPY
	* Semaphore
	* mutex
	* Numbers every programmer should know
	* amdahls-law
	* gustafsons-law
	* cache-coherence
	* cuda
	* openmp
	* queuing-theory
	* lock-free-queue
	* numa
	* false-sharing
	* aba-problem
	* trace-monoid
	* hazard-pointer
	* cache-coherence
	* roofline-model
	* numa
	* embarrassingly-parallel
	* fork-join-model
	* rcu
	* lock
	* lock-convoy
	* lock-contention
	* sp…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-paths?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of paths</title>
        <link>https://yanevskiv.com/list-of-paths?rev=1778758708&amp;do=diff</link>
        <description>List of paths

	* /bin
	* /dev
	* /boot
	* /etc
	* /home
	* /lib
	* /mnt
	* /opt
	* /proc
	* /root
	* /sbin
	* /srv
	* /tmp
	* /usr
	* /var</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-quantum-algorithms?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of quantum algorithms</title>
        <link>https://yanevskiv.com/list-of-quantum-algorithms?rev=1778758708&amp;do=diff</link>
        <description>List of quantum algorithms

	* Quantum Fourier transform
	* Quantum phase estimation
	* Shor&#039;s algorithm
	* Grover&#039;s algorithm
	* Deutsch-Jozsa algorithm
	* QAOA
	* VQE</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-quantum-computing-concepts?rev=1779717440&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:57:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of quantum computing concepts</title>
        <link>https://yanevskiv.com/list-of-quantum-computing-concepts?rev=1779717440&amp;do=diff</link>
        <description>List of quantum computing concepts

	* Qubit
	* Born rule
	* Dirac notation
	* Global phase
	* $\mathbb{CP}^1$
	* Hopf fibration
	* Bloch sphere
	* Pure state
	* Mixed state
	* $\lvert 0\rangle$
	* $\lvert 1\rangle$
	* $\lvert +\rangle$
	* $\lvert -\rangle$
	* $\lvert i\rangle$
	* $\lvert -i\rangle$
	* Two qubits
	* Bell state
	* Three qubits
	* W state
	* GHZ state
	* NOON state
	* Quantum register
	* Quantum gate
	* Multiqubit gates
	* I gate
	* X-gate
	* Y gate
	* Z gate
	* Rotation gates
	* …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-quantum-computing-libraries?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of quantum computing libraries</title>
        <link>https://yanevskiv.com/list-of-quantum-computing-libraries?rev=1778758708&amp;do=diff</link>
        <description>List of quantum computing libraries

	* qiskit
	* q-sharp</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-quantum-error-correction-codes?rev=1779493887&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T23:51:27+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of quantum error correction codes</title>
        <link>https://yanevskiv.com/list-of-quantum-error-correction-codes?rev=1779493887&amp;do=diff</link>
        <description>List of quantum error correction codes

	* repetition-code
	* shor-code
	* surface-code</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-quantum-gates?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of quantum gates</title>
        <link>https://yanevskiv.com/list-of-quantum-gates?rev=1778758708&amp;do=diff</link>
        <description>List of quantum gates

	* I gate
	* X-gate
	* Y gate
	* Z gate
	* Rotation gates
	* s-gate
	* t-gate
	* Hadamard gate
	* Phase gate
	* U gate
	* ccnot-gate
	* CNOT gate
	* SWAP gate
	* iSWAP gate</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-quantum-states?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of quantum states</title>
        <link>https://yanevskiv.com/list-of-quantum-states?rev=1778758708&amp;do=diff</link>
        <description>List of quantum states

	* $\lvert 0\rangle$
	* $\lvert 1\rangle$
	* $\lvert +\rangle$
	* $\lvert -\rangle$
	* plus-i-state
	* $\lvert -i\rangle$
	* Bell state
	* W state
	* GHZ state</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-software-engineering-concepts?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of software engineering concepts</title>
        <link>https://yanevskiv.com/list-of-software-engineering-concepts?rev=1778758708&amp;do=diff</link>
        <description>List of software engineering concepts

	* brooks-law
	* parkinsons-law
	* kanban
	* xp-programming
	* agile
	* Test-driven development
	* CI/CD
	* devops
	* blue-green-deployment
	* canary-release
	* unit-test
	* regression
	* test-automation
	* kanban
	* feature-flag
	* production
	* ab-testing
	* hotfix
	* feature-branch
	* eat-your-own-dog-food
	* spike-solution
	* solid
	* liskov-substitution-principle
	* smart-and-vapid
	* devops
	* incremental-build-model
	* prototype
	* artifact
	* goodha…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-software-engineering-tools?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of software engineering tools</title>
        <link>https://yanevskiv.com/list-of-software-engineering-tools?rev=1778758708&amp;do=diff</link>
        <description>List of software engineering tools

	* jira
	* confluence
	* ms-teams
	* harvestapp
	* notion</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-syntaxes?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of syntaxes</title>
        <link>https://yanevskiv.com/list-of-syntaxes?rev=1778758708&amp;do=diff</link>
        <description>List of syntaxes

	* c-syntax
	* cpp-syntax
	* LaTeX syntax</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-system-commands?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of system commands</title>
        <link>https://yanevskiv.com/list-of-system-commands?rev=1778758708&amp;do=diff</link>
        <description>List of system commands

	* ifupdown</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-tools?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of tools</title>
        <link>https://yanevskiv.com/list-of-tools?rev=1778758708&amp;do=diff</link>
        <description>List of tools

	* git
	* docker
	* Terminal
	* Shell
	* LaTeX
	* tmux
	* ssh
	* VPS
	* qemu
	* gcc
	* gdb
	* nvim
	* perf</description>
    </item>
    <item rdf:about="https://yanevskiv.com/list-of-util-linux-commands?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>List of util-linux commands</title>
        <link>https://yanevskiv.com/list-of-util-linux-commands?rev=1778758708&amp;do=diff</link>
        <description>List of util-linux commands

util-linux is a collection of commands provided by the Linux Kernel Organization.

A similar set of commands is GNU core utilities. 

The following are commands provided by until-linux.
You can do man &lt;command&gt; or use the --help option to see what each command does.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/main-return?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>main() return</title>
        <link>https://yanevskiv.com/main-return?rev=1778758708&amp;do=diff</link>
        <description>main() return

The return value of int main(); function is called the program&#039;s exit status.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/math-books?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Math books</title>
        <link>https://yanevskiv.com/math-books?rev=1778758708&amp;do=diff</link>
        <description>Math books

	* &lt;https://zb260.user.srcf.net/notes/III/modrep.pdf&gt;</description>
    </item>
    <item rdf:about="https://yanevskiv.com/mathematical-maturity?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Mathematical Maturity</title>
        <link>https://yanevskiv.com/mathematical-maturity?rev=1778758708&amp;do=diff</link>
        <description>Mathematical Maturity

Trivial example

One of the earliest awakenings of my mathematical maturity was when I was a kid, thinking one of the simplest equations there is:

$$ a\cdot x = b$$

I knew how to solve this 99% of the time:

$$x = b / a$$

Is this correct? Let&#039;s take the equation $2\cdot x = 6$$b = 0$$x = 0$$a = 0$$a = 0$$b = 3$$x$$0 = 3$$a = 0$$b = 0$$x$$0 = 0$$a\cdot x = b$$a\cdot x = b$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/matmul?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Matmul</title>
        <link>https://yanevskiv.com/matmul?rev=1778758708&amp;do=diff</link>
        <description>Matmul

Matmul is an algorithm in high-performance computing (HPC). It is a BLAS level 2 (“Basic Linear Algebra Subprograms”) algorithm.

Definition

Matrices

Let $\mathbf A\in\mathbb{R}^{A_\text{rows}\times A_\text{cols}}$ and $\mathbf B\in \mathbb R^{B_\text{rows}\times B_\text{cols}}$ be square matrices over real numbers and let $A_\text{rows} = B_\text{cols}$.

Matmul defined as a matrix multiplication $\mathbf A\cdot \mathbf B$$\mathbf C\in\mathbb{R}^{A_\text{rows}\times B_\text{cols}}$$$ …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/minus-i-state?rev=1779716857&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:47:37+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$\lvert -i\rangle$</title>
        <link>https://yanevskiv.com/minus-i-state?rev=1779716857&amp;do=diff</link>
        <description>$\lvert -i\rangle$

Minus-i state $\lvert -i\rangle$ (also written $\lvert -y\rangle$) is a quantum state that is an equal superposition of $\lvert 0\rangle$ and $\lvert 1\rangle$ with a relative phase of $-i$. It is one of the six cardinal states on the Bloch sphere, sitting at the negative $y$-axis with coordinates $(0, -1, 0)$.

$$\lvert -i\rangle = \frac{1}{\sqrt{2}}\lvert 0\rangle - \frac{i}{\sqrt{2}}\lvert 1\rangle = \frac{1}{\sqrt{2}}\begin{pmatrix}1\\-i\end{pmatrix}$$

It is an eigenstat…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/minus-state?rev=1779716847&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:47:27+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$\lvert -\rangle$</title>
        <link>https://yanevskiv.com/minus-state?rev=1779716847&amp;do=diff</link>
        <description>$\lvert -\rangle$

Minus state $\lvert -\rangle$ is a quantum state that is an equal superposition of the two computational basis states $\lvert 0\rangle$ and $\lvert 1\rangle$ with opposite signs. It is one of the six cardinal states on the Bloch sphere, sitting at the negative $x$-axis.

$$\lvert -\rangle = \frac{1}{\sqrt{2}}\lvert 0\rangle - \frac{1}{\sqrt{2}}\lvert 1\rangle = \frac{1}{\sqrt{2}}\begin{pmatrix}1\\-1\end{pmatrix}$$

When measured in the computational basis $\{\lvert 0\rangle, \…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/mixed-state?rev=1779716831&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:47:11+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Mixed state</title>
        <link>https://yanevskiv.com/mixed-state?rev=1779716831&amp;do=diff</link>
        <description>Mixed state

Mixed state is a quantum state that cannot be described by a single state vector $\lvert\psi\rangle$. It arises when a quantum system is entangled with its environment or when there is classical uncertainty about how the system was prepared. Mixed states are represented by density matrices $\rho$$\rho = \lvert\psi\rangle\langle\psi\rvert$$\text{tr}(\rho^2) = 1$$\lvert 0\rangle$$p$$\lvert 1\rangle$$1-p$$$\rho = p\lvert 0\rangle\langle 0\rvert + (1-p)\lvert 1\rangle\langle 1\rvert = \…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/multiqubit-gates?rev=1779716937&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:48:57+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Multiqubit gates</title>
        <link>https://yanevskiv.com/multiqubit-gates?rev=1779716937&amp;do=diff</link>
        <description>Multiqubit gates

Multiqubit gates are quantum gates that act on two or more qubits simultaneously. Unlike single-qubit gates, multiqubit gates can create entanglement between qubits, which is an essential resource for quantum computation.

A single-qubit gate is a $2\times 2$$4\times 4$$8\times 8$$n$$2^n \times 2^n$$U$$U$$\lvert 1\rangle$$X$$X$$n$$\{H, T, \text{CNOT}\}$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/my-bookmarks?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>My bookmarks</title>
        <link>https://yanevskiv.com/my-bookmarks?rev=1778758708&amp;do=diff</link>
        <description>My bookmarks

C++

	* &lt;https://en.cppreference.com/w/&gt;
	* &lt;https://json.nlohmann.me/api/basic_json/&gt;

LaTeX

Online tools:

	* &lt;https://openai.com/index/introducing-prism/&gt;
	* &lt;https://www.mathcha.io/&gt;
	* &lt;https://www.overleaf.com/&gt;

Documentation PDFs:

	* &lt;https://pgfplots.sourceforge.net/pgfplots.pdf&gt;
	* &lt;https://www.bu.edu/math/files/2013/08/tikzpgfmanual.pdf&gt;
	* &lt;https://feog.github.io/chap1dm.pdf&gt;

Wikipedia

Related to mathematics:

	* &lt;https://en.wikipedia.org/wiki/Siamese_neural_network…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/name-mangling?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Name mangling</title>
        <link>https://yanevskiv.com/name-mangling?rev=1778758708&amp;do=diff</link>
        <description>Name mangling

Name mangling is how C++ compilers encode object types then and reconstruct the type back.

Let&#039;s say we got a following piece of C++ code.


namespace Hello {
    struct World {
      template &lt;typename T&gt; T add(T x, T y) {
          return x + y;
      }
    };
}</description>
    </item>
    <item rdf:about="https://yanevskiv.com/net-config?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Network Configuration</title>
        <link>https://yanevskiv.com/net-config?rev=1778758708&amp;do=diff</link>
        <description>Network Configuration

This article is about network configuration in GNU/Linux systems

ifupdown

Dynamic configurations

Dynamic configuration with ifupdown (IPv4)



# /etc/network/interfaces
iface ens3 inet dhcp


Dynamic configuration with ifupdwon (IPv6)</description>
    </item>
    <item rdf:about="https://yanevskiv.com/nih-syndrome?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>NIH syndrome</title>
        <link>https://yanevskiv.com/nih-syndrome?rev=1778758708&amp;do=diff</link>
        <description>NIH syndrome

NIH syndrome stands for “Not invented here” syndrome. It&#039;s when you deliberately avoid using a premade solution in favor of your own.

For example, you might prefer to implement your own dynamic array even though std::vector&lt;int&gt; already exist. The commonly given rationale is that you&#039;ll probably find the implementation you made easier to understand (you wrote it!) and you&#039;ll be able easily make it fit your needs.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/nisq?rev=1779717118&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:51:58+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>NISQ</title>
        <link>https://yanevskiv.com/nisq?rev=1779717118&amp;do=diff</link>
        <description>NISQ

NISQ (Noisy Intermediate-Scale Quantum) refers to the current era of quantum computing, characterized by devices with tens to a few thousand qubits that are too noisy for full fault-tolerant quantum error correction. The term was coined by John Preskill in 2018.$10^{-3}$$10^{-2}$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/noon-state?rev=1779716926&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:48:46+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>NOON state</title>
        <link>https://yanevskiv.com/noon-state?rev=1779716926&amp;do=diff</link>
        <description>NOON state

NOON state is an entangled quantum state of two modes in which $N$ photons are in one mode and zero in the other, in an equal superposition with the reverse. It is written as:

$$\lvert N\!:\!0\rangle\!\rangle = \frac{1}{\sqrt{2}}\left(\lvert N\rangle_a\lvert 0\rangle_b + \lvert 0\rangle_a\lvert N\rangle_b\right)$$

NOON states arise naturally in quantum metrology and quantum lithography. Their key property is phase sensitivity that scales as $1/N$$1/\sqrt{N}$$\sqrt{N}$$\phi$$a$$N$$N…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/numbers-every-programmer-should-know?rev=1779495120&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-23T00:12:00+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Numbers every programmer should know</title>
        <link>https://yanevskiv.com/numbers-every-programmer-should-know?rev=1779495120&amp;do=diff</link>
        <description>Numbers every programmer should know

Numbers every programmer should know is a short document listing latencies of various computer operations. The list is given by a computer scientist Jeff Dean.

It illustrates how various high-level operations exponentially take longer time to perform compared to various low-level operations.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/nvcc?rev=1779108594&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-18T12:49:54+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>nvcc</title>
        <link>https://yanevskiv.com/nvcc?rev=1779108594&amp;do=diff</link>
        <description>nvcc

nvcc (or Nvidia C/C++ compiler) is a C++ compiler created by Nvidia that adds CUDA kernel syntax.



 $ nvcc kernel.cu</description>
    </item>
    <item rdf:about="https://yanevskiv.com/one-state?rev=1779717275&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:54:35+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$\lvert 1\rangle$</title>
        <link>https://yanevskiv.com/one-state?rev=1779717275&amp;do=diff</link>
        <description>$\lvert 1\rangle$

The one state $\lvert 1\rangle$ is one of the two computational basis states of a qubit. It is the quantum analogue of a classical 1 bit. The other computational basis state is $\lvert 0\rangle$.

$$\lvert 1\rangle = \begin{pmatrix}0\\ 1\end{pmatrix}$$

On the Bloch sphere, $\lvert 1\rangle$ corresponds to the south pole at coordinates $(0, 0, -1)$. It is an eigenstate of the Pauli-Z gate with eigenvalue $-1$$Z\lvert 1\rangle = -\lvert 1\rangle$$\lvert 0\rangle$$\lvert 1\rangl…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/p-gate?rev=1779716953&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:49:13+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Phase gate</title>
        <link>https://yanevskiv.com/p-gate?rev=1779716953&amp;do=diff</link>
        <description>Phase gate

Phase gate (or P gate) is a single-qubit quantum gate that applies a phase shift $\phi$ to the $\lvert 1\rangle$ component of a qubit while leaving the $\lvert 0\rangle$ component unchanged. It is a rotation about the $z$-axis of the Bloch sphere.

$$P(\phi) = \begin{pmatrix}1 &amp; 0\\ 0 &amp; e^{i\phi}\end{pmatrix}$$

Applied to a general qubit $\lvert\psi\rangle = a\lvert 0\rangle + b\lvert 1\rangle$, the phase gate multiplies the $\lvert 1\rangle$$e^{i\phi}$$$P(\phi)\lvert\psi\rangle = a…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/past-disclaimer?rev=1779714524&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:08:44+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Disclaimer</title>
        <link>https://yanevskiv.com/past-disclaimer?rev=1779714524&amp;do=diff</link>
        <description>Disclaimer

This website is not an authoritative source. It is written by one person -- me. It&#039;s not meant to serve as documentation or a definitive guide to the technology I talk about. I write about topics that interest me and I explain them in the way I understand them</description>
    </item>
    <item rdf:about="https://yanevskiv.com/path-usr?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>/usr</title>
        <link>https://yanevskiv.com/path-usr?rev=1778758708&amp;do=diff</link>
        <description>/usr

	* /usr/bin
	* /usr/include
	* /usr/lib
	* /usr/share
	* /usr/src</description>
    </item>
    <item rdf:about="https://yanevskiv.com/path-var?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>/var</title>
        <link>https://yanevskiv.com/path-var?rev=1778758708&amp;do=diff</link>
        <description>/var

	* /var/cache
	* /var/db
	* /var/empty
	* /var/lib
	* /var/local
	* /var/lock
	* /var/log
	* /var/opt
	* /var/run
	* /var/www
	* /var/spool
	* /var/tmp</description>
    </item>
    <item rdf:about="https://yanevskiv.com/pauli-gate?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Pauli gate</title>
        <link>https://yanevskiv.com/pauli-gate?rev=1778758708&amp;do=diff</link>
        <description>Pauli gate

Pauli gates are one of the three quantum gates $(X, Y, Z)$, which correspond to Pauli matrices $(\sigma_x, \sigma_y, \sigma_z)$, with the inclusion of the identity gate $I$.

For a single qubit, they take the following matrix form
$$I = \begin{pmatrix}1 &amp; 0\\0 &amp; 1\end{pmatrix}\quad 
X = \begin{pmatrix}0 &amp; 1\\ 1 &amp; 0\end{pmatrix}\quad
Y = \begin{pmatrix}0 &amp; i \\ -i &amp; 0 \end{pmatrix}\quad
Z = \begin{pmatrix}1 &amp; 0 \\ 0 &amp; -1\end{pmatrix}$$

They are involutory, meaning they square up to i…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/pdflatex?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>pdflatex</title>
        <link>https://yanevskiv.com/pdflatex?rev=1778758708&amp;do=diff</link>
        <description>pdflatex

pdflatex is the most common LaTeX compiler.

You compile latex source code by running pdflatex main.tex. This creates a PDF file main.pdf. It also creates a log file main.log and an auxiliary file main.aux used to build references. You can ignore these latter two and</description>
    </item>
    <item rdf:about="https://yanevskiv.com/perf?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>perf</title>
        <link>https://yanevskiv.com/perf?rev=1778758708&amp;do=diff</link>
        <description>perf</description>
    </item>
    <item rdf:about="https://yanevskiv.com/playground?rev=1778765281&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T13:28:01+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title></title>
        <link>https://yanevskiv.com/playground?rev=1778765281&amp;do=diff</link>
        <description>\documentclass{standalone}

\begin{document}

\end{document}</description>
    </item>
    <item rdf:about="https://yanevskiv.com/plus-state?rev=1779716839&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:47:19+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$\lvert +\rangle$</title>
        <link>https://yanevskiv.com/plus-state?rev=1779716839&amp;do=diff</link>
        <description>$\lvert +\rangle$

Plus state $\lvert +\rangle$ is a quantum state that is an equal superposition of the two computational basis states $\lvert 0\rangle$ and $\lvert 1\rangle$ with equal positive amplitudes. It is one of the six cardinal states on the Bloch sphere, sitting at the positive $x$-axis.

$$\lvert +\rangle = \frac{1}{\sqrt{2}}\lvert 0\rangle + \frac{1}{\sqrt{2}}\lvert 1\rangle = \frac{1}{\sqrt{2}}\begin{pmatrix}1\\1\end{pmatrix}$$

When measured in the computational basis $\{\lvert 0\…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/posix-headers?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>POSIX headers</title>
        <link>https://yanevskiv.com/posix-headers?rev=1778758708&amp;do=diff</link>
        <description>POSIX headers

POSIX headers are C programming language headers as defined by POSIX.

Links

	* &lt;https://pubs.opengroup.org/onlinepubs/9799919799/idx/head.html&gt;</description>
    </item>
    <item rdf:about="https://yanevskiv.com/pragma-once?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>#pragma once</title>
        <link>https://yanevskiv.com/pragma-once?rev=1778758708&amp;do=diff</link>
        <description>#pragma once

In C and C++ programming languages #pragma once is a non-standard preprocessor directive that is equivalent to header guards.

You just put #pragma once at the top, rather than wrapping the entire header within header guards.

Header guards:


// image.h
#ifndef __IMAGE_H__
#define __IMAGE_H__

struct Image {
    ...
};

#endif /* __IMAGE_H__ */</description>
    </item>
    <item rdf:about="https://yanevskiv.com/probability-amplitude?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Probability amplitude</title>
        <link>https://yanevskiv.com/probability-amplitude?rev=1778758708&amp;do=diff</link>
        <description>Probability amplitude

Probability amplitude is a complex number associated with a quantum state. The square modulus of that complex number is -- according to the Born rule -- the probability of finding the quantum system in that state. 

If we take 
$$\lvert\psi\rangle = a\lvert 0\rangle + b\lvert 1\rangle$$

Concrete example</description>
    </item>
    <item rdf:about="https://yanevskiv.com/pure-state?rev=1779717261&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:54:21+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Pure state</title>
        <link>https://yanevskiv.com/pure-state?rev=1779717261&amp;do=diff</link>
        <description>Pure state

Pure state is a quantum state that is completely described by a single state vector $\lvert\psi\rangle$. It carries the maximum possible information about a quantum system. When information about the system leaks into the environment the state becomes mixed — this process is called decoherence, and it is one of the primary challenges in quantum computing.$0\,\text{V}$$5\,\text{V}$$\lvert\psi\rangle = a\lvert 0\rangle + b\lvert 1\rangle$$a$$b$$\lvert\psi\rangle$$\rho = \lvert\psi\rang…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/qaoa?rev=1779717132&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:52:12+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>QAOA</title>
        <link>https://yanevskiv.com/qaoa?rev=1779717132&amp;do=diff</link>
        <description>QAOA

QAOA (Quantum Approximate Optimization Algorithm) is a hybrid quantum-classical algorithm for combinatorial optimization problems. It was introduced by Edward Farhi, Jeffrey Goldstone, and Sam Gutmann in 2014 and is one of the leading candidates for near-term quantum advantage on $p$$(\boldsymbol\gamma, \boldsymbol\beta)$$\lvert s\rangle = H^{\otimes n}\lvert 0\rangle^{\otimes n}$$H_C$$H_B = \sum_i X_i$$p$$$\lvert\boldsymbol{\gamma},\boldsymbol{\beta}\rangle = e^{-i\beta_p H_B}e^{-i\gamma_…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/qft?rev=1779717046&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:50:46+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Quantum Fourier transform</title>
        <link>https://yanevskiv.com/qft?rev=1779717046&amp;do=diff</link>
        <description>Quantum Fourier transform

Quantum Fourier transform (QFT) is the quantum analogue of the discrete Fourier transform (DFT). It maps a computational basis state $\lvert j\rangle$ to a superposition whose amplitudes encode the DFT of the input amplitudes, for $N = 2^n$ states on $n$$$\text{QFT}\lvert j\rangle = \frac{1}{\sqrt{N}}\sum_{k=0}^{N-1} e^{2\pi ijk/N}\lvert k\rangle$$$O(n^2)$$n$$O(N \log N) = O(n \cdot 2^n)$$n$$n(n+1)/2$$$R_k = P\!\left(\frac{2\pi}{2^k}\right) = \begin{pmatrix}1 &amp; 0 \\ 0 …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/qpe?rev=1779717058&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:50:58+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Quantum phase estimation</title>
        <link>https://yanevskiv.com/qpe?rev=1779717058&amp;do=diff</link>
        <description>Quantum phase estimation

Quantum phase estimation (QPE) is a quantum algorithm that estimates the eigenvalue phase $\phi$ of a unitary operator $U$ given access to an eigenstate $\lvert u\rangle$ of $U$. It is one of the most important subroutines in quantum computing, used as a building block in $U\lvert u\rangle = e^{2\pi i\phi}\lvert u\rangle$$\phi \in [0,1)$$\phi$$n$$n$$O(2^n)$$U$$n$$\lvert 0\rangle^{\otimes n}$$\lvert u\rangle$$n$$U^{2^k}$$k = 0, 1, \ldots, n-1$$k$$U^{2^k}$$$\lvert 0\rangl…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/quantum-algorithm?rev=1779717335&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:55:35+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Quantum algorithm</title>
        <link>https://yanevskiv.com/quantum-algorithm?rev=1779717335&amp;do=diff</link>
        <description>Quantum algorithm

Quantum algorithm is an algorithm designed to run on a quantum computer, exploiting quantum phenomena such as superposition, entanglement, and interference to solve certain problems faster than any known classical algorithm. Quantum algorithms are expressed as sequences of quantum gates applied to a quantum register, followed by measurements.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/quantum-circuit?rev=1779717013&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:50:13+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Quantum circuit</title>
        <link>https://yanevskiv.com/quantum-circuit?rev=1779717013&amp;do=diff</link>
        <description>Quantum circuit

Quantum circuit is a model of quantum computation in which a sequence of quantum gates is applied to a quantum register. Quantum circuits are the quantum analogue of classical digital circuits, but instead of Boolean logic gates acting on bits they use unitary matrices acting on qubits.$\lvert 0\rangle^{\otimes n}$$d$$n$$nd$$\{H, T, \text{CNOT}\}$$\varepsilon$$O(\text{polylog}(1/\varepsilon))$$\lvert 0\rangle$$\lvert 1\rangle$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/quantum-gate?rev=1779704059&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T10:14:19+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Quantum gate</title>
        <link>https://yanevskiv.com/quantum-gate?rev=1779704059&amp;do=diff</link>
        <description>Quantum gate

Quantum gates are the quantum computing equivalent of classical logic gates like AND, OR, XOR, NOT.

Classical logic gates are defined by their truth tables. They follow a mathematical structure called Boolean algebra. With the advancement of MOSFET transistor it became possible to implement these logic gates electrically.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/quantum-i-gate?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Quantum I gate</title>
        <link>https://yanevskiv.com/quantum-i-gate?rev=1778758708&amp;do=diff</link>
        <description>Quantum I gate

Quantum I gate (or Identity gate) is a quantum gate that leaves the quantum state unchanged. In quantum circuits it&#039;s commonly written as wire. In matrix form, it&#039;s equivalent to the identity matrix.

$$I = \begin{pmatrix} 1 &amp; 0\\ 0 &amp; 1\end{pmatrix}$$

Effect

Z basis states

For states along the Z-axis:
$$I\lvert 0\rangle =\lvert 0\rangle\qquad I\lvert 1\rangle = \lvert 1 \rangle$$$$I\lvert i\rangle =\lvert i\rangle\qquad I\lvert -i\rangle = \lvert -i \rangle$$$$I\lvert +\rangle…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/quantum-register?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Quantum register</title>
        <link>https://yanevskiv.com/quantum-register?rev=1778758708&amp;do=diff</link>
        <description>Quantum register

Quantum register is a register made out of qubits. It is the quantum equivalent of a classical CPU register.

A classical CPU registers such as x86-64 registers (rax rbx rcx rdx rdi rsi) are made out of 64 bits on modern CPU architectures. A 64-bit register can store any whole number from 0 to 18446744073709551616, which is big! The CPU can efficiently manipulate these by running instructions over them, such as $\lvert\psi\rangle$$a,b\in\mathbb{C}$$$\lvert\psi\rangle = a\lvert …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/quantum-x-gate?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Quantum X gate</title>
        <link>https://yanevskiv.com/quantum-x-gate?rev=1778758708&amp;do=diff</link>
        <description>Quantum X gate

Quantum X gate (or Pauli-X gate, quantum NOT gate) is a quantum gate that is analogous to the classical “NOT” or “bit flip”. For a single qubit, it applies a rotation around the X-axis by $\pi$ on the Bloch sphere. In matrix form, X gate is equivalently written as a Pauli matrix $\sigma_x$$$X = \begin{pmatrix}0 &amp; 1\\ 1 &amp; 0\end{pmatrix}$$$\lvert0\rangle,\lvert 1\rangle$$$X\lvert 0\rangle = \lvert 1\rangle\qquad X\lvert 1\rangle = \lvert 0\rangle$$$\lvert i\rangle, \lvert -i\rangle…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/quantum-y-gate?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Quantum Y gate</title>
        <link>https://yanevskiv.com/quantum-y-gate?rev=1778758708&amp;do=diff</link>
        <description>Quantum Y gate

Quantum Y gate (or Pauli-Y gate) is a quantum gate. It rotates the quantum state by $\pi$ degrees around the Y-axis on the Bloch sphere. In matrix form, it is equivalent to Pauli matrix $\sigma_y$ which is why it&#039;s commonly called Pauli-Y gate.

$$Y = \begin{pmatrix}0 &amp; -i\\ i &amp; 0\end{pmatrix}$$

In some ways, it acts as an alternative to $\pi / 2$$i$$$Y\lvert 1\rangle = \lvert 0\rangle\qquad Y\lvert 0\rangle = \lvert 1 \rangle$$$$Y\lvert +\rangle = \lvert -\rangle\qquad Y\lvert …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/quantum-z-gate?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Quantum Z gate</title>
        <link>https://yanevskiv.com/quantum-z-gate?rev=1778758708&amp;do=diff</link>
        <description>Quantum Z gate

Quantum Z gate (or Pauli-Z gate, phase flip gate) is a quantum gate. It rotates the quantum state around the computational axis (the Z-axis) by $\pi$ degrees. In matrix form, it is equivalent to the Pauli-Z matrix $\sigma_z$. This is why it&#039;s commonly called Pauli-Z gate.$$Z = \begin{pmatrix}1 &amp; 0 \\ 0 &amp; -1\end{pmatrix}$$$\lvert 0\rangle$$\lvert 1\rangle$$\pi$$$Z\lvert 0\rangle = \lvert 0\rangle\qquad Z\lvert 1\rangle = -\lvert 1\rangle$$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/qubit-gates-in-c?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Qubit gate</title>
        <link>https://yanevskiv.com/qubit-gates-in-c?rev=1778758708&amp;do=diff</link>
        <description>Qubit gate

Simulation

In C99, a header &lt;complex.h&gt; is provided that implements complex numbers.

State

As we&#039;ve seen, a qubit is a two-state configuration with complex probability amplitudes distributed between the two states.
This gives us the following implementation of a single qubit:
$$\lvert\psi\rangle = \alpha\lvert 0\rangle + \beta\lvert 1\rangle,\qquad \alpha,\beta\in\mathbb C$$$$\lVert\psi\lVert^2 = |\alpha|^2 + |\beta|^2 = \alpha\bar{\alpha} + \beta\bar{\beta}$$$$\lvert\psi\rangle\r…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/qubit?rev=1779715005&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:16:45+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Qubit</title>
        <link>https://yanevskiv.com/qubit?rev=1779715005&amp;do=diff</link>
        <description>Qubit

Qubit is the quantum computing equivalent of a bit.

A classical bit can be 0 or 1. There are no probabilities involved at all, but we can assign them anyway. If a bit is 1, then it&#039;s 1 with 100% probability and 0 with 0% probability. Conversely, if a bit is $\lvert 0\rangle$$\lvert 1\rangle$$\lvert 0\rangle$$\lvert 1\rangle$$\lvert\psi\rangle$$$\lvert\psi\rangle = a\lvert 0\rangle + b\lvert 1\rangle$$$a$$b$$\lvert 0\rangle$$a = \frac{\sqrt 2}{2} + i\frac{\sqrt 2}{2}$$\lvert 1\rangle$$b =…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/r-gate?rev=1779717325&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:55:25+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Rotation gates</title>
        <link>https://yanevskiv.com/r-gate?rev=1779717325&amp;do=diff</link>
        <description>Rotation gates

Rotation gates $R_x(\theta)$, $R_y(\theta)$, $R_z(\theta)$ are single-qubit gates that rotate the Bloch vector by angle $\theta$ about the $x$-, $y$-, and $z$-axes respectively. They are defined via the matrix exponential of the corresponding Pauli matrices.

$$R_x(\theta) = e^{-i\theta X/2}, \qquad R_y(\theta) = e^{-i\theta Y/2}, \qquad R_z(\theta) = e^{-i\theta Z/2}$$

Matrix form

Applying the matrix exponential $e^{-i\theta P/2} = \cos(\theta/2)I - i\sin(\theta/2)P$$X^2 = Y^2…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/rabi-cycles?rev=1779717171&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:52:51+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Rabi oscillations</title>
        <link>https://yanevskiv.com/rabi-cycles?rev=1779717171&amp;do=diff</link>
        <description>Rabi oscillations

Rabi oscillations (or Rabi cycles) are periodic oscillations in the state of a driven two-level quantum system. When a qubit is driven by a resonant electromagnetic field, its population continuously oscillates between $\lvert 0\rangle$ and $\lvert 1\rangle$ at the Rabi frequency $\Omega$$\omega = \omega_0$$\omega_0$$\Omega$$\lvert 1\rangle$$\lvert 0\rangle$$$P_1(t) = \sin^2\!\left(\frac{\Omega t}{2}\right), \qquad P_0(t) = \cos^2\!\left(\frac{\Omega t}{2}\right)$$$\lvert 0\ra…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ramsey-interference?rev=1779717186&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:53:06+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Ramsey interferometry</title>
        <link>https://yanevskiv.com/ramsey-interference?rev=1779717186&amp;do=diff</link>
        <description>Ramsey interferometry

Ramsey interferometry is a technique for measuring the transition frequency of a quantum system with very high precision using two separated pulses. It was developed by Norman Ramsey in 1950 as an improvement on Rabi&#039;s continuous-drive spectroscopy, and it forms the basis of modern atomic clocks and qubit frequency calibration.$\pi/2$$T$$\pi/2$$\lvert +\rangle$$\lvert 0\rangle$$T$$\delta T$$\delta = \omega - \omega_0$$\omega$$\omega_0$$\pi/2$$$P_1(T) = \frac{1}{2}(1 - \cos…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ruin-theory?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Ruin theory (personal finance)</title>
        <link>https://yanevskiv.com/ruin-theory?rev=1778758708&amp;do=diff</link>
        <description>Ruin theory (personal finance)

This article is supposed to illustrate using Cramer-Lundberg model from actuarial science and applying to personal finance. This model was invented in 1930s for insurance companies. Insurance companies never seem to go bankrupt yet ordinary people are often get financial struggles. While it&#039;s easy to blame insurance companies for cheating at the game and ripping us off (and there is certainly a lot of truth to that), perhaps we can also learn the game they&#039;re play…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/rule-of-5?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Rule of 5</title>
        <link>https://yanevskiv.com/rule-of-5?rev=1778758708&amp;do=diff</link>
        <description>Rule of 5

In C++, rule of 5

	* Destructor
* Copy constructor
* Move constructor
* Copy assignment operator
* Move assignment operator


#pragma once

struct Image {
public:
    Image();
    /* Todo */
};


Links

	* &lt;https://en.cppreference.com/w/cpp/language/rule_of_three.html&gt;</description>
    </item>
    <item rdf:about="https://yanevskiv.com/rwa?rev=1779717197&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:53:17+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Rotating wave approximation</title>
        <link>https://yanevskiv.com/rwa?rev=1779717197&amp;do=diff</link>
        <description>Rotating wave approximation

Rotating wave approximation (RWA) is an approximation in quantum optics and quantum control that simplifies the Hamiltonian of a driven quantum system by discarding rapidly oscillating terms. It reduces the full time-dependent driven Hamiltonian to a simpler time-independent one in the rotating frame, making $\omega_0$$\omega$$\delta = \omega - \omega_0$$\omega + \omega_0$$\omega$$\rho \to e^{i\omega t Z/2}\rho e^{-i\omega t Z/2}$$$H_{\text{RWA}} = \frac{\hbar}{2}\be…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/saxpy?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>SAXPY</title>
        <link>https://yanevskiv.com/saxpy?rev=1778758708&amp;do=diff</link>
        <description>SAXPY

SAXPY is an algorithm in high-performance computing (HPC).

Math

Vectors

Let $\mathbf{y}^{(t)}, \mathbf{x}^{(t)}\in\mathbb{R}^n$ be vectors over real numbers at some discrete time $t\in\mathbb{N}$ and let $a\in\mathbb{R}$ be a real parameter.

SAXPY is defined as a vector update of $\mathbf{y}$ at time $t+1$ according to the formula:

$$\mathbf{y}^{(t+1)} = a\mathbf{x}^{(t)} + \mathbf{y}^{(t)}$$

Elements
$\mathbf{y}^{(t)} = (y_0^{(t)}, y_1^{(t)}, \dots, y_n^{(t)})$$\mathbf{x}^{(t)} = (…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/schrodinger-equation?rev=1779494585&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-23T00:03:05+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Schrödinger equation</title>
        <link>https://yanevskiv.com/schrodinger-equation?rev=1779494585&amp;do=diff</link>
        <description>Schrödinger equation

In quantum mechanics, wave function is a mathematical object used to  describe a quantum particle. This wave function evolves according to the Schrödinger equation. For a single particle, the time-dependent 3-dimensional Schrödinger equation is stated as the following:$$ i\hbar \frac{\partial}{\partial t}\Psi = \left(-\frac{\hbar^2}{2m}\nabla^2 + V\right) \Psi$$$i$$i^2 + 1 = 0$$\hbar$$\hbar = h/2\pi$$\hbar \approx 1.054 571 817\times 10^{-34}J\cdot s$$\partial / \partial t$…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/semaphore.h?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title></title>
        <link>https://yanevskiv.com/semaphore.h?rev=1778758708&amp;do=diff</link>
        <description>&lt;semaphore.h&gt;

In C, &lt;semaphore.h&gt; is a header that offers POSIX semaphores.

Manual

	* &lt;https://pubs.opengroup.org/onlinepubs/7908799/xsh/semaphore.h.html&gt;</description>
    </item>
    <item rdf:about="https://yanevskiv.com/semaphore?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Semaphore</title>
        <link>https://yanevskiv.com/semaphore?rev=1778758708&amp;do=diff</link>
        <description>Semaphore

Semaphore is a synchronization primitive. It&#039;s used to control thread execution in multithreaded environments.

A semaphore acts like an integer. An integer supports two well-known opeartions: increment i++ and decrement i--. A semaphore works in a similar way, except a semaphore cannot be decremented below zero. This is because semaphore takes action to protect its value against bankrupcy by taking hostage of threads that attempt to make it negative.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/shell?rev=1778764029&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T13:07:09+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Shell</title>
        <link>https://yanevskiv.com/shell?rev=1778764029&amp;do=diff</link>
        <description>Shell

What is a shell?

Shell is a program that lets you to run other programs in the terminal. 

Shell allows you to pass command line arguments, set environment variables and redirect the program&#039;s stardard input / output / error. It allows you to chain programs, such that output from one program is redirected as input to another program. It also allows you to run the programs in the background. Basically, a shell allows you to easily orchestrate programs in the terminal.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/shor?rev=1779717082&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:51:22+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Shor&#039;s algorithm</title>
        <link>https://yanevskiv.com/shor?rev=1779717082&amp;do=diff</link>
        <description>Shor&#039;s algorithm

Shor&#039;s algorithm is a quantum algorithm that factors large integers in polynomial time. It was invented by Peter Shor in 1994 and is one of the most consequential results in quantum computing, because it would break the RSA public-key cryptosystem if run on a sufficiently large fault-tolerant quantum computer.$O(e^{O(n^{1/3}\log^{2/3} n)})$$n$$O(n^3)$$O(n)$$N$$a$$\gcd(a, N) = 1$$r$$a^r \equiv 1 \pmod{N}$$r$$a^{r/2} \not\equiv -1 \pmod{N}$$\gcd(a^{r/2} \pm 1, N)$$N$$1/2$$x \in \…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/ssh?rev=1778943426&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-16T14:57:06+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>ssh</title>
        <link>https://yanevskiv.com/ssh?rev=1778943426&amp;do=diff</link>
        <description>ssh

What is ssh?

SSH (Secure shell) is a tool that allows you to remotely control another computer from your own. 

Login without password

On the client, you should run the following command:



ssh-keyring


This command is going to generate two files in your</description>
    </item>
    <item rdf:about="https://yanevskiv.com/state-vector?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>State vector</title>
        <link>https://yanevskiv.com/state-vector?rev=1778758708&amp;do=diff</link>
        <description>State vector

State vector is the vector representation of a quantum state.

Quantum state is often written as a linear combination of basis states where the coefficients are  probability amplitudes. For example, a qubit is often written in the following way using Dirac notation.$$\lvert\psi\rangle = a\lvert 0\rangle + b\lvert 1\rangle$$$\mathbb{C}^2$$\mathbb{C}^2$$\lvert\psi\rangle$$\mathbb{C}^2$$$\lvert\psi\rangle = \begin{pmatrix}a\\b\end{pmatrix}\qquad a,b\in\mathbb{C}$$$$\lvert\psi\rangle =…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/stdbool.h?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title></title>
        <link>https://yanevskiv.com/stdbool.h?rev=1778758708&amp;do=diff</link>
        <description>&lt;stdbool.h&gt;

In C programming language, &lt;stdbool.h&gt; is a header that&#039;s part of C standard library. It defines a boolean type bool as well as constants  true and false.

You need at least version C99 to use this header, so compile with gcc -std=c99 main.c -o program.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/string.h?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title></title>
        <link>https://yanevskiv.com/string.h?rev=1778758708&amp;do=diff</link>
        <description>&lt;string.h&gt;

In C programming language, &lt;string.h&gt; is a header for void* and char* types, presumably spanning many consequtive characters.

Functions


/* Memory functions */
void    *memccpy(void *, const void *, int, size_t);
void    *memchr(const void *, int, size_t);
int      memcmp(const void *, const void *, size_t);
void    *memcpy(void *, const void *, size_t);
void    *memmove(void *, const void *, size_t);
void    *memset(void *, int, size_t);

/* String functions */
char    *strcat(cha…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/strunk-and-white?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Strunk &amp; White</title>
        <link>https://yanevskiv.com/strunk-and-white?rev=1778758708&amp;do=diff</link>
        <description>Strunk &amp; White

Strunk &amp; White is a guide on writing text in the English language. The guide is contained in a book  titled “The Elements of Style”. It was written written by William Strunk Jr. in the 1910s and later expanded by E. B. White in the 1950s.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/swap-gate?rev=1779716993&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:49:53+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>SWAP gate</title>
        <link>https://yanevskiv.com/swap-gate?rev=1779716993&amp;do=diff</link>
        <description>SWAP gate

SWAP gate is a two-qubit quantum gate that exchanges the states of two qubits. It is its own inverse ($\text{SWAP}^2 = I$) and is symmetric with respect to its two qubits.

$$\text{SWAP} = \begin{pmatrix}1 &amp; 0 &amp; 0 &amp; 0\\ 0 &amp; 0 &amp; 1 &amp; 0\\ 0 &amp; 1 &amp; 0 &amp; 0\\ 0 &amp; 0 &amp; 0 &amp; 1\end{pmatrix}$$

The SWAP gate acts on the computational basis as follows.

$$\text{SWAP}\lvert 00\rangle = \lvert 00\rangle, \quad \text{SWAP}\lvert 01\rangle = \lvert 10\rangle, \quad \text{SWAP}\lvert 10\rangle = \lvert 0…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/syntax?rev=1778765950&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T13:39:10+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title></title>
        <link>https://yanevskiv.com/syntax?rev=1778765950&amp;do=diff</link>
        <description>[GitHub][gh]
fdsafdsa</description>
    </item>
    <item rdf:about="https://yanevskiv.com/terminal?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Terminal</title>
        <link>https://yanevskiv.com/terminal?rev=1778758708&amp;do=diff</link>
        <description>Terminal

Terminal is conceptually anything that looks like a keyboard + a screen attached to a teletype device (TTY). It gives humans the ability to use the teletype device.

When you type something in a terminal, the terminal sends your characters to the teletype device. When a teletype device responds, the terminal prints the result back to you. A terminal can also reinterpret the characters coming from the teletype device and change its behavior in some way (e.g. change cursor location or tu…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/test-driven-development?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Test-driven development</title>
        <link>https://yanevskiv.com/test-driven-development?rev=1778758708&amp;do=diff</link>
        <description>Test-driven development

Test-driven development (or TDD) is a practice where you apprach software development in the following way:

	* You write a test. This test fails immediately, as you haven&#039;t even written any code yet.
* You write the smallest piece of code that passes your test</description>
    </item>
    <item rdf:about="https://yanevskiv.com/thinkpad?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>ThinkPad</title>
        <link>https://yanevskiv.com/thinkpad?rev=1778758708&amp;do=diff</link>
        <description>ThinkPad

X-series
x220ai</description>
    </item>
    <item rdf:about="https://yanevskiv.com/three-qubits?rev=1779716889&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:48:09+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Three qubits</title>
        <link>https://yanevskiv.com/three-qubits?rev=1779716889&amp;do=diff</link>
        <description>Three qubits

Three-qubit system is a quantum system consisting of three qubits. The state space is the tensor product $\mathbb{C}^2 \otimes \mathbb{C}^2 \otimes \mathbb{C}^2 \cong \mathbb{C}^8$, spanned by eight computational basis states. A general three-qubit state requires eight complex probability amplitudes.

$$\lvert\psi\rangle = \sum_{x \in \{0,1\}^3} c_x\lvert x\rangle = c_{000}\lvert 000\rangle + c_{001}\lvert 001\rangle + c_{010}\lvert 010\rangle + c_{011}\lvert 011\rangle + \cdots + …</description>
    </item>
    <item rdf:about="https://yanevskiv.com/tmux?rev=1778943419&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-16T14:56:59+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>tmux</title>
        <link>https://yanevskiv.com/tmux?rev=1778943419&amp;do=diff</link>
        <description>tmux

What is tmux?

Tmux is a terminal multiplexer. It allows you to run multiple terminals in a single terminal. In this sense, it is an alternative to screen command.

Tmux runs a background session that you can attach to. It gives you the ability to create multiple windows within a session. Then it also gives you the ability to create multiple panes within a window, and tile them. Each pane contains a terminal. Thus, you can think of tmux as a</description>
    </item>
    <item rdf:about="https://yanevskiv.com/todo?rev=1778764571&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T13:16:11+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>To do</title>
        <link>https://yanevskiv.com/todo?rev=1778764571&amp;do=diff</link>
        <description>To do

This page contains articles which I&#039;m in the process of writing or plan to write about.

Fix things

	* Annoying scroll when opening sitemap
	* Clicking on the logo should navigate to / instead of /home
	* Clean up the HTML in the page

Website</description>
    </item>
    <item rdf:about="https://yanevskiv.com/toffoli-gate?rev=1779716985&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:49:45+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Toffoli gate</title>
        <link>https://yanevskiv.com/toffoli-gate?rev=1779716985&amp;do=diff</link>
        <description>Toffoli gate

Toffoli gate (also known as the CCNOT gate or doubly-controlled NOT) is a three-qubit quantum gate that flips the target qubit if and only if both control qubits are in state $\lvert 1\rangle$. It is named after Tommaso Toffoli, who introduced it in 1980.$\lvert a, b, c\rangle \mapsto \lvert a, b, c \oplus (a \wedge b)\rangle$$\oplus$$\wedge$$8\times 8$$8\times 8$$$\text{CCNOT} = \begin{pmatrix}
1 &amp; 0 &amp; 0 &amp; 0 &amp; 0 &amp; 0 &amp; 0 &amp; 0\\
0 &amp; 1 &amp; 0 &amp; 0 &amp; 0 &amp; 0 &amp; 0 &amp; 0\\
0 &amp; 0 &amp; 1 &amp; 0 &amp; 0 &amp; 0 &amp;…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/topics?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Topics I plan to write about</title>
        <link>https://yanevskiv.com/topics?rev=1778758708&amp;do=diff</link>
        <description>Topics I plan to write about

Wikipedia

	* Trace theory
	* Pi calculus
	* History monoid

Concepts

	* Hazard pointer
	* ABA problem
	* Cache coherence (MSI MESI MOESI DragonFly)</description>
    </item>
    <item rdf:about="https://yanevskiv.com/two-qubits?rev=1779716869&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:47:49+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Two qubits</title>
        <link>https://yanevskiv.com/two-qubits?rev=1779716869&amp;do=diff</link>
        <description>Two qubits

Two-qubit system is a quantum system consisting of two qubits. The state space is the tensor product $\mathbb{C}^2 \otimes \mathbb{C}^2 \cong \mathbb{C}^4$, and a general two-qubit state is a superposition over four computational basis states: $\lvert 00\rangle$, $\lvert 01\rangle$, $\lvert 10\rangle$, and $\lvert 11\rangle$.

A general two-qubit state $\lvert\psi\rangle$ requires four complex probability amplitudes $c_{00}, c_{01}, c_{10}, c_{11} \in \mathbb{C}$$|c_{00}|^2 + |c_{01}…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/u-gate?rev=1779716964&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:49:24+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>U gate</title>
        <link>https://yanevskiv.com/u-gate?rev=1779716964&amp;do=diff</link>
        <description>U gate

U gate is the most general single-qubit unitary gate, parameterized by three real angles $\theta$, $\phi$, $\lambda$. Every single-qubit unitary operation (up to global phase) can be expressed as $U(\theta, \phi, \lambda)$ for some choice of these angles.

$$U(\theta, \phi, \lambda) = \begin{pmatrix}\cos\dfrac{\theta}{2} &amp; -e^{i\lambda}\sin\dfrac{\theta}{2}\\[6pt] e^{i\phi}\sin\dfrac{\theta}{2} &amp; e^{i(\phi+\lambda)}\cos\dfrac{\theta}{2}\end{pmatrix}$$

The parameter $\theta$ controls how…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/vps?rev=1778943493&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-16T14:58:13+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>VPS</title>
        <link>https://yanevskiv.com/vps?rev=1778943493&amp;do=diff</link>
        <description>VPS

What is a VPS?

VPS (Virtual private server) is a virtual computer that you can buy from a cloud provider. It can do almost anything a real computer can. A VPS slice is often a virtual machine (QEMU + KVM) given to you by a cloud privder, with GNU/Linux pre-installed.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/vqe?rev=1779717143&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:52:23+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>VQE</title>
        <link>https://yanevskiv.com/vqe?rev=1779717143&amp;do=diff</link>
        <description>VQE

VQE (Variational Quantum Eigensolver) is a hybrid quantum-classical algorithm for estimating the ground state energy of a quantum system. It was proposed in 2014 by Peruzzo et al. and is one of the most important algorithms for near-term NISQ devices, with applications in quantum chemistry and materials science.$\lvert\psi(\boldsymbol\theta)\rangle$$H$$E_0$$$E_0 \leq \langle\psi(\boldsymbol\theta)\rvert H\lvert\psi(\boldsymbol\theta)\rangle$$$\lvert\psi(\boldsymbol\theta)\rangle$$\boldsymbo…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/w-state?rev=1779716915&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:48:35+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>W state</title>
        <link>https://yanevskiv.com/w-state?rev=1779716915&amp;do=diff</link>
        <description>W state

W state is an entangled three-qubit state that is an equal superposition over all configurations with exactly one qubit in state $\lvert 1\rangle$ and the others in $\lvert 0\rangle$.

$$\lvert W\rangle = \frac{1}{\sqrt{3}}(\lvert 001\rangle + \lvert 010\rangle + \lvert 100\rangle)$$

The W state was identified by Wolfgang Dür, Guifré Vidal, and J. Ignacio Cirac in 2000 as part of their classification of three-qubit entanglement. Unlike the $n$$n$$\lvert 1\rangle$$$\lvert W_n\rangle = \…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/wip-example?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>(WIP) Work in Progress</title>
        <link>https://yanevskiv.com/wip-example?rev=1778758708&amp;do=diff</link>
        <description>(WIP) Work in Progress</description>
    </item>
    <item rdf:about="https://yanevskiv.com/writing-guide?rev=1779716312&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:38:32+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Writing guide</title>
        <link>https://yanevskiv.com/writing-guide?rev=1779716312&amp;do=diff</link>
        <description>Writing guide

Writing guide (this article) is a guide to writing articles in this wiki.

Every article should preferably start with a main section followed by a few paragraphs. The first paragraph should preferably start with the name of the article in bold (just as it did in this article) followed by a few sentences that further describe the concept.$\alpha,\beta,\gamma$$X$$$X = \begin{pmatrix} 0 &amp; 1 \\ 1 &amp; 0 \end{pmatrix}$$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/x-gate?rev=1779704472&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T10:21:12+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>X-gate</title>
        <link>https://yanevskiv.com/x-gate?rev=1779704472&amp;do=diff</link>
        <description>X-gate

X-gate (or Pauli-X gate / Quantum NOT gate) is a 1-qubit quantum gate that serves as the quantum equivalent of logical NOT. It&#039;s represented by the following 2×2 matrix.

$$ X = \begin{pmatrix}0 &amp; 1\\ 1 &amp; 0\end{pmatrix}$$

The gate flips $\lvert 0\rangle$ to $\lvert 1\rangle$, and $\lvert 1\rangle$ to $\lvert 0\rangle$, which is why it&#039;s called the quantum equivalent of NOT.$\pi$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/x220-gpu-rendering-with-hyprland?rev=1779736963&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T19:22:43+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>GPU Rendering Artifacts on ThinkPad X220 with Hyprland — Diagnosis &amp; Fix</title>
        <link>https://yanevskiv.com/x220-gpu-rendering-with-hyprland?rev=1779736963&amp;do=diff</link>
        <description>GPU Rendering Artifacts on ThinkPad X220 with Hyprland — Diagnosis &amp; Fix

Hardware &amp; Software Context
  ------ Machine  Lenovo ThinkPad X220 (4291SWP)  GPU  Intel HD Graphics 3000 — Sandy Bridge, Gen 6  Kernel driver  i915  Mesa driver  crocus (Gallium3D for Intel Gen 4–8)</description>
    </item>
    <item rdf:about="https://yanevskiv.com/y-gate?rev=1779717302&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:55:02+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Y gate</title>
        <link>https://yanevskiv.com/y-gate?rev=1779717302&amp;do=diff</link>
        <description>Y gate

Y gate (or Pauli-Y gate) is a single-qubit quantum gate represented by the second Pauli matrix. It combines the actions of the X gate (bit flip) and the Z gate (phase flip), and also introduces a factor of $i$.

$$Y = \begin{pmatrix}0 &amp; -i \\ i &amp; 0\end{pmatrix}$$

The gate maps the computational basis states as $Y\lvert 0\rangle = i\lvert 1\rangle$$Y\lvert 1\rangle = -i\lvert 0\rangle$$\pi$$y$$Y$$Y^\dagger = Y$$Y^\dagger Y = I$$Y^2 = I$$Y = iXZ$$\lvert i\rangle$$+1$$\lvert -i\rangle$$-1$</description>
    </item>
    <item rdf:about="https://yanevskiv.com/yanevskiv-wiki?rev=1778758708&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-14T11:38:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Wiki</title>
        <link>https://yanevskiv.com/yanevskiv-wiki?rev=1778758708&amp;do=diff</link>
        <description>Wiki

This is a meta article about this website.

This website is my creation 

Challenges

Writing this website presents some unique challenges. How do I write down my notes but also make the information useful to the reader? If this website was only about putting my notes, I wouldn&#039;t have to use words at all. I could make articles where I just slap some links and call it a day. That would be useful to me, but not to the wider audience.</description>
    </item>
    <item rdf:about="https://yanevskiv.com/z-gate?rev=1779717314&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:55:14+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Z gate</title>
        <link>https://yanevskiv.com/z-gate?rev=1779717314&amp;do=diff</link>
        <description>Z gate

Z gate (or Pauli-Z gate) is a single-qubit quantum gate that applies a phase flip to the $\lvert 1\rangle$ state while leaving $\lvert 0\rangle$ unchanged. It is the third Pauli matrix and a special case of the phase gate $P(\pi)$.

$$Z = \begin{pmatrix}1 &amp; 0\\ 0 &amp; -1\end{pmatrix}$$

The Z gate maps the computational basis states as $Z\lvert 0\rangle = \lvert 0\rangle$ and $Z\lvert 1\rangle = -\lvert 1\rangle$. It does not change measurement outcomes in the computational basis (since $|-…</description>
    </item>
    <item rdf:about="https://yanevskiv.com/zero-state?rev=1779717268&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-25T13:54:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>$\lvert 0\rangle$</title>
        <link>https://yanevskiv.com/zero-state?rev=1779717268&amp;do=diff</link>
        <description>$\lvert 0\rangle$

The zero state $\lvert 0\rangle$ is one of the two computational basis states of a qubit. It is the quantum analogue of a classical 0 bit, and it is the standard initial state used in most quantum circuits. The other computational basis state is $\lvert 1\rangle$.
$$\lvert 0\rangle = \begin{pmatrix}1\\0\end{pmatrix}$$$\lvert 0\rangle$$(0, 0, 1)$$+1$$Z\lvert 0\rangle = \lvert 0\rangle$$\lvert 0\rangle$$\lvert +\rangle = (\lvert 0\rangle + \lvert 1\rangle)/\sqrt{2}$</description>
    </item>
</rdf:RDF>
